[v4,1/3] mongoose: Update to version 7.4

This is the latest unmodified upstream mongoose 7.4 amalgamation.

Signed-off-by: James Hilliard <james.hilliard1@gmail.com>
---
 mongoose/mongoose.c | 19555 +++++++++---------------------------------
 mongoose/mongoose.h |  6804 ++-------------
 2 files changed, 4891 insertions(+), 21468 deletions(-)

Hi James,

On 19.10.21 13:25, James Hilliard wrote:
> This is the latest unmodified upstream mongoose 7.4 amalgamation.
> 
> Signed-off-by: James Hilliard <james.hilliard1@gmail.com>
> ---

I have not taken a deep look, but I applied in my devel branch and start 
to test. It seems at least not compatible because the Webserver is not 
started at all:

I run the same command in -master and with your patches applied:

swupdate -l 5 -H testboard:1.0 -K own-ci-tests/etc/aeskey -w "-r 
./web-app -p 8100" -f own-ci-tests/etc/swupdate.cfg -u ""

But Webserver is not started at all and ends with:

[ERROR] : SWUPDATE failed [0] ERROR mongoose/mongoose_interface.c : 
start_mongoose : 867 : Failed to start Mongoose.

(I have not deeply  inverstigated...)

Best regards,
Stefano

>   mongoose/mongoose.c | 19555 +++++++++---------------------------------
>   mongoose/mongoose.h |  6804 ++-------------
>   2 files changed, 4891 insertions(+), 21468 deletions(-)
> 
> diff --git a/mongoose/mongoose.c b/mongoose/mongoose.c
> index 03bfad3..84978f6 100644
> --- a/mongoose/mongoose.c
> +++ b/mongoose/mongoose.c
> @@ -1,16143 +1,4794 @@
> -/*
> - * Copyright (c) 2004-2013 Sergey Lyubka
> - * Copyright (c) 2013-2020 Cesanta Software Limited
> - * All rights reserved
> - *
> - * SPDX-License-Identifier: GPL-2.0-only
> - *
> - * This software is dual-licensed: you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License version 2 as
> - * published by the Free Software Foundation. For the terms of this
> - * license, see <http://www.gnu.org/licenses/>.
> - *
> - * You are free to use this software under the terms of the GNU General
> - * Public License, but WITHOUT ANY WARRANTY; without even the implied
> - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> - * See the GNU General Public License for more details.
> - *
> - * Alternatively, you can license this software under a commercial
> - * license, as set out in <https://www.cesanta.com/license>.
> - */
> +// Copyright (c) 2004-2013 Sergey Lyubka
> +// Copyright (c) 2013-2021 Cesanta Software Limited
> +// All rights reserved
> +//
> +// This software is dual-licensed: you can redistribute it and/or modify
> +// it under the terms of the GNU General Public License version 2 as
> +// published by the Free Software Foundation. For the terms of this
> +// license, see <http://www.gnu.org/licenses/>.
> +//
> +// You are free to use this software under the terms of the GNU General
> +// Public License, but WITHOUT ANY WARRANTY; without even the implied
> +// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> +// See the GNU General Public License for more details.
> +//
> +// Alternatively, you can license this software under a commercial
> +// license, as set out in <https://www.cesanta.com/license>.
>   
>   #include "mongoose.h"
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_internal.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_INTERNAL_H_
> -#define CS_MONGOOSE_SRC_INTERNAL_H_
> -
> -/* Amalgamated: #include "common/mg_mem.h" */
> -
> -#ifndef MBUF_REALLOC
> -#define MBUF_REALLOC MG_REALLOC
> -#endif
> -
> -#ifndef MBUF_FREE
> -#define MBUF_FREE MG_FREE
> -#endif
> -
> -#define MG_SET_PTRPTR(_ptr, _v) \
> -  do {                          \
> -    if (_ptr) *(_ptr) = _v;     \
> -  } while (0)
> -
> -#ifndef MG_INTERNAL
> -#define MG_INTERNAL static
> -#endif
> -
> -#ifdef PICOTCP
> -#define NO_LIBC
> -#define MG_DISABLE_PFS
> -#endif
> -
> -/* Amalgamated: #include "common/cs_dbg.h" */
> -/* Amalgamated: #include "mg_http.h" */
> -/* Amalgamated: #include "mg_net.h" */
> -
> -#ifndef MG_CTL_MSG_MESSAGE_SIZE
> -#define MG_CTL_MSG_MESSAGE_SIZE 8192
> -#endif
> -
> -/* internals that need to be accessible in unit tests */
> -MG_INTERNAL struct mg_connection *mg_do_connect(struct mg_connection *nc,
> -                                                int proto,
> -                                                union socket_address *sa);
> -
> -MG_INTERNAL int mg_parse_address(const char *str, union socket_address *sa,
> -                                 int *proto, char *host, size_t host_len);
> -MG_INTERNAL void mg_call(struct mg_connection *nc,
> -                         mg_event_handler_t ev_handler, void *user_data, int ev,
> -                         void *ev_data);
> -void mg_forward(struct mg_connection *from, struct mg_connection *to);
> -MG_INTERNAL void mg_add_conn(struct mg_mgr *mgr, struct mg_connection *c);
> -MG_INTERNAL void mg_remove_conn(struct mg_connection *c);
> -MG_INTERNAL struct mg_connection *mg_create_connection(
> -    struct mg_mgr *mgr, mg_event_handler_t callback,
> -    struct mg_add_sock_opts opts);
> -#ifdef _WIN32
> -/* Retur value is the same as for MultiByteToWideChar. */
> -int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len);
> -#endif
> -
> -struct ctl_msg {
> -  mg_event_handler_t callback;
> -  char message[MG_CTL_MSG_MESSAGE_SIZE];
> -};
> -
> -#if MG_ENABLE_MQTT
> -struct mg_mqtt_message;
> -
> -#define MG_MQTT_ERROR_INCOMPLETE_MSG -1
> -#define MG_MQTT_ERROR_MALFORMED_MSG -2
> -
> -MG_INTERNAL int parse_mqtt(struct mbuf *io, struct mg_mqtt_message *mm);
> -#endif
> -
> -/* Forward declarations for testing. */
> -extern void *(*test_malloc)(size_t size);
> -extern void *(*test_calloc)(size_t count, size_t size);
> -
> -#ifndef MIN
> -#define MIN(a, b) ((a) < (b) ? (a) : (b))
> -#endif
> -
> -#if MG_ENABLE_HTTP
> -struct mg_serve_http_opts;
> -
> -MG_INTERNAL struct mg_http_proto_data *mg_http_create_proto_data(
> -    struct mg_connection *c);
> -
> -/*
> - * Reassemble the content of the buffer (buf, blen) which should be
> - * in the HTTP chunked encoding, by collapsing data chunks to the
> - * beginning of the buffer.
> - *
> - * If chunks get reassembled, modify hm->body to point to the reassembled
> - * body and fire MG_EV_HTTP_CHUNK event. If handler sets MG_F_DELETE_CHUNK
> - * in nc->flags, delete reassembled body from the mbuf.
> - *
> - * Return reassembled body size.
> - */
> -MG_INTERNAL size_t mg_handle_chunked(struct mg_connection *nc,
> -                                     struct http_message *hm, char *buf,
> -                                     size_t blen);
> -
> -#if MG_ENABLE_FILESYSTEM
> -MG_INTERNAL int mg_uri_to_local_path(struct http_message *hm,
> -                                     const struct mg_serve_http_opts *opts,
> -                                     char **local_path,
> -                                     struct mg_str *remainder);
> -MG_INTERNAL time_t mg_parse_date_string(const char *datetime);
> -MG_INTERNAL int mg_is_not_modified(struct http_message *hm, cs_stat_t *st);
> -#endif
> -#if MG_ENABLE_HTTP_CGI
> -MG_INTERNAL void mg_handle_cgi(struct mg_connection *nc, const char *prog,
> -                               const struct mg_str *path_info,
> -                               const struct http_message *hm,
> -                               const struct mg_serve_http_opts *opts);
> -struct mg_http_proto_data_cgi;
> -MG_INTERNAL void mg_http_free_proto_data_cgi(struct mg_http_proto_data_cgi *d);
> -#endif
> -#if MG_ENABLE_HTTP_SSI
> -MG_INTERNAL void mg_handle_ssi_request(struct mg_connection *nc,
> -                                       struct http_message *hm,
> -                                       const char *path,
> -                                       const struct mg_serve_http_opts *opts);
> -#endif
> -#if MG_ENABLE_HTTP_WEBDAV
> -MG_INTERNAL int mg_is_dav_request(const struct mg_str *s);
> -MG_INTERNAL void mg_handle_propfind(struct mg_connection *nc, const char *path,
> -                                    cs_stat_t *stp, struct http_message *hm,
> -                                    struct mg_serve_http_opts *opts);
> -MG_INTERNAL void mg_handle_lock(struct mg_connection *nc, const char *path);
> -MG_INTERNAL void mg_handle_mkcol(struct mg_connection *nc, const char *path,
> -                                 struct http_message *hm);
> -MG_INTERNAL void mg_handle_move(struct mg_connection *c,
> -                                const struct mg_serve_http_opts *opts,
> -                                const char *path, struct http_message *hm);
> -MG_INTERNAL void mg_handle_delete(struct mg_connection *nc,
> -                                  const struct mg_serve_http_opts *opts,
> -                                  const char *path);
> -MG_INTERNAL void mg_handle_put(struct mg_connection *nc, const char *path,
> -                               struct http_message *hm);
> -#endif
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -MG_INTERNAL void mg_ws_handler(struct mg_connection *nc, int ev,
> -                               void *ev_data MG_UD_ARG(void *user_data));
> -MG_INTERNAL void mg_ws_handshake(struct mg_connection *nc,
> -                                 const struct mg_str *key,
> -                                 struct http_message *);
> -#endif
> -#endif /* MG_ENABLE_HTTP */
> -
> -MG_INTERNAL int mg_get_errno(void);
> -
> -MG_INTERNAL void mg_close_conn(struct mg_connection *conn);
> -
> -#if MG_ENABLE_SNTP
> -MG_INTERNAL int mg_sntp_parse_reply(const char *buf, int len,
> -                                    struct mg_sntp_message *msg);
> -#endif
> -
> -#endif /* CS_MONGOOSE_SRC_INTERNAL_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/mg_mem.h"
> -#endif
> -
> -#ifndef CS_COMMON_MG_MEM_H_
> -#define CS_COMMON_MG_MEM_H_
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -#ifndef MG_MALLOC
> -#define MG_MALLOC malloc
> -#endif
> -
> -#ifndef MG_CALLOC
> -#define MG_CALLOC calloc
> -#endif
> -
> -#ifndef MG_REALLOC
> -#define MG_REALLOC realloc
> -#endif
> -
> -#ifndef MG_FREE
> -#define MG_FREE free
> -#endif
>   
> -#ifdef __cplusplus
> -}
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/private.h"
>   #endif
> +void mg_connect_resolved(struct mg_connection *);
>   
> -#endif /* CS_COMMON_MG_MEM_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_base64.c"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/base64.c"
>   #endif
> -
> -#ifndef EXCLUDE_COMMON
> -
> -/* Amalgamated: #include "common/cs_base64.h" */
> -
>   #include <string.h>
>   
> -/* Amalgamated: #include "common/cs_dbg.h" */
> -
> -/* ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ */
> -
> -#define NUM_UPPERCASES ('Z' - 'A' + 1)
> -#define NUM_LETTERS (NUM_UPPERCASES * 2)
> -#define NUM_DIGITS ('9' - '0' + 1)
> -
> -/*
> - * Emit a base64 code char.
> - *
> - * Doesn't use memory, thus it's safe to use to safely dump memory in crashdumps
> - */
> -static void cs_base64_emit_code(struct cs_base64_ctx *ctx, int v) {
> -  if (v < NUM_UPPERCASES) {
> -    ctx->b64_putc(v + 'A', ctx->user_data);
> -  } else if (v < (NUM_LETTERS)) {
> -    ctx->b64_putc(v - NUM_UPPERCASES + 'a', ctx->user_data);
> -  } else if (v < (NUM_LETTERS + NUM_DIGITS)) {
> -    ctx->b64_putc(v - NUM_LETTERS + '0', ctx->user_data);
> +static int mg_b64idx(int c) {
> +  if (c < 26) {
> +    return c + 'A';
> +  } else if (c < 52) {
> +    return c - 26 + 'a';
> +  } else if (c < 62) {
> +    return c - 52 + '0';
> +  } else {
> +    return c == 62 ? '+' : '/';
> +  }
> +}
> +
> +static int mg_b64rev(int c) {
> +  if (c >= 'A' && c <= 'Z') {
> +    return c - 'A';
> +  } else if (c >= 'a' && c <= 'z') {
> +    return c + 26 - 'a';
> +  } else if (c >= '0' && c <= '9') {
> +    return c + 52 - '0';
> +  } else if (c == '+') {
> +    return 62;
> +  } else if (c == '/') {
> +    return 63;
> +  } else if (c == '=') {
> +    return 64;
>     } else {
> -    ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/',
> -                  ctx->user_data);
> +    return -1;
>     }
>   }
>   
> -static void cs_base64_emit_chunk(struct cs_base64_ctx *ctx) {
> -  int a, b, c;
> -
> -  a = ctx->chunk[0];
> -  b = ctx->chunk[1];
> -  c = ctx->chunk[2];
> -
> -  cs_base64_emit_code(ctx, a >> 2);
> -  cs_base64_emit_code(ctx, ((a & 3) << 4) | (b >> 4));
> -  if (ctx->chunk_size > 1) {
> -    cs_base64_emit_code(ctx, (b & 15) << 2 | (c >> 6));
> -  }
> -  if (ctx->chunk_size > 2) {
> -    cs_base64_emit_code(ctx, c & 63);
> +int mg_base64_update(unsigned char ch, char *to, int n) {
> +  int rem = (n & 3) % 3;
> +  if (rem == 0) {
> +    to[n] = (char) mg_b64idx(ch >> 2);
> +    to[++n] = (char) ((ch & 3) << 4);
> +  } else if (rem == 1) {
> +    to[n] = (char) mg_b64idx(to[n] | (ch >> 4));
> +    to[++n] = (char) ((ch & 15) << 2);
> +  } else {
> +    to[n] = (char) mg_b64idx(to[n] | (ch >> 6));
> +    to[++n] = (char) mg_b64idx(ch & 63);
> +    n++;
>     }
> +  return n;
>   }
>   
> -void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t b64_putc,
> -                    void *user_data) {
> -  ctx->chunk_size = 0;
> -  ctx->b64_putc = b64_putc;
> -  ctx->user_data = user_data;
> +int mg_base64_final(char *to, int n) {
> +  int saved = n;
> +  // printf("---[%.*s]\n", n, to);
> +  if (n & 3) n = mg_base64_update(0, to, n);
> +  if ((saved & 3) == 2) n--;
> +  // printf("    %d[%.*s]\n", n, n, to);
> +  while (n & 3) to[n++] = '=';
> +  to[n] = '\0';
> +  return n;
>   }
>   
> -void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len) {
> -  const unsigned char *src = (const unsigned char *) str;
> -  size_t i;
> -  for (i = 0; i < len; i++) {
> -    ctx->chunk[ctx->chunk_size++] = src[i];
> -    if (ctx->chunk_size == 3) {
> -      cs_base64_emit_chunk(ctx);
> -      ctx->chunk_size = 0;
> -    }
> -  }
> +int mg_base64_encode(const unsigned char *p, int n, char *to) {
> +  int i, len = 0;
> +  for (i = 0; i < n; i++) len = mg_base64_update(p[i], to, len);
> +  len = mg_base64_final(to, len);
> +  return len;
>   }
>   
> -void cs_base64_finish(struct cs_base64_ctx *ctx) {
> -  if (ctx->chunk_size > 0) {
> -    int i;
> -    memset(&ctx->chunk[ctx->chunk_size], 0, 3 - ctx->chunk_size);
> -    cs_base64_emit_chunk(ctx);
> -    for (i = 0; i < (3 - ctx->chunk_size); i++) {
> -      ctx->b64_putc('=', ctx->user_data);
> -    }
> -  }
> +int mg_base64_decode(const char *src, int n, char *dst) {
> +  const char *end = src + n;
> +  int len = 0;
> +  while (src + 3 < end) {
> +    int a = mg_b64rev(src[0]), b = mg_b64rev(src[1]), c = mg_b64rev(src[2]),
> +        d = mg_b64rev(src[3]);
> +    if (a == 64 || a < 0 || b == 64 || b < 0 || c < 0 || d < 0) return 0;
> +    dst[len++] = (char) ((a << 2) | (b >> 4));
> +    if (src[2] != '=') {
> +      dst[len++] = (char) ((b << 4) | (c >> 2));
> +      if (src[3] != '=') dst[len++] = (char) ((c << 6) | d);
> +    }
> +    src += 4;
> +  }
> +  dst[len] = '\0';
> +  return len;
>   }
>   
> -#define BASE64_ENCODE_BODY                                                \
> -  static const char *b64 =                                                \
> -      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; \
> -  int i, j, a, b, c;                                                      \
> -                                                                          \
> -  for (i = j = 0; i < src_len; i += 3) {                                  \
> -    a = src[i];                                                           \
> -    b = i + 1 >= src_len ? 0 : src[i + 1];                                \
> -    c = i + 2 >= src_len ? 0 : src[i + 2];                                \
> -                                                                          \
> -    BASE64_OUT(b64[a >> 2]);                                              \
> -    BASE64_OUT(b64[((a & 3) << 4) | (b >> 4)]);                           \
> -    if (i + 1 < src_len) {                                                \
> -      BASE64_OUT(b64[(b & 15) << 2 | (c >> 6)]);                          \
> -    }                                                                     \
> -    if (i + 2 < src_len) {                                                \
> -      BASE64_OUT(b64[c & 63]);                                            \
> -    }                                                                     \
> -  }                                                                       \
> -                                                                          \
> -  while (j % 4 != 0) {                                                    \
> -    BASE64_OUT('=');                                                      \
> -  }                                                                       \
> -  BASE64_FLUSH()
> -
> -#define BASE64_OUT(ch) \
> -  do {                 \
> -    dst[j++] = (ch);   \
> -  } while (0)
> -
> -#define BASE64_FLUSH() \
> -  do {                 \
> -    dst[j++] = '\0';   \
> -  } while (0)
> -
> -void cs_base64_encode(const unsigned char *src, int src_len, char *dst) {
> -  BASE64_ENCODE_BODY;
> -}
> -
> -#undef BASE64_OUT
> -#undef BASE64_FLUSH
> -
> -#if CS_ENABLE_STDIO
> -#define BASE64_OUT(ch)      \
> -  do {                      \
> -    fprintf(f, "%c", (ch)); \
> -    j++;                    \
> -  } while (0)
> -
> -#define BASE64_FLUSH()
> -
> -void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len) {
> -  BASE64_ENCODE_BODY;
> -}
> -
> -#undef BASE64_OUT
> -#undef BASE64_FLUSH
> -#endif /* CS_ENABLE_STDIO */
> -
> -/* Convert one byte of encoded base64 input stream to 6-bit chunk */
> -static unsigned char from_b64(unsigned char ch) {
> -  /* Inverse lookup map */
> -  static const unsigned char tab[128] = {
> -      255, 255, 255, 255,
> -      255, 255, 255, 255, /*  0 */
> -      255, 255, 255, 255,
> -      255, 255, 255, 255, /*  8 */
> -      255, 255, 255, 255,
> -      255, 255, 255, 255, /*  16 */
> -      255, 255, 255, 255,
> -      255, 255, 255, 255, /*  24 */
> -      255, 255, 255, 255,
> -      255, 255, 255, 255, /*  32 */
> -      255, 255, 255, 62,
> -      255, 255, 255, 63, /*  40 */
> -      52,  53,  54,  55,
> -      56,  57,  58,  59, /*  48 */
> -      60,  61,  255, 255,
> -      255, 200, 255, 255, /*  56   '=' is 200, on index 61 */
> -      255, 0,   1,   2,
> -      3,   4,   5,   6, /*  64 */
> -      7,   8,   9,   10,
> -      11,  12,  13,  14, /*  72 */
> -      15,  16,  17,  18,
> -      19,  20,  21,  22, /*  80 */
> -      23,  24,  25,  255,
> -      255, 255, 255, 255, /*  88 */
> -      255, 26,  27,  28,
> -      29,  30,  31,  32, /*  96 */
> -      33,  34,  35,  36,
> -      37,  38,  39,  40, /*  104 */
> -      41,  42,  43,  44,
> -      45,  46,  47,  48, /*  112 */
> -      49,  50,  51,  255,
> -      255, 255, 255, 255, /*  120 */
> -  };
> -  return tab[ch & 127];
> -}
> -
> -int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len) {
> -  unsigned char a, b, c, d;
> -  int orig_len = len;
> -  char *orig_dst = dst;
> -  while (len >= 4 && (a = from_b64(s[0])) != 255 &&
> -         (b = from_b64(s[1])) != 255 && (c = from_b64(s[2])) != 255 &&
> -         (d = from_b64(s[3])) != 255) {
> -    s += 4;
> -    len -= 4;
> -    if (a == 200 || b == 200) break; /* '=' can't be there */
> -    *dst++ = a << 2 | b >> 4;
> -    if (c == 200) break;
> -    *dst++ = b << 4 | c >> 2;
> -    if (d == 200) break;
> -    *dst++ = c << 6 | d;
> -  }
> -  *dst = 0;
> -  if (dec_len != NULL) *dec_len = (dst - orig_dst);
> -  return orig_len - len;
> -}
> -
> -#endif /* EXCLUDE_COMMON */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_dbg.h"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/dns.c"
>   #endif
>   
> -#ifndef CS_COMMON_CS_DBG_H_
> -#define CS_COMMON_CS_DBG_H_
>   
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#if CS_ENABLE_STDIO
> -#include <stdio.h>
> -#endif
>   
> -#ifndef CS_ENABLE_DEBUG
> -#define CS_ENABLE_DEBUG 0
> -#endif
>   
> -#ifndef CS_LOG_PREFIX_LEN
> -#define CS_LOG_PREFIX_LEN 24
> -#endif
>   
> -#ifndef CS_LOG_ENABLE_TS_DIFF
> -#define CS_LOG_ENABLE_TS_DIFF 0
> -#endif
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
>   
> -/*
> - * Log level; `LL_INFO` is the default. Use `cs_log_set_level()` to change it.
> - */
> -enum cs_log_level {
> -  LL_NONE = -1,
> -  LL_ERROR = 0,
> -  LL_WARN = 1,
> -  LL_INFO = 2,
> -  LL_DEBUG = 3,
> -  LL_VERBOSE_DEBUG = 4,
> -
> -  _LL_MIN = -2,
> -  _LL_MAX = 5,
> +struct dns_data {
> +  struct dns_data *next;
> +  struct mg_connection *c;
> +  unsigned long expire;
> +  uint16_t txnid;
>   };
>   
> -/*
> - * Set max log level to print; messages with the level above the given one will
> - * not be printed.
> - */
> -void cs_log_set_level(enum cs_log_level level);
> -
> -/*
> - * A comma-separated set of prefix=level.
> - * prefix is matched against the log prefix exactly as printed, including line
> - * number, but partial match is ok. Check stops on first matching entry.
> - * If nothing matches, default level is used.
> - *
> - * Examples:
> - *   main.c:=4 - everything from main C at verbose debug level.
> - *   mongoose.c=1,mjs.c=1,=4 - everything at verbose debug except mg_* and mjs_*
> - *
> - */
> -void cs_log_set_file_level(const char *file_level);
> -
> -/*
> - * Helper function which prints message prefix with the given `level`.
> - * If message should be printed (according to the current log level
> - * and filter), prints the prefix and returns 1, otherwise returns 0.
> - *
> - * Clients should typically just use `LOG()` macro.
> - */
> -int cs_log_print_prefix(enum cs_log_level level, const char *fname, int line);
> +static struct dns_data *s_reqs;  // Active DNS requests
>   
> -extern enum cs_log_level cs_log_level;
> +static void mg_sendnsreq(struct mg_connection *, struct mg_str *, int,
> +                         struct mg_dns *, bool);
>   
> -#if CS_ENABLE_STDIO
> +static void mg_dns_free(struct dns_data *d) {
> +  LIST_DELETE(struct dns_data, &s_reqs, d);
> +  free(d);
> +}
>   
> -/*
> - * Set file to write logs into. If `NULL`, logs go to `stderr`.
> - */
> -void cs_log_set_file(FILE *file);
> +void mg_resolve_cancel(struct mg_connection *c) {
> +  struct dns_data *tmp, *d;
> +  for (d = s_reqs; d != NULL; d = tmp) {
> +    tmp = d->next;
> +    if (d->c == c) mg_dns_free(d);
> +  }
> +}
>   
> -/*
> - * Prints log to the current log file, appends "\n" in the end and flushes the
> - * stream.
> - */
> -void cs_log_printf(const char *fmt, ...) PRINTF_LIKE(1, 2);
> +static size_t mg_dns_parse_name_depth(const uint8_t *s, size_t len, size_t ofs,
> +                                      char *to, size_t tolen, int depth) {
> +  size_t i = 0, j = 0;
> +  if (tolen > 0) to[0] = '\0';
> +  if (depth > 5) return 0;
> +  while (ofs + i + 1 < len) {
> +    size_t n = s[ofs + i];
> +    if (n == 0) {
> +      i++;
> +      break;
> +    }
> +    if (n & 0xc0) {
> +      size_t ptr = (((n & 0x3f) << 8) | s[ofs + i + 1]);  // 12 is hdr len
> +      if (ptr + 1 < len && (s[ptr] & 0xc0) == 0 &&
> +          mg_dns_parse_name_depth(s, len, ptr, to, tolen, depth + 1) == 0)
> +        return 0;
> +      i += 2;
> +      break;
> +    }
> +    if (ofs + i + n + 1 >= len) return 0;
> +    if (j > 0) {
> +      if (j < tolen) to[j] = '.';
> +      j++;
> +    }
> +    if (j + n < tolen) memcpy(&to[j], &s[ofs + i + 1], n);
> +    j += n;
> +    i += n + 1;
> +    if (j < tolen) to[j] = '\0';  // Zero-terminate this chunk
> +  }
> +  if (tolen > 0) to[tolen - 1] = '\0';  // Make sure make sure it is nul-term
> +  return i;
> +}
>   
> -#if CS_ENABLE_STDIO
> +size_t mg_dns_parse_name(const uint8_t *s, size_t n, size_t ofs, char *dst,
> +                         size_t dstlen) {
> +  return mg_dns_parse_name_depth(s, n, ofs, dst, dstlen, 0);
> +}
>   
> -/*
> - * Format and print message `x` with the given level `l`. Example:
> - *
> - * ```c
> - * LOG(LL_INFO, ("my info message: %d", 123));
> - * LOG(LL_DEBUG, ("my debug message: %d", 123));
> - * ```
> - */
> -#define LOG(l, x)                                     \
> -  do {                                                \
> -    if (cs_log_print_prefix(l, __FILE__, __LINE__)) { \
> -      cs_log_printf x;                                \
> -    }                                                 \
> -  } while (0)
> +size_t mg_dns_parse_rr(const uint8_t *buf, size_t len, size_t ofs,
> +                       bool is_question, struct mg_dns_rr *rr) {
> +  const uint8_t *s = buf + ofs, *e = &buf[len];
>   
> -#else
> +  memset(rr, 0, sizeof(*rr));
> +  if (len < sizeof(struct mg_dns_header)) return 0;  // Too small
> +  if (len > 512) return 0;         //  Too large, we don't expect that
> +  if (s >= e) return 0;            //  Overflow
>   
> -#define LOG(l, x) ((void) l)
> +  if ((rr->nlen = (uint16_t) mg_dns_parse_name(buf, len, ofs, NULL, 0)) == 0)
> +    return 0;
> +  s += rr->nlen + 4;
> +  if (s > e) return 0;
> +  rr->atype = (uint16_t)(((uint16_t) s[-4] << 8) | s[-3]);
> +  rr->aclass = (uint16_t)(((uint16_t) s[-2] << 8) | s[-1]);
> +  if (is_question) return (size_t)(rr->nlen + 4);
> +
> +  s += 6;
> +  if (s > e) return 0;
> +  rr->alen = (uint16_t)(((uint16_t) s[-2] << 8) | s[-1]);
> +  if (s + rr->alen > e) return 0;
> +  return (size_t)(rr->nlen + rr->alen + 10);
> +}
> +
> +bool mg_dns_parse(const uint8_t *buf, size_t len, struct mg_dns_message *dm) {
> +  const struct mg_dns_header *h = (struct mg_dns_header *) buf;
> +  struct mg_dns_rr rr;
> +  size_t i, n, ofs = sizeof(*h);
> +  memset(dm, 0, sizeof(*dm));
> +
> +  if (len < sizeof(*h)) return 0;                // Too small, headers dont fit
> +  if (mg_ntohs(h->num_questions) > 1) return 0;  // Sanity
> +  if (mg_ntohs(h->num_answers) > 10) return 0;   // Sanity
> +  dm->txnid = mg_ntohs(h->txnid);
> +
> +  for (i = 0; i < mg_ntohs(h->num_questions); i++) {
> +    if ((n = mg_dns_parse_rr(buf, len, ofs, true, &rr)) == 0) return false;
> +    // LOG(LL_INFO, ("Q %zu %zu", ofs, n));
> +    ofs += n;
> +  }
> +  for (i = 0; i < mg_ntohs(h->num_answers); i++) {
> +    // LOG(LL_INFO, ("A -- %zu %zu %s", ofs, n, dm->name));
> +    if ((n = mg_dns_parse_rr(buf, len, ofs, false, &rr)) == 0) return false;
> +    mg_dns_parse_name(buf, len, ofs, dm->name, sizeof(dm->name));
> +    ofs += n;
> +
> +    if (rr.alen == 4 && rr.atype == 1 && rr.aclass == 1) {
> +      dm->addr.is_ip6 = false;
> +      memcpy(&dm->addr.ip, &buf[ofs - 4], 4);
> +      dm->resolved = true;
> +      break;  // Return success
> +    } else if (rr.alen == 16 && rr.atype == 28 && rr.aclass == 1) {
> +      dm->addr.is_ip6 = true;
> +      memcpy(&dm->addr.ip6, &buf[ofs - 16], 16);
> +      dm->resolved = true;
> +      break;  // Return success
> +    }
> +  }
> +  return true;
> +}
>   
> +static void dns_cb(struct mg_connection *c, int ev, void *ev_data,
> +                   void *fn_data) {
> +  struct dns_data *d, *tmp;
> +  if (ev == MG_EV_POLL) {
> +    unsigned long now = *(unsigned long *) ev_data;
> +    for (d = s_reqs; d != NULL; d = tmp) {
> +      tmp = d->next;
> +      // LOG(LL_DEBUG, ("%lu %lu dns poll", d->expire, now));
> +      if (now > d->expire) mg_error(d->c, "DNS timeout");
> +    }
> +  } else if (ev == MG_EV_READ) {
> +    struct mg_dns_message dm;
> +    int resolved = 0;
> +    if (mg_dns_parse(c->recv.buf, c->recv.len, &dm) == false) {
> +      char *s = mg_hexdump(c->recv.buf, c->recv.len);
> +      LOG(LL_ERROR, ("Unexpected DNS response:\n%s\n", s));
> +      free(s);
> +    } else {
> +      LOG(LL_VERBOSE_DEBUG, ("%s %d", dm.name, dm.resolved));
> +      for (d = s_reqs; d != NULL; d = tmp) {
> +        tmp = d->next;
> +        // LOG(LL_INFO, ("d %p %hu %hu", d, d->txnid, dm.txnid));
> +        if (dm.txnid != d->txnid) continue;
> +        if (d->c->is_resolving) {
> +          d->c->is_resolving = 0;
> +          if (dm.resolved) {
> +#if MG_ENABLE_LOG
> +            char buf[100];
> +#endif
> +            dm.addr.port = d->c->peer.port;  // Save port
> +            d->c->peer = dm.addr;            // Copy resolved address
> +            LOG(LL_DEBUG, ("%lu %s resolved to %s", d->c->id, dm.name,
> +                           mg_ntoa(&d->c->peer, buf, sizeof(buf))));
> +            mg_connect_resolved(d->c);
> +#if MG_ENABLE_IPV6
> +          } else if (dm.addr.is_ip6 == false && dm.name[0] != '\0') {
> +            struct mg_str x = mg_str(dm.name);
> +            mg_sendnsreq(d->c, &x, c->mgr->dnstimeout, &c->mgr->dns6, true);
>   #endif
> +          } else {
> +            mg_error(d->c, "%s DNS lookup failed", dm.name);
> +          }
> +        } else {
> +          LOG(LL_ERROR, ("%lu already resolved", d->c->id));
> +        }
> +        mg_dns_free(d);
> +        resolved = 1;
> +      }
> +    }
> +    if (!resolved) LOG(LL_ERROR, ("stray DNS reply"));
> +    c->recv.len = 0;
> +  } else if (ev == MG_EV_CLOSE) {
> +    for (d = s_reqs; d != NULL; d = tmp) {
> +      tmp = d->next;
> +      mg_dns_free(d);
> +    }
> +  }
> +  (void) fn_data;
> +}
> +
> +void mg_dns_send(struct mg_connection *c, const struct mg_str *name,
> +                 uint16_t txnid, bool ipv6) {
> +  struct {
> +    struct mg_dns_header header;
> +    uint8_t data[256];
> +  } pkt;
> +  size_t i, n;
> +  memset(&pkt, 0, sizeof(pkt));
> +  pkt.header.txnid = mg_htons(txnid);
> +  pkt.header.flags = mg_htons(0x100);
> +  pkt.header.num_questions = mg_htons(1);
> +  for (i = n = 0; i < sizeof(pkt.data) - 5; i++) {
> +    if (name->ptr[i] == '.' || i >= name->len) {
> +      pkt.data[n] = (uint8_t)(i - n);
> +      memcpy(&pkt.data[n + 1], name->ptr + n, i - n);
> +      n = i + 1;
> +    }
> +    if (i >= name->len) break;
> +  }
> +  memcpy(&pkt.data[n], "\x00\x00\x01\x00\x01", 5);  // A query
> +  n += 5;
> +  if (ipv6) pkt.data[n - 3] = 0x1c;  // AAAA query
> +  // memcpy(&pkt.data[n], "\xc0\x0c\x00\x1c\x00\x01", 6);  // AAAA query
> +  // n += 6;
> +  mg_send(c, &pkt, sizeof(pkt.header) + n);
> +#if 0
> +  // Immediately after A query, send AAAA query. Whatever reply comes first,
> +  // we'll use it. Note: we cannot send two queries in a single packet.
> +  // https://stackoverflow.com/questions/4082081/requesting-a-and-aaaa-records-in-single-dns-query
> +  pkt.data[n - 3] = 0x1c;  // AAAA query
> +  mg_send(c, &pkt, sizeof(pkt.header) + n);
> +#endif
> +}
> +
> +static void mg_sendnsreq(struct mg_connection *c, struct mg_str *name, int ms,
> +                         struct mg_dns *dnsc, bool ipv6) {
> +  struct dns_data *d = NULL;
> +  if (dnsc->url == NULL) {
> +    mg_error(c, "DNS server URL is NULL. Call mg_mgr_init()");
> +  } else if (dnsc->c == NULL) {
> +    dnsc->c = mg_connect(c->mgr, dnsc->url, NULL, NULL);
> +    if (dnsc->c != NULL) {
> +      dnsc->c->pfn = dns_cb;
> +      snprintf(dnsc->c->label, sizeof(dnsc->c->label), "%s", "DNS");
> +      // dnsc->c->is_hexdumping = 1;
> +    }
> +  }
> +  if (dnsc->c == NULL) {
> +    mg_error(c, "resolver");
> +  } else if ((d = (struct dns_data *) calloc(1, sizeof(*d))) == NULL) {
> +    mg_error(c, "resolve OOM");
> +  } else {
> +#if MG_ENABLE_LOG
> +    char buf[100];
> +#endif
> +    d->txnid = s_reqs ? (uint16_t)(s_reqs->txnid + 1) : 1;
> +    d->next = s_reqs;
> +    s_reqs = d;
> +    d->expire = mg_millis() + (unsigned long) ms;
> +    d->c = c;
> +    c->is_resolving = 1;
> +    LOG(LL_VERBOSE_DEBUG,
> +        ("%lu resolving %.*s @ %s, txnid %hu", c->id, (int) name->len,
> +         name->ptr, mg_ntoa(&dnsc->c->peer, buf, sizeof(buf)), d->txnid));
> +    mg_dns_send(dnsc->c, name, d->txnid, ipv6);
> +  }
> +}
> +
> +void mg_resolve(struct mg_connection *c, struct mg_str *name, int ms) {
> +  if (mg_aton(*name, &c->peer)) {
> +    // name is an IP address, do not fire name resolution
> +    mg_connect_resolved(c);
> +  } else {
> +    // name is not an IP, send DNS resolution request
> +    mg_sendnsreq(c, name, ms, &c->mgr->dns4, false);
> +  }
> +}
>   
> -#ifndef CS_NDEBUG
> -
> -/*
> - * Shortcut for `LOG(LL_VERBOSE_DEBUG, (...))`
> - */
> -#define DBG(x) LOG(LL_VERBOSE_DEBUG, x)
> -
> -#else /* NDEBUG */
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/event.c"
> +#endif
>   
> -#define DBG(x)
>   
> -#endif
>   
> -#else /* CS_ENABLE_STDIO */
>   
> -#define LOG(l, x)
> -#define DBG(x)
>   
> -#endif
> +void mg_call(struct mg_connection *c, int ev, void *ev_data) {
> +  if (c->pfn != NULL) c->pfn(c, ev, ev_data, c->pfn_data);
> +  if (c->fn != NULL) c->fn(c, ev, ev_data, c->fn_data);
> +}
>   
> -#ifdef __cplusplus
> +void mg_error(struct mg_connection *c, const char *fmt, ...) {
> +  char mem[256], *buf = mem;
> +  va_list ap;
> +  va_start(ap, fmt);
> +  mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  va_end(ap);
> +  LOG(LL_ERROR, ("%lu %s", c->id, buf));
> +  mg_call(c, MG_EV_ERROR, buf);
> +  if (buf != mem) free(buf);
> +  c->is_closing = 1;
>   }
> -#endif /* __cplusplus */
>   
> -#endif /* CS_COMMON_CS_DBG_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_dbg.c"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/fs_packed.c"
>   #endif
>   
> -/* Amalgamated: #include "common/cs_dbg.h" */
> -
> -#include <stdarg.h>
> -#include <stdio.h>
> -#include <string.h>
>   
> -/* Amalgamated: #include "common/cs_time.h" */
> -/* Amalgamated: #include "common/str_util.h" */
> +struct packed_file {
> +  const char *data;
> +  size_t size;
> +  size_t pos;
> +};
>   
> -enum cs_log_level cs_log_level WEAK =
> -#if CS_ENABLE_DEBUG
> -    LL_VERBOSE_DEBUG;
> +const char *mg_unpack(const char *path, size_t *size, time_t *mtime);
> +const char *mg_unlist(size_t no);
> +#if MG_ENABLE_PACKED_FS
>   #else
> -    LL_ERROR;
> -#endif
> -
> -#if CS_ENABLE_STDIO
> -static char *s_file_level = NULL;
> -
> -void cs_log_set_file_level(const char *file_level) WEAK;
> -
> -FILE *cs_log_file WEAK = NULL;
> -
> -#if CS_LOG_ENABLE_TS_DIFF
> -double cs_log_ts WEAK;
> +const char *mg_unpack(const char *path, size_t *size, time_t *mtime) {
> +  (void) path, (void) size, (void) mtime;
> +  return NULL;
> +}
> +const char *mg_unlist(size_t no) {
> +  (void) no;
> +  return NULL;
> +}
>   #endif
>   
> -enum cs_log_level cs_log_cur_msg_level WEAK = LL_NONE;
> -
> -void cs_log_set_file_level(const char *file_level) {
> -  char *fl = s_file_level;
> -  if (file_level != NULL) {
> -    s_file_level = strdup(file_level);
> -  } else {
> -    s_file_level = NULL;
> -  }
> -  free(fl);
> +static int is_dir_prefix(const char *prefix, size_t n, const char *path) {
> +  return n < strlen(path) && memcmp(prefix, path, n) == 0 && path[n] == '/';
> +  //(n == 0 || path[n] == MG_DIRSEP);
>   }
>   
> -int cs_log_print_prefix(enum cs_log_level level, const char *file, int ln) WEAK;
> -int cs_log_print_prefix(enum cs_log_level level, const char *file, int ln) {
> -  char prefix[CS_LOG_PREFIX_LEN], *q;
> +static int packed_stat(const char *path, size_t *size, time_t *mtime) {
>     const char *p;
> -  size_t fl = 0, ll = 0, pl = 0;
> -
> -  if (level > cs_log_level && s_file_level == NULL) return 0;
> -
> -  p = file + strlen(file);
> -
> -  while (p != file) {
> -    const char c = *(p - 1);
> -    if (c == '/' || c == '\\') break;
> -    p--;
> -    fl++;
> -  }
> -
> -  ll = (ln < 10000 ? (ln < 1000 ? (ln < 100 ? (ln < 10 ? 1 : 2) : 3) : 4) : 5);
> -  if (fl > (sizeof(prefix) - ll - 2)) fl = (sizeof(prefix) - ll - 2);
> -
> -  pl = fl + 1 + ll;
> -  memcpy(prefix, p, fl);
> -  q = prefix + pl;
> -  memset(q, ' ', sizeof(prefix) - pl);
> -  do {
> -    *(--q) = '0' + (ln % 10);
> -    ln /= 10;
> -  } while (ln > 0);
> -  *(--q) = ':';
> -
> -  if (s_file_level != NULL) {
> -    enum cs_log_level pll = cs_log_level;
> -    struct mg_str mgfl = mg_mk_str(s_file_level), ps = MG_MK_STR_N(prefix, pl);
> -    struct mg_str k, v;
> -    while ((mgfl = mg_next_comma_list_entry_n(mgfl, &k, &v)).p != NULL) {
> -      bool yes = !(!mg_str_starts_with(ps, k) || v.len == 0);
> -      if (!yes) continue;
> -      pll = (enum cs_log_level)(*v.p - '0');
> -      break;
> -    }
> -    if (level > pll) return 0;
> +  size_t i, n = strlen(path);
> +  if (mg_unpack(path, size, mtime)) return MG_FS_READ;  // Regular file
> +  // Scan all files. If `path` is a dir prefix for any of them, it's a dir
> +  for (i = 0; (p = mg_unlist(i)) != NULL; i++) {
> +    if (is_dir_prefix(path, n, p)) return MG_FS_DIR;
>     }
> -
> -  if (cs_log_file == NULL) cs_log_file = stderr;
> -  cs_log_cur_msg_level = level;
> -  fwrite(prefix, 1, sizeof(prefix), cs_log_file);
> -#if CS_LOG_ENABLE_TS_DIFF
> -  {
> -    double now = cs_time();
> -    fprintf(cs_log_file, "%7u ", (unsigned int) ((now - cs_log_ts) * 1000000));
> -    cs_log_ts = now;
> -  }
> -#endif
> -  return 1;
> +  return 0;
>   }
>   
> -void cs_log_printf(const char *fmt, ...) WEAK;
> -void cs_log_printf(const char *fmt, ...) {
> -  va_list ap;
> -  va_start(ap, fmt);
> -  vfprintf(cs_log_file, fmt, ap);
> -  va_end(ap);
> -  fputc('\n', cs_log_file);
> -  fflush(cs_log_file);
> -  cs_log_cur_msg_level = LL_NONE;
> +static void packed_list(const char *dir, void (*fn)(const char *, void *),
> +                        void *userdata) {
> +  char buf[256], tmp[sizeof(buf)];
> +  const char *path, *begin, *end;
> +  size_t i, n = strlen(dir);
> +  tmp[0] = '\0';  // Previously listed entry
> +  for (i = 0; (path = mg_unlist(i)) != NULL; i++) {
> +    if (!is_dir_prefix(dir, n, path)) continue;
> +    begin = &path[n + 1];
> +    end = strchr(begin, '/');
> +    if (end == NULL) end = begin + strlen(begin);
> +    snprintf(buf, sizeof(buf), "%.*s", (int) (end - begin), begin);
> +    buf[sizeof(buf) - 1] = '\0';
> +    // If this entry has been already listed, skip
> +    // NOTE: we're assuming that file list is sorted alphabetically
> +    if (strcmp(buf, tmp) == 0) continue;
> +    fn(buf, userdata);  // Not yet listed, call user function
> +    strcpy(tmp, buf);   // And save this entry as listed
> +  }
> +}
> +
> +static struct mg_fd *packed_open(const char *path, int flags) {
> +  size_t size = 0;
> +  const char *data = mg_unpack(path, &size, NULL);
> +  struct packed_file *fp = NULL;
> +  struct mg_fd *fd = NULL;
> +  if (data == NULL) return NULL;
> +  if (flags & MG_FS_WRITE) return NULL;
> +  fp = (struct packed_file *) calloc(1, sizeof(*fp));
> +  fd = (struct mg_fd *) calloc(1, sizeof(*fd));
> +  fp->size = size;
> +  fp->data = data;
> +  fd->fd = fp;
> +  fd->fs = &mg_fs_packed;
> +  return fd;
>   }
>   
> -void cs_log_set_file(FILE *file) WEAK;
> -void cs_log_set_file(FILE *file) {
> -  cs_log_file = file;
> +static void packed_close(struct mg_fd *fd) {
> +  if (fd) free(fd->fd), free(fd);
>   }
>   
> -#else
> -
> -void cs_log_set_file_level(const char *file_level) {
> -  (void) file_level;
> +static size_t packed_read(void *fd, void *buf, size_t len) {
> +  struct packed_file *fp = (struct packed_file *) fd;
> +  if (fp->pos + len > fp->size) len = fp->size - fp->pos;
> +  memcpy(buf, &fp->data[fp->pos], len);
> +  fp->pos += len;
> +  return len;
>   }
>   
> -#endif /* CS_ENABLE_STDIO */
> -
> -void cs_log_set_level(enum cs_log_level level) WEAK;
> -void cs_log_set_level(enum cs_log_level level) {
> -  cs_log_level = level;
> -#if CS_LOG_ENABLE_TS_DIFF && CS_ENABLE_STDIO
> -  cs_log_ts = cs_time();
> -#endif
> +static size_t packed_write(void *fd, const void *buf, size_t len) {
> +  (void) fd, (void) buf, (void) len;
> +  return 0;
>   }
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_dirent.h"
> -#endif
> -
> -#ifndef CS_COMMON_CS_DIRENT_H_
> -#define CS_COMMON_CS_DIRENT_H_
>   
> -#include <limits.h>
> +static size_t packed_seek(void *fd, size_t offset) {
> +  struct packed_file *fp = (struct packed_file *) fd;
> +  fp->pos = offset;
> +  if (fp->pos > fp->size) fp->pos = fp->size;
> +  return fp->pos;
> +}
>   
> -/* Amalgamated: #include "common/platform.h" */
> +struct mg_fs mg_fs_packed = {packed_stat,  packed_list, packed_open,
> +                             packed_close, packed_read, packed_write,
> +                             packed_seek};
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/fs_posix.c"
> +#endif
>   
> -#ifdef CS_DEFINE_DIRENT
> -typedef struct { int dummy; } DIR;
>   
> -struct dirent {
> -  int d_ino;
> +#if defined(FOPEN_MAX)
> +static int p_stat(const char *path, size_t *size, time_t *mtime) {
>   #ifdef _WIN32
> -  char d_name[MAX_PATH];
> +  struct _stati64 st;
> +  wchar_t tmp[PATH_MAX];
> +  MultiByteToWideChar(CP_UTF8, 0, path, -1, tmp, sizeof(tmp) / sizeof(tmp[0]));
> +  if (_wstati64(tmp, &st) != 0) return 0;
>   #else
> -  /* TODO(rojer): Use PATH_MAX but make sure it's sane on every platform */
> -  char d_name[256];
> +  struct stat st;
> +  if (stat(path, &st) != 0) return 0;
>   #endif
> -};
> -
> -DIR *opendir(const char *dir_name);
> -int closedir(DIR *dir);
> -struct dirent *readdir(DIR *dir);
> -#endif /* CS_DEFINE_DIRENT */
> -
> -#ifdef __cplusplus
> +  if (size) *size = (size_t) st.st_size;
> +  if (mtime) *mtime = st.st_mtime;
> +  return MG_FS_READ | MG_FS_WRITE | (S_ISDIR(st.st_mode) ? MG_FS_DIR : 0);
>   }
> -#endif /* __cplusplus */
> -
> -#endif /* CS_COMMON_CS_DIRENT_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_dirent.c"
> -#endif
> -
> -#ifndef EXCLUDE_COMMON
> -
> -/* Amalgamated: #include "common/mg_mem.h" */
> -/* Amalgamated: #include "common/cs_dirent.h" */
> -
> -/*
> - * This file contains POSIX opendir/closedir/readdir API implementation
> - * for systems which do not natively support it (e.g. Windows).
> - */
>   
>   #ifdef _WIN32
> -struct win32_dir {
> -  DIR d;
> +struct dirent {
> +  char d_name[MAX_PATH];
> +};
> +
> +typedef struct win32_dir {
>     HANDLE handle;
>     WIN32_FIND_DATAW info;
>     struct dirent result;
> -};
> +} DIR;
> +
> +int gettimeofday(struct timeval *tv, void *tz) {
> +  FILETIME ft;
> +  unsigned __int64 tmpres = 0;
> +
> +  if (tv != NULL) {
> +    GetSystemTimeAsFileTime(&ft);
> +    tmpres |= ft.dwHighDateTime;
> +    tmpres <<= 32;
> +    tmpres |= ft.dwLowDateTime;
> +    tmpres /= 10;  // convert into microseconds
> +    tmpres -= (int64_t) 11644473600000000;
> +    tv->tv_sec = (long) (tmpres / 1000000UL);
> +    tv->tv_usec = (long) (tmpres % 1000000UL);
> +  }
> +  (void) tz;
> +  return 0;
> +}
> +
> +static int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len) {
> +  int ret;
> +  char buf[MAX_PATH * 2], buf2[MAX_PATH * 2], *p;
> +  strncpy(buf, path, sizeof(buf));
> +  buf[sizeof(buf) - 1] = '\0';
> +  // Trim trailing slashes. Leave backslash for paths like "X:\"
> +  p = buf + strlen(buf) - 1;
> +  while (p > buf && p[-1] != ':' && (p[0] == '\\' || p[0] == '/')) *p-- = '\0';
> +  memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
> +  ret = MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
> +  // Convert back to Unicode. If doubly-converted string does not match the
> +  // original, something is fishy, reject.
> +  WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
> +                      NULL, NULL);
> +  if (strcmp(buf, buf2) != 0) {
> +    wbuf[0] = L'\0';
> +    ret = 0;
> +  }
> +  return ret;
> +}
>   
>   DIR *opendir(const char *name) {
> -  struct win32_dir *dir = NULL;
> +  DIR *d = NULL;
>     wchar_t wpath[MAX_PATH];
>     DWORD attrs;
>   
>     if (name == NULL) {
>       SetLastError(ERROR_BAD_ARGUMENTS);
> -  } else if ((dir = (struct win32_dir *) MG_MALLOC(sizeof(*dir))) == NULL) {
> +  } else if ((d = (DIR *) calloc(1, sizeof(*d))) == NULL) {
>       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
>     } else {
> -    to_wchar(name, wpath, ARRAY_SIZE(wpath));
> +    to_wchar(name, wpath, sizeof(wpath) / sizeof(wpath[0]));
>       attrs = GetFileAttributesW(wpath);
> -    if (attrs != 0xFFFFFFFF && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
> +    if (attrs != 0Xffffffff && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
>         (void) wcscat(wpath, L"\\*");
> -      dir->handle = FindFirstFileW(wpath, &dir->info);
> -      dir->result.d_name[0] = '\0';
> +      d->handle = FindFirstFileW(wpath, &d->info);
> +      d->result.d_name[0] = '\0';
>       } else {
> -      MG_FREE(dir);
> -      dir = NULL;
> +      free(d);
> +      d = NULL;
>       }
>     }
> -
> -  return (DIR *) dir;
> +  return d;
>   }
>   
>   int closedir(DIR *d) {
> -  struct win32_dir *dir = (struct win32_dir *) d;
>     int result = 0;
> -
> -  if (dir != NULL) {
> -    if (dir->handle != INVALID_HANDLE_VALUE)
> -      result = FindClose(dir->handle) ? 0 : -1;
> -    MG_FREE(dir);
> +  if (d != NULL) {
> +    if (d->handle != INVALID_HANDLE_VALUE)
> +      result = FindClose(d->handle) ? 0 : -1;
> +    free(d);
>     } else {
>       result = -1;
>       SetLastError(ERROR_BAD_ARGUMENTS);
>     }
> -
>     return result;
>   }
>   
>   struct dirent *readdir(DIR *d) {
> -  struct win32_dir *dir = (struct win32_dir *) d;
>     struct dirent *result = NULL;
> -
> -  if (dir) {
> -    memset(&dir->result, 0, sizeof(dir->result));
> -    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;
> +  if (d != NULL) {
> +    memset(&d->result, 0, sizeof(d->result));
> +    if (d->handle != INVALID_HANDLE_VALUE) {
> +      result = &d->result;
> +      WideCharToMultiByte(CP_UTF8, 0, d->info.cFileName, -1, result->d_name,
> +                          sizeof(result->d_name), NULL, NULL);
> +      if (!FindNextFileW(d->handle, &d->info)) {
> +        FindClose(d->handle);
> +        d->handle = INVALID_HANDLE_VALUE;
>         }
> -
>       } else {
>         SetLastError(ERROR_FILE_NOT_FOUND);
>       }
>     } else {
>       SetLastError(ERROR_BAD_ARGUMENTS);
>     }
> -
>     return result;
>   }
>   #endif
>   
> -#endif /* EXCLUDE_COMMON */
> -
> -/* ISO C requires a translation unit to contain at least one declaration */
> -typedef int cs_dirent_dummy;
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_time.c"
> +static void p_list(const char *dir, void (*fn)(const char *, void *),
> +                   void *userdata) {
> +#if MG_ENABLE_DIRLIST
> +  struct dirent *dp;
> +  DIR *dirp;
> +  if ((dirp = (opendir(dir))) == NULL) return;
> +  while ((dp = readdir(dirp)) != NULL) {
> +    if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue;
> +    fn(dp->d_name, userdata);
> +  }
> +  closedir(dirp);
> +#else
> +  (void) dir, (void) fn, (void) userdata;
>   #endif
> +}
>   
> -/* Amalgamated: #include "common/cs_time.h" */
> -
> -#ifndef _WIN32
> -#include <stddef.h>
> -/*
> - * There is no sys/time.h on ARMCC.
> - */
> -#if !(defined(__ARMCC_VERSION) || defined(__ICCARM__)) && \
> -    !defined(__TI_COMPILER_VERSION__) &&                  \
> -    (!defined(CS_PLATFORM) || CS_PLATFORM != CS_P_NXP_LPC)
> -#include <sys/time.h>
> -#endif
> -#else
> -#include <windows.h>
> -#endif
> -
> -double cs_time(void) WEAK;
> -double cs_time(void) {
> -  double now;
> -#ifndef _WIN32
> -  struct timeval tv;
> -  if (gettimeofday(&tv, NULL /* tz */) != 0) return 0;
> -  now = (double) tv.tv_sec + (((double) tv.tv_usec) / 1000000.0);
> -#else
> -  SYSTEMTIME sysnow;
> -  FILETIME ftime;
> -  GetLocalTime(&sysnow);
> -  SystemTimeToFileTime(&sysnow, &ftime);
> -  /*
> -   * 1. VC 6.0 doesn't support conversion uint64 -> double, so, using int64
> -   * This should not cause a problems in this (21th) century
> -   * 2. Windows FILETIME is a number of 100-nanosecond intervals since January
> -   * 1, 1601 while time_t is a number of _seconds_ since January 1, 1970 UTC,
> -   * thus, we need to convert to seconds and adjust amount (subtract 11644473600
> -   * seconds)
> -   */
> -  now = (double) (((int64_t) ftime.dwLowDateTime +
> -                   ((int64_t) ftime.dwHighDateTime << 32)) /
> -                  10000000.0) -
> -        11644473600;
> -#endif /* _WIN32 */
> -  return now;
> -}
> -
> -double cs_timegm(const struct tm *tm) {
> -  /* Month-to-day offset for non-leap-years. */
> -  static const int month_day[12] = {0,   31,  59,  90,  120, 151,
> -                                    181, 212, 243, 273, 304, 334};
> -
> -  /* Most of the calculation is easy; leap years are the main difficulty. */
> -  int month = tm->tm_mon % 12;
> -  int year = tm->tm_year + tm->tm_mon / 12;
> -  int year_for_leap;
> -  int64_t rt;
> -
> -  if (month < 0) { /* Negative values % 12 are still negative. */
> -    month += 12;
> -    --year;
> -  }
> -
> -  /* This is the number of Februaries since 1900. */
> -  year_for_leap = (month > 1) ? year + 1 : year;
> -
> -  rt =
> -      tm->tm_sec /* Seconds */
> -      +
> -      60 *
> -          (tm->tm_min /* Minute = 60 seconds */
> -           +
> -           60 * (tm->tm_hour /* Hour = 60 minutes */
> -                 +
> -                 24 * (month_day[month] + tm->tm_mday - 1 /* Day = 24 hours */
> -                       + 365 * (year - 70)                /* Year = 365 days */
> -                       + (year_for_leap - 69) / 4 /* Every 4 years is leap... */
> -                       - (year_for_leap - 1) / 100 /* Except centuries... */
> -                       + (year_for_leap + 299) / 400))); /* Except 400s. */
> -  return rt < 0 ? -1 : (double) rt;
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_endian.h"
> -#endif
> -
> -#ifndef CS_COMMON_CS_ENDIAN_H_
> -#define CS_COMMON_CS_ENDIAN_H_
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -/*
> - * clang with std=-c99 uses __LITTLE_ENDIAN, by default
> - * while for ex, RTOS gcc - LITTLE_ENDIAN, by default
> - * it depends on __USE_BSD, but let's have everything
> - */
> -#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
> -#define BYTE_ORDER __BYTE_ORDER
> -#ifndef LITTLE_ENDIAN
> -#define LITTLE_ENDIAN __LITTLE_ENDIAN
> -#endif /* LITTLE_ENDIAN */
> -#ifndef BIG_ENDIAN
> -#define BIG_ENDIAN __LITTLE_ENDIAN
> -#endif /* BIG_ENDIAN */
> -#endif /* BYTE_ORDER */
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_COMMON_CS_ENDIAN_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_md5.c"
> -#endif
> -/*
> - * This code implements the MD5 message-digest algorithm.
> - * The algorithm is due to Ron Rivest.  This code was
> - * written by Colin Plumb in 1993, no copyright is claimed.
> - * This code is in the public domain; do with it what you wish.
> - *
> - * Equivalent code is available from RSA Data Security, Inc.
> - * This code has been tested against that, and is equivalent,
> - * except that you don't need to include two pages of legalese
> - * with every copy.
> - *
> - * To compute the message digest of a chunk of bytes, declare an
> - * MD5Context structure, pass it to MD5Init, call MD5Update as
> - * needed on buffers full of bytes, and then call MD5Final, which
> - * will fill a supplied 16-byte array with the digest.
> - */
> -
> -/* Amalgamated: #include "common/cs_md5.h" */
> -/* Amalgamated: #include "common/str_util.h" */
> -
> -#if !defined(EXCLUDE_COMMON)
> -#if !CS_DISABLE_MD5
> -
> -/* Amalgamated: #include "common/cs_endian.h" */
> -
> -static void byteReverse(unsigned char *buf, unsigned longs) {
> -/* Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN */
> -#if BYTE_ORDER == BIG_ENDIAN
> -  do {
> -    uint32_t t = (uint32_t)((unsigned) buf[3] << 8 | buf[2]) << 16 |
> -                 ((unsigned) buf[1] << 8 | buf[0]);
> -    *(uint32_t *) buf = t;
> -    buf += 4;
> -  } while (--longs);
> -#else
> -  (void) buf;
> -  (void) longs;
> -#endif
> -}
> -
> -#define F1(x, y, z) (z ^ (x & (y ^ z)))
> -#define F2(x, y, z) F1(z, x, y)
> -#define F3(x, y, z) (x ^ y ^ z)
> -#define F4(x, y, z) (y ^ (x | ~z))
> -
> -#define MD5STEP(f, w, x, y, z, data, s) \
> -  (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x)
> -
> -/*
> - * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
> - * initialization constants.
> - */
> -void cs_md5_init(cs_md5_ctx *ctx) {
> -  ctx->buf[0] = 0x67452301;
> -  ctx->buf[1] = 0xefcdab89;
> -  ctx->buf[2] = 0x98badcfe;
> -  ctx->buf[3] = 0x10325476;
> -
> -  ctx->bits[0] = 0;
> -  ctx->bits[1] = 0;
> -}
> -
> -static void cs_md5_transform(uint32_t buf[4], uint32_t const in[16]) {
> -  register uint32_t a, b, c, d;
> -
> -  a = buf[0];
> -  b = buf[1];
> -  c = buf[2];
> -  d = buf[3];
> -
> -  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
> -  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
> -  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
> -  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
> -  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
> -  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
> -  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
> -  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
> -  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
> -  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
> -  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
> -  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
> -  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
> -  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
> -  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
> -  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
> -
> -  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
> -  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
> -  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
> -  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
> -  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
> -  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
> -  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
> -  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
> -  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
> -  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
> -  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
> -  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
> -  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
> -  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
> -  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
> -  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
> -
> -  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
> -  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
> -  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
> -  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
> -  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
> -  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
> -  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
> -  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
> -  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
> -  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
> -  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
> -  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
> -  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
> -  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
> -  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
> -  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
> -
> -  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
> -  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
> -  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
> -  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
> -  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
> -  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
> -  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
> -  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
> -  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
> -  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
> -  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
> -  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
> -  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
> -  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
> -  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
> -  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
> -
> -  buf[0] += a;
> -  buf[1] += b;
> -  buf[2] += c;
> -  buf[3] += d;
> -}
> -
> -void cs_md5_update(cs_md5_ctx *ctx, const unsigned char *buf, size_t len) {
> -  uint32_t t;
> -
> -  t = ctx->bits[0];
> -  if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) ctx->bits[1]++;
> -  ctx->bits[1] += (uint32_t) len >> 29;
> -
> -  t = (t >> 3) & 0x3f;
> -
> -  if (t) {
> -    unsigned char *p = (unsigned char *) ctx->in + t;
> -
> -    t = 64 - t;
> -    if (len < t) {
> -      memcpy(p, buf, len);
> -      return;
> -    }
> -    memcpy(p, buf, t);
> -    byteReverse(ctx->in, 16);
> -    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> -    buf += t;
> -    len -= t;
> -  }
> -
> -  while (len >= 64) {
> -    memcpy(ctx->in, buf, 64);
> -    byteReverse(ctx->in, 16);
> -    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> -    buf += 64;
> -    len -= 64;
> -  }
> -
> -  memcpy(ctx->in, buf, len);
> -}
> -
> -void cs_md5_final(unsigned char digest[16], cs_md5_ctx *ctx) {
> -  unsigned count;
> -  unsigned char *p;
> -  uint32_t *a;
> -
> -  count = (ctx->bits[0] >> 3) & 0x3F;
> -
> -  p = ctx->in + count;
> -  *p++ = 0x80;
> -  count = 64 - 1 - count;
> -  if (count < 8) {
> -    memset(p, 0, count);
> -    byteReverse(ctx->in, 16);
> -    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> -    memset(ctx->in, 0, 56);
> -  } else {
> -    memset(p, 0, count - 8);
> -  }
> -  byteReverse(ctx->in, 14);
> -
> -  a = (uint32_t *) ctx->in;
> -  a[14] = ctx->bits[0];
> -  a[15] = ctx->bits[1];
> -
> -  cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> -  byteReverse((unsigned char *) ctx->buf, 4);
> -  memcpy(digest, ctx->buf, 16);
> -  memset((char *) ctx, 0, sizeof(*ctx));
> -}
> -
> -#endif /* CS_DISABLE_MD5 */
> -#endif /* EXCLUDE_COMMON */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_sha1.c"
> -#endif
> -/* Copyright(c) By Steve Reid <steve@edmweb.com> */
> -/* 100% Public Domain */
> -
> -/* Amalgamated: #include "common/cs_sha1.h" */
> -
> -#if !CS_DISABLE_SHA1 && !defined(EXCLUDE_COMMON)
> -
> -/* Amalgamated: #include "common/cs_endian.h" */
> -
> -#define SHA1HANDSOFF
> -#if defined(__sun)
> -/* Amalgamated: #include "common/solarisfixes.h" */
> -#endif
> -
> -union char64long16 {
> -  unsigned char c[64];
> -  uint32_t l[16];
> -};
> -
> -#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
> -
> -static uint32_t blk0(union char64long16 *block, int i) {
> -/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
> -#if BYTE_ORDER == LITTLE_ENDIAN
> -  block->l[i] =
> -      (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
> -#endif
> -  return block->l[i];
> -}
> -
> -/* Avoid redefine warning (ARM /usr/include/sys/ucontext.h define R0~R4) */
> -#undef blk
> -#undef R0
> -#undef R1
> -#undef R2
> -#undef R3
> -#undef R4
> -
> -#define blk(i)                                                               \
> -  (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
> -                              block->l[(i + 2) & 15] ^ block->l[i & 15],     \
> -                          1))
> -#define R0(v, w, x, y, z, i)                                          \
> -  z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \
> -  w = rol(w, 30);
> -#define R1(v, w, x, y, z, i)                                  \
> -  z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
> -  w = rol(w, 30);
> -#define R2(v, w, x, y, z, i)                          \
> -  z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
> -  w = rol(w, 30);
> -#define R3(v, w, x, y, z, i)                                        \
> -  z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
> -  w = rol(w, 30);
> -#define R4(v, w, x, y, z, i)                          \
> -  z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
> -  w = rol(w, 30);
> -
> -static void cs_sha1_transform(uint32_t state[5], const unsigned char buffer[64]) {
> -  uint32_t a, b, c, d, e;
> -  union char64long16 block[1];
> -
> -  memcpy(block, buffer, 64);
> -  a = state[0];
> -  b = state[1];
> -  c = state[2];
> -  d = state[3];
> -  e = state[4];
> -  R0(a, b, c, d, e, 0);
> -  R0(e, a, b, c, d, 1);
> -  R0(d, e, a, b, c, 2);
> -  R0(c, d, e, a, b, 3);
> -  R0(b, c, d, e, a, 4);
> -  R0(a, b, c, d, e, 5);
> -  R0(e, a, b, c, d, 6);
> -  R0(d, e, a, b, c, 7);
> -  R0(c, d, e, a, b, 8);
> -  R0(b, c, d, e, a, 9);
> -  R0(a, b, c, d, e, 10);
> -  R0(e, a, b, c, d, 11);
> -  R0(d, e, a, b, c, 12);
> -  R0(c, d, e, a, b, 13);
> -  R0(b, c, d, e, a, 14);
> -  R0(a, b, c, d, e, 15);
> -  R1(e, a, b, c, d, 16);
> -  R1(d, e, a, b, c, 17);
> -  R1(c, d, e, a, b, 18);
> -  R1(b, c, d, e, a, 19);
> -  R2(a, b, c, d, e, 20);
> -  R2(e, a, b, c, d, 21);
> -  R2(d, e, a, b, c, 22);
> -  R2(c, d, e, a, b, 23);
> -  R2(b, c, d, e, a, 24);
> -  R2(a, b, c, d, e, 25);
> -  R2(e, a, b, c, d, 26);
> -  R2(d, e, a, b, c, 27);
> -  R2(c, d, e, a, b, 28);
> -  R2(b, c, d, e, a, 29);
> -  R2(a, b, c, d, e, 30);
> -  R2(e, a, b, c, d, 31);
> -  R2(d, e, a, b, c, 32);
> -  R2(c, d, e, a, b, 33);
> -  R2(b, c, d, e, a, 34);
> -  R2(a, b, c, d, e, 35);
> -  R2(e, a, b, c, d, 36);
> -  R2(d, e, a, b, c, 37);
> -  R2(c, d, e, a, b, 38);
> -  R2(b, c, d, e, a, 39);
> -  R3(a, b, c, d, e, 40);
> -  R3(e, a, b, c, d, 41);
> -  R3(d, e, a, b, c, 42);
> -  R3(c, d, e, a, b, 43);
> -  R3(b, c, d, e, a, 44);
> -  R3(a, b, c, d, e, 45);
> -  R3(e, a, b, c, d, 46);
> -  R3(d, e, a, b, c, 47);
> -  R3(c, d, e, a, b, 48);
> -  R3(b, c, d, e, a, 49);
> -  R3(a, b, c, d, e, 50);
> -  R3(e, a, b, c, d, 51);
> -  R3(d, e, a, b, c, 52);
> -  R3(c, d, e, a, b, 53);
> -  R3(b, c, d, e, a, 54);
> -  R3(a, b, c, d, e, 55);
> -  R3(e, a, b, c, d, 56);
> -  R3(d, e, a, b, c, 57);
> -  R3(c, d, e, a, b, 58);
> -  R3(b, c, d, e, a, 59);
> -  R4(a, b, c, d, e, 60);
> -  R4(e, a, b, c, d, 61);
> -  R4(d, e, a, b, c, 62);
> -  R4(c, d, e, a, b, 63);
> -  R4(b, c, d, e, a, 64);
> -  R4(a, b, c, d, e, 65);
> -  R4(e, a, b, c, d, 66);
> -  R4(d, e, a, b, c, 67);
> -  R4(c, d, e, a, b, 68);
> -  R4(b, c, d, e, a, 69);
> -  R4(a, b, c, d, e, 70);
> -  R4(e, a, b, c, d, 71);
> -  R4(d, e, a, b, c, 72);
> -  R4(c, d, e, a, b, 73);
> -  R4(b, c, d, e, a, 74);
> -  R4(a, b, c, d, e, 75);
> -  R4(e, a, b, c, d, 76);
> -  R4(d, e, a, b, c, 77);
> -  R4(c, d, e, a, b, 78);
> -  R4(b, c, d, e, a, 79);
> -  state[0] += a;
> -  state[1] += b;
> -  state[2] += c;
> -  state[3] += d;
> -  state[4] += e;
> -  /* Erase working structures. The order of operations is important,
> -   * used to ensure that compiler doesn't optimize those out. */
> -  memset(block, 0, sizeof(block));
> -  a = b = c = d = e = 0;
> -  (void) a;
> -  (void) b;
> -  (void) c;
> -  (void) d;
> -  (void) e;
> -}
> -
> -void cs_sha1_init(cs_sha1_ctx *context) {
> -  context->state[0] = 0x67452301;
> -  context->state[1] = 0xEFCDAB89;
> -  context->state[2] = 0x98BADCFE;
> -  context->state[3] = 0x10325476;
> -  context->state[4] = 0xC3D2E1F0;
> -  context->count[0] = context->count[1] = 0;
> -}
> -
> -void cs_sha1_update(cs_sha1_ctx *context, const unsigned char *data,
> -                    uint32_t len) {
> -  uint32_t i, j;
> -
> -  j = context->count[0];
> -  if ((context->count[0] += len << 3) < j) context->count[1]++;
> -  context->count[1] += (len >> 29);
> -  j = (j >> 3) & 63;
> -  if ((j + len) > 63) {
> -    memcpy(&context->buffer[j], data, (i = 64 - j));
> -    cs_sha1_transform(context->state, context->buffer);
> -    for (; i + 63 < len; i += 64) {
> -      cs_sha1_transform(context->state, &data[i]);
> -    }
> -    j = 0;
> -  } else
> -    i = 0;
> -  memcpy(&context->buffer[j], &data[i], len - i);
> -}
> -
> -void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *context) {
> -  unsigned i;
> -  unsigned char finalcount[8], c;
> -
> -  for (i = 0; i < 8; i++) {
> -    finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
> -                                      ((3 - (i & 3)) * 8)) &
> -                                     255);
> -  }
> -  c = 0200;
> -  cs_sha1_update(context, &c, 1);
> -  while ((context->count[0] & 504) != 448) {
> -    c = 0000;
> -    cs_sha1_update(context, &c, 1);
> -  }
> -  cs_sha1_update(context, finalcount, 8);
> -  for (i = 0; i < 20; i++) {
> -    digest[i] =
> -        (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
> -  }
> -  memset(context, '\0', sizeof(*context));
> -  memset(&finalcount, '\0', sizeof(finalcount));
> -}
> -
> -void cs_hmac_sha1(const unsigned char *key, size_t keylen,
> -                  const unsigned char *data, size_t datalen,
> -                  unsigned char out[20]) {
> -  cs_sha1_ctx ctx;
> -  unsigned char buf1[64], buf2[64], tmp_key[20], i;
> -
> -  if (keylen > sizeof(buf1)) {
> -    cs_sha1_init(&ctx);
> -    cs_sha1_update(&ctx, key, keylen);
> -    cs_sha1_final(tmp_key, &ctx);
> -    key = tmp_key;
> -    keylen = sizeof(tmp_key);
> -  }
> -
> -  memset(buf1, 0, sizeof(buf1));
> -  memset(buf2, 0, sizeof(buf2));
> -  memcpy(buf1, key, keylen);
> -  memcpy(buf2, key, keylen);
> -
> -  for (i = 0; i < sizeof(buf1); i++) {
> -    buf1[i] ^= 0x36;
> -    buf2[i] ^= 0x5c;
> -  }
> -
> -  cs_sha1_init(&ctx);
> -  cs_sha1_update(&ctx, buf1, sizeof(buf1));
> -  cs_sha1_update(&ctx, data, datalen);
> -  cs_sha1_final(out, &ctx);
> -
> -  cs_sha1_init(&ctx);
> -  cs_sha1_update(&ctx, buf2, sizeof(buf2));
> -  cs_sha1_update(&ctx, out, 20);
> -  cs_sha1_final(out, &ctx);
> -}
> -
> -#endif /* EXCLUDE_COMMON */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/mbuf.c"
> -#endif
> -
> -#ifndef EXCLUDE_COMMON
> -
> -#include <assert.h>
> -#include <string.h>
> -/* Amalgamated: #include "common/mbuf.h" */
> -
> -#ifndef MBUF_REALLOC
> -#define MBUF_REALLOC realloc
> -#endif
> -
> -#ifndef MBUF_FREE
> -#define MBUF_FREE free
> -#endif
> -
> -void mbuf_init(struct mbuf *mbuf, size_t initial_size) WEAK;
> -void mbuf_init(struct mbuf *mbuf, size_t initial_size) {
> -  mbuf->len = mbuf->size = 0;
> -  mbuf->buf = NULL;
> -  mbuf_resize(mbuf, initial_size);
> -}
> -
> -void mbuf_free(struct mbuf *mbuf) WEAK;
> -void mbuf_free(struct mbuf *mbuf) {
> -  if (mbuf->buf != NULL) {
> -    MBUF_FREE(mbuf->buf);
> -    mbuf_init(mbuf, 0);
> -  }
> -}
> -
> -void mbuf_resize(struct mbuf *a, size_t new_size) WEAK;
> -void mbuf_resize(struct mbuf *a, size_t new_size) {
> -  if (new_size > a->size || (new_size < a->size && new_size >= a->len)) {
> -    char *buf = (char *) MBUF_REALLOC(a->buf, new_size);
> -    /*
> -     * In case realloc fails, there's not much we can do, except keep things as
> -     * they are. Note that NULL is a valid return value from realloc when
> -     * size == 0, but that is covered too.
> -     */
> -    if (buf == NULL && new_size != 0) return;
> -    a->buf = buf;
> -    a->size = new_size;
> -  }
> -}
> -
> -void mbuf_trim(struct mbuf *mbuf) WEAK;
> -void mbuf_trim(struct mbuf *mbuf) {
> -  mbuf_resize(mbuf, mbuf->len);
> -}
> -
> -size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t) WEAK;
> -size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t len) {
> -  char *p = NULL;
> -
> -  assert(a != NULL);
> -  assert(a->len <= a->size);
> -  assert(off <= a->len);
> -
> -  /* check overflow */
> -  if (~(size_t) 0 - (size_t) a->buf < len) return 0;
> -
> -  if (a->len + len <= a->size) {
> -    memmove(a->buf + off + len, a->buf + off, a->len - off);
> -    if (buf != NULL) {
> -      memcpy(a->buf + off, buf, len);
> -    }
> -    a->len += len;
> -  } else {
> -    size_t min_size = (a->len + len);
> -    size_t new_size = (size_t)(min_size * MBUF_SIZE_MULTIPLIER);
> -    if (new_size - min_size > MBUF_SIZE_MAX_HEADROOM) {
> -      new_size = min_size + MBUF_SIZE_MAX_HEADROOM;
> -    }
> -    p = (char *) MBUF_REALLOC(a->buf, new_size);
> -    if (p == NULL && new_size != min_size) {
> -      new_size = min_size;
> -      p = (char *) MBUF_REALLOC(a->buf, new_size);
> -    }
> -    if (p != NULL) {
> -      a->buf = p;
> -      if (off != a->len) {
> -        memmove(a->buf + off + len, a->buf + off, a->len - off);
> -      }
> -      if (buf != NULL) memcpy(a->buf + off, buf, len);
> -      a->len += len;
> -      a->size = new_size;
> -    } else {
> -      len = 0;
> -    }
> -  }
> -
> -  return len;
> -}
> -
> -size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) WEAK;
> -size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) {
> -  return mbuf_insert(a, a->len, buf, len);
> -}
> -
> -size_t mbuf_append_and_free(struct mbuf *a, void *buf, size_t len) WEAK;
> -size_t mbuf_append_and_free(struct mbuf *a, void *data, size_t len) {
> -  size_t ret;
> -  /* Optimization: if the buffer is currently empty,
> -   * take over the user-provided buffer. */
> -  if (a->len == 0) {
> -    if (a->buf != NULL) free(a->buf);
> -    a->buf = (char *) data;
> -    a->len = a->size = len;
> -    return len;
> -  }
> -  ret = mbuf_insert(a, a->len, data, len);
> -  free(data);
> -  return ret;
> -}
> -
> -void mbuf_remove(struct mbuf *mb, size_t n) WEAK;
> -void mbuf_remove(struct mbuf *mb, size_t n) {
> -  if (n > 0 && n <= mb->len) {
> -    memmove(mb->buf, mb->buf + n, mb->len - n);
> -    mb->len -= n;
> -  }
> -}
> -
> -void mbuf_clear(struct mbuf *mb) WEAK;
> -void mbuf_clear(struct mbuf *mb) {
> -  mb->len = 0;
> -}
> -
> -void mbuf_move(struct mbuf *from, struct mbuf *to) WEAK;
> -void mbuf_move(struct mbuf *from, struct mbuf *to) {
> -  memcpy(to, from, sizeof(*to));
> -  memset(from, 0, sizeof(*from));
> -}
> -
> -#endif /* EXCLUDE_COMMON */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/mg_str.c"
> -#endif
> -
> -/* Amalgamated: #include "common/mg_mem.h" */
> -/* Amalgamated: #include "common/mg_str.h" */
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#include <ctype.h>
> -#include <stdlib.h>
> -#include <string.h>
> -
> -int mg_ncasecmp(const char *s1, const char *s2, size_t len) WEAK;
> -
> -struct mg_str mg_mk_str(const char *s) WEAK;
> -struct mg_str mg_mk_str(const char *s) {
> -  struct mg_str ret = {s, 0};
> -  if (s != NULL) ret.len = strlen(s);
> -  return ret;
> -}
> -
> -struct mg_str mg_mk_str_n(const char *s, size_t len) WEAK;
> -struct mg_str mg_mk_str_n(const char *s, size_t len) {
> -  struct mg_str ret = {s, len};
> -  return ret;
> -}
> -
> -int mg_vcmp(const struct mg_str *str1, const char *str2) WEAK;
> -int mg_vcmp(const struct mg_str *str1, const char *str2) {
> -  size_t n2 = strlen(str2), n1 = str1->len;
> -  int r = strncmp(str1->p, str2, (n1 < n2) ? n1 : n2);
> -  if (r == 0) {
> -    return n1 - n2;
> -  }
> -  return r;
> -}
> -
> -int mg_vcasecmp(const struct mg_str *str1, const char *str2) WEAK;
> -int mg_vcasecmp(const struct mg_str *str1, const char *str2) {
> -  size_t n2 = strlen(str2), n1 = str1->len;
> -  int r = mg_ncasecmp(str1->p, str2, (n1 < n2) ? n1 : n2);
> -  if (r == 0) {
> -    return n1 - n2;
> -  }
> -  return r;
> -}
> -
> -static struct mg_str mg_strdup_common(const struct mg_str s,
> -                                      int nul_terminate) {
> -  struct mg_str r = {NULL, 0};
> -  if (s.len > 0 && s.p != NULL) {
> -    char *sc = (char *) MG_MALLOC(s.len + (nul_terminate ? 1 : 0));
> -    if (sc != NULL) {
> -      memcpy(sc, s.p, s.len);
> -      if (nul_terminate) sc[s.len] = '\0';
> -      r.p = sc;
> -      r.len = s.len;
> -    }
> -  }
> -  return r;
> -}
> -
> -struct mg_str mg_strdup(const struct mg_str s) WEAK;
> -struct mg_str mg_strdup(const struct mg_str s) {
> -  return mg_strdup_common(s, 0 /* NUL-terminate */);
> -}
> -
> -struct mg_str mg_strdup_nul(const struct mg_str s) WEAK;
> -struct mg_str mg_strdup_nul(const struct mg_str s) {
> -  return mg_strdup_common(s, 1 /* NUL-terminate */);
> -}
> -
> -const char *mg_strchr(const struct mg_str s, int c) WEAK;
> -const char *mg_strchr(const struct mg_str s, int c) {
> -  size_t i;
> -  for (i = 0; i < s.len; i++) {
> -    if (s.p[i] == c) return &s.p[i];
> -  }
> -  return NULL;
> -}
> -
> -int mg_strcmp(const struct mg_str str1, const struct mg_str str2) WEAK;
> -int mg_strcmp(const struct mg_str str1, const struct mg_str str2) {
> -  size_t i = 0;
> -  while (i < str1.len && i < str2.len) {
> -    int c1 = str1.p[i];
> -    int c2 = str2.p[i];
> -    if (c1 < c2) return -1;
> -    if (c1 > c2) return 1;
> -    i++;
> -  }
> -  if (i < str1.len) return 1;
> -  if (i < str2.len) return -1;
> -  return 0;
> -}
> -
> -int mg_strncmp(const struct mg_str, const struct mg_str, size_t n) WEAK;
> -int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n) {
> -  struct mg_str s1 = str1;
> -  struct mg_str s2 = str2;
> -
> -  if (s1.len > n) {
> -    s1.len = n;
> -  }
> -  if (s2.len > n) {
> -    s2.len = n;
> -  }
> -  return mg_strcmp(s1, s2);
> -}
> -
> -int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2) WEAK;
> -int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2) {
> -  size_t i = 0;
> -  while (i < str1.len && i < str2.len) {
> -    int c1 = tolower((int) str1.p[i]);
> -    int c2 = tolower((int) str2.p[i]);
> -    if (c1 < c2) return -1;
> -    if (c1 > c2) return 1;
> -    i++;
> -  }
> -  if (i < str1.len) return 1;
> -  if (i < str2.len) return -1;
> -  return 0;
> -}
> -
> -void mg_strfree(struct mg_str *s) WEAK;
> -void mg_strfree(struct mg_str *s) {
> -  char *sp = (char *) s->p;
> -  s->p = NULL;
> -  s->len = 0;
> -  if (sp != NULL) free(sp);
> -}
> -
> -const char *mg_strstr(const struct mg_str haystack,
> -                      const struct mg_str needle) WEAK;
> -const char *mg_strstr(const struct mg_str haystack,
> -                      const struct mg_str needle) {
> -  size_t i;
> -  if (needle.len > haystack.len) return NULL;
> -  for (i = 0; i <= haystack.len - needle.len; i++) {
> -    if (memcmp(haystack.p + i, needle.p, needle.len) == 0) {
> -      return haystack.p + i;
> -    }
> -  }
> -  return NULL;
> -}
> -
> -struct mg_str mg_strstrip(struct mg_str s) WEAK;
> -struct mg_str mg_strstrip(struct mg_str s) {
> -  while (s.len > 0 && isspace((int) *s.p)) {
> -    s.p++;
> -    s.len--;
> -  }
> -  while (s.len > 0 && isspace((int) *(s.p + s.len - 1))) {
> -    s.len--;
> -  }
> -  return s;
> -}
> -
> -int mg_str_starts_with(struct mg_str s, struct mg_str prefix) WEAK;
> -int mg_str_starts_with(struct mg_str s, struct mg_str prefix) {
> -  const struct mg_str sp = MG_MK_STR_N(s.p, prefix.len);
> -  if (s.len < prefix.len) return 0;
> -  return (mg_strcmp(sp, prefix) == 0);
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/str_util.c"
> -#endif
> -
> -#ifndef EXCLUDE_COMMON
> -
> -/* Amalgamated: #include "common/str_util.h" */
> -/* Amalgamated: #include "common/mg_mem.h" */
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifndef C_DISABLE_BUILTIN_SNPRINTF
> -#define C_DISABLE_BUILTIN_SNPRINTF 0
> -#endif
> -
> -/* Amalgamated: #include "common/mg_mem.h" */
> -
> -size_t c_strnlen(const char *s, size_t maxlen) WEAK;
> -size_t c_strnlen(const char *s, size_t maxlen) {
> -  size_t l = 0;
> -  for (; l < maxlen && s[l] != '\0'; l++) {
> -  }
> -  return l;
> -}
> -
> -#define C_SNPRINTF_APPEND_CHAR(ch)       \
> -  do {                                   \
> -    if (i < (int) buf_size) buf[i] = ch; \
> -    i++;                                 \
> -  } while (0)
> -
> -#define C_SNPRINTF_FLAG_ZERO 1
> -
> -#if C_DISABLE_BUILTIN_SNPRINTF
> -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) WEAK;
> -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) {
> -  return vsnprintf(buf, buf_size, fmt, ap);
> -}
> -#else
> -static int c_itoa(char *buf, size_t buf_size, int64_t num, int base, int flags,
> -                  int field_width) {
> -  char tmp[40];
> -  int i = 0, k = 0, neg = 0;
> -
> -  if (num < 0) {
> -    neg++;
> -    num = -num;
> -  }
> -
> -  /* Print into temporary buffer - in reverse order */
> -  do {
> -    int rem = num % base;
> -    if (rem < 10) {
> -      tmp[k++] = '0' + rem;
> -    } else {
> -      tmp[k++] = 'a' + (rem - 10);
> -    }
> -    num /= base;
> -  } while (num > 0);
> -
> -  /* Zero padding */
> -  if (flags && C_SNPRINTF_FLAG_ZERO) {
> -    while (k < field_width && k < (int) sizeof(tmp) - 1) {
> -      tmp[k++] = '0';
> -    }
> -  }
> -
> -  /* And sign */
> -  if (neg) {
> -    tmp[k++] = '-';
> -  }
> -
> -  /* Now output */
> -  while (--k >= 0) {
> -    C_SNPRINTF_APPEND_CHAR(tmp[k]);
> -  }
> -
> -  return i;
> -}
> -
> -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) WEAK;
> -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) {
> -  int ch, i = 0, len_mod, flags, precision, field_width;
> -
> -  while ((ch = *fmt++) != '\0') {
> -    if (ch != '%') {
> -      C_SNPRINTF_APPEND_CHAR(ch);
> -    } else {
> -      /*
> -       * Conversion specification:
> -       *   zero or more flags (one of: # 0 - <space> + ')
> -       *   an optional minimum  field  width (digits)
> -       *   an  optional precision (. followed by digits, or *)
> -       *   an optional length modifier (one of: hh h l ll L q j z t)
> -       *   conversion specifier (one of: d i o u x X e E f F g G a A c s p n)
> -       */
> -      flags = field_width = precision = len_mod = 0;
> -
> -      /* Flags. only zero-pad flag is supported. */
> -      if (*fmt == '0') {
> -        flags |= C_SNPRINTF_FLAG_ZERO;
> -      }
> -
> -      /* Field width */
> -      while (*fmt >= '0' && *fmt <= '9') {
> -        field_width *= 10;
> -        field_width += *fmt++ - '0';
> -      }
> -      /* Dynamic field width */
> -      if (*fmt == '*') {
> -        field_width = va_arg(ap, int);
> -        fmt++;
> -      }
> -
> -      /* Precision */
> -      if (*fmt == '.') {
> -        fmt++;
> -        if (*fmt == '*') {
> -          precision = va_arg(ap, int);
> -          fmt++;
> -        } else {
> -          while (*fmt >= '0' && *fmt <= '9') {
> -            precision *= 10;
> -            precision += *fmt++ - '0';
> -          }
> -        }
> -      }
> -
> -      /* Length modifier */
> -      switch (*fmt) {
> -        case 'h':
> -        case 'l':
> -        case 'L':
> -        case 'I':
> -        case 'q':
> -        case 'j':
> -        case 'z':
> -        case 't':
> -          len_mod = *fmt++;
> -          if (*fmt == 'h') {
> -            len_mod = 'H';
> -            fmt++;
> -          }
> -          if (*fmt == 'l') {
> -            len_mod = 'q';
> -            fmt++;
> -          }
> -          break;
> -      }
> -
> -      ch = *fmt++;
> -      if (ch == 's') {
> -        const char *s = va_arg(ap, const char *); /* Always fetch parameter */
> -        int j;
> -        int pad = field_width - (precision >= 0 ? c_strnlen(s, precision) : 0);
> -        for (j = 0; j < pad; j++) {
> -          C_SNPRINTF_APPEND_CHAR(' ');
> -        }
> -
> -        /* `s` may be NULL in case of %.*s */
> -        if (s != NULL) {
> -          /* Ignore negative and 0 precisions */
> -          for (j = 0; (precision <= 0 || j < precision) && s[j] != '\0'; j++) {
> -            C_SNPRINTF_APPEND_CHAR(s[j]);
> -          }
> -        }
> -      } else if (ch == 'c') {
> -        ch = va_arg(ap, int); /* Always fetch parameter */
> -        C_SNPRINTF_APPEND_CHAR(ch);
> -      } else if (ch == 'd' && len_mod == 0) {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, int), 10, flags,
> -                    field_width);
> -      } else if (ch == 'd' && len_mod == 'l') {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, long), 10, flags,
> -                    field_width);
> -#ifdef SSIZE_MAX
> -      } else if (ch == 'd' && len_mod == 'z') {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, ssize_t), 10, flags,
> -                    field_width);
> -#endif
> -      } else if (ch == 'd' && len_mod == 'q') {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, int64_t), 10, flags,
> -                    field_width);
> -      } else if ((ch == 'x' || ch == 'u') && len_mod == 0) {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned),
> -                    ch == 'x' ? 16 : 10, flags, field_width);
> -      } else if ((ch == 'x' || ch == 'u') && len_mod == 'l') {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned long),
> -                    ch == 'x' ? 16 : 10, flags, field_width);
> -      } else if ((ch == 'x' || ch == 'u') && len_mod == 'z') {
> -        i += c_itoa(buf + i, buf_size - i, va_arg(ap, size_t),
> -                    ch == 'x' ? 16 : 10, flags, field_width);
> -      } else if (ch == 'p') {
> -        unsigned long num = (unsigned long) (uintptr_t) va_arg(ap, void *);
> -        C_SNPRINTF_APPEND_CHAR('0');
> -        C_SNPRINTF_APPEND_CHAR('x');
> -        i += c_itoa(buf + i, buf_size - i, num, 16, flags, 0);
> -      } else {
> -#ifndef NO_LIBC
> -        /*
> -         * TODO(lsm): abort is not nice in a library, remove it
> -         * Also, ESP8266 SDK doesn't have it
> -         */
> -        abort();
> -#endif
> -      }
> -    }
> -  }
> -
> -  /* Zero-terminate the result */
> -  if (buf_size > 0) {
> -    buf[i < (int) buf_size ? i : (int) buf_size - 1] = '\0';
> -  }
> -
> -  return i;
> -}
> -#endif
> -
> -int c_snprintf(char *buf, size_t buf_size, const char *fmt, ...) WEAK;
> -int c_snprintf(char *buf, size_t buf_size, const char *fmt, ...) {
> -  int result;
> -  va_list ap;
> -  va_start(ap, fmt);
> -  result = c_vsnprintf(buf, buf_size, fmt, ap);
> -  va_end(ap);
> -  return result;
> -}
> -
> -#ifdef _WIN32
> -int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len) {
> -  int ret;
> -  char buf[MAX_PATH * 2], buf2[MAX_PATH * 2], *p;
> -
> -  strncpy(buf, path, sizeof(buf));
> -  buf[sizeof(buf) - 1] = '\0';
> -
> -  /* Trim trailing slashes. Leave backslash for paths like "X:\" */
> -  p = buf + strlen(buf) - 1;
> -  while (p > buf && p[-1] != ':' && (p[0] == '\\' || p[0] == '/')) *p-- = '\0';
> -
> -  memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
> -  ret = MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
> -
> -  /*
> -   * Convert back to Unicode. If doubly-converted string does not match the
> -   * original, something is fishy, reject.
> -   */
> -  WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
> -                      NULL, NULL);
> -  if (strcmp(buf, buf2) != 0) {
> -    wbuf[0] = L'\0';
> -    ret = 0;
> -  }
> -
> -  return ret;
> -}
> -#endif /* _WIN32 */
> -
> -/* The simplest O(mn) algorithm. Better implementation are GPLed */
> -const char *c_strnstr(const char *s, const char *find, size_t slen) WEAK;
> -const char *c_strnstr(const char *s, const char *find, size_t slen) {
> -  size_t find_length = strlen(find);
> -  size_t i;
> -
> -  for (i = 0; i < slen; i++) {
> -    if (i + find_length > slen) {
> -      return NULL;
> -    }
> -
> -    if (strncmp(&s[i], find, find_length) == 0) {
> -      return &s[i];
> -    }
> -  }
> -
> -  return NULL;
> -}
> -
> -#if CS_ENABLE_STRDUP
> -char *strdup(const char *src) WEAK;
> -char *strdup(const char *src) {
> -  size_t len = strlen(src) + 1;
> -  char *ret = MG_MALLOC(len);
> -  if (ret != NULL) {
> -    strcpy(ret, src);
> -  }
> -  return ret;
> -}
> -#endif
> -
> -void cs_to_hex(char *to, const unsigned char *p, size_t len) WEAK;
> -void cs_to_hex(char *to, const unsigned char *p, size_t len) {
> -  static const char *hex = "0123456789abcdef";
> -
> -  for (; len--; p++) {
> -    *to++ = hex[p[0] >> 4];
> -    *to++ = hex[p[0] & 0x0f];
> -  }
> -  *to = '\0';
> -}
> -
> -static int fourbit(int ch) {
> -  if (ch >= '0' && ch <= '9') {
> -    return ch - '0';
> -  } else if (ch >= 'a' && ch <= 'f') {
> -    return ch - 'a' + 10;
> -  } else if (ch >= 'A' && ch <= 'F') {
> -    return ch - 'A' + 10;
> -  }
> -  return 0;
> -}
> -
> -void cs_from_hex(char *to, const char *p, size_t len) WEAK;
> -void cs_from_hex(char *to, const char *p, size_t len) {
> -  size_t i;
> -
> -  for (i = 0; i < len; i += 2) {
> -    *to++ = (fourbit(p[i]) << 4) + fourbit(p[i + 1]);
> -  }
> -  *to = '\0';
> -}
> -
> -#if CS_ENABLE_TO64
> -int64_t cs_to64(const char *s) WEAK;
> -int64_t cs_to64(const char *s) {
> -  int64_t result = 0;
> -  int64_t neg = 1;
> -  while (*s && isspace((unsigned char) *s)) s++;
> -  if (*s == '-') {
> -    neg = -1;
> -    s++;
> -  }
> -  while (isdigit((unsigned char) *s)) {
> -    result *= 10;
> -    result += (*s - '0');
> -    s++;
> -  }
> -  return result * neg;
> -}
> -#endif
> -
> -static int str_util_lowercase(const char *s) {
> -  return tolower(*(const unsigned char *) s);
> -}
> -
> -int mg_ncasecmp(const char *s1, const char *s2, size_t len) WEAK;
> -int mg_ncasecmp(const char *s1, const char *s2, size_t len) {
> -  int diff = 0;
> -
> -  if (len > 0) do {
> -      diff = str_util_lowercase(s1++) - str_util_lowercase(s2++);
> -    } while (diff == 0 && s1[-1] != '\0' && --len > 0);
> -
> -  return diff;
> -}
> -
> -int mg_casecmp(const char *s1, const char *s2) WEAK;
> -int mg_casecmp(const char *s1, const char *s2) {
> -  return mg_ncasecmp(s1, s2, (size_t) ~0);
> -}
> -
> -int mg_asprintf(char **buf, size_t size, const char *fmt, ...) WEAK;
> -int mg_asprintf(char **buf, size_t size, const char *fmt, ...) {
> -  int ret;
> -  va_list ap;
> -  va_start(ap, fmt);
> -  ret = mg_avprintf(buf, size, fmt, ap);
> -  va_end(ap);
> -  return ret;
> -}
> -
> -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap) WEAK;
> -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap) {
> -  va_list ap_copy;
> -  int len;
> -
> -  va_copy(ap_copy, ap);
> -  len = vsnprintf(*buf, size, fmt, ap_copy);
> -  va_end(ap_copy);
> -
> -  if (len < 0) {
> -    /* eCos and Windows are not standard-compliant and return -1 when
> -     * the buffer is too small. Keep allocating larger buffers until we
> -     * succeed or out of memory. */
> -    *buf = NULL; /* LCOV_EXCL_START */
> -    while (len < 0) {
> -      MG_FREE(*buf);
> -      if (size == 0) {
> -        size = 5;
> -      }
> -      size *= 2;
> -      if ((*buf = (char *) MG_MALLOC(size)) == NULL) {
> -        len = -1;
> -        break;
> -      }
> -      va_copy(ap_copy, ap);
> -      len = vsnprintf(*buf, size - 1, fmt, ap_copy);
> -      va_end(ap_copy);
> -    }
> -
> -    /*
> -     * Microsoft version of vsnprintf() is not always null-terminated, so put
> -     * the terminator manually
> -     */
> -    (*buf)[len] = 0;
> -    /* LCOV_EXCL_STOP */
> -  } else if (len >= (int) size) {
> -    /* Standard-compliant code path. Allocate a buffer that is large enough. */
> -    if ((*buf = (char *) MG_MALLOC(len + 1)) == NULL) {
> -      len = -1; /* LCOV_EXCL_LINE */
> -    } else {    /* LCOV_EXCL_LINE */
> -      va_copy(ap_copy, ap);
> -      len = vsnprintf(*buf, len + 1, fmt, ap_copy);
> -      va_end(ap_copy);
> -    }
> -  }
> -
> -  return len;
> -}
> -
> -const char *mg_next_comma_list_entry(const char *, struct mg_str *,
> -                                     struct mg_str *) WEAK;
> -const char *mg_next_comma_list_entry(const char *list, struct mg_str *val,
> -                                     struct mg_str *eq_val) {
> -  struct mg_str ret = mg_next_comma_list_entry_n(mg_mk_str(list), val, eq_val);
> -  return ret.p;
> -}
> -
> -struct mg_str mg_next_comma_list_entry_n(struct mg_str list, struct mg_str *val,
> -                                         struct mg_str *eq_val) WEAK;
> -struct mg_str mg_next_comma_list_entry_n(struct mg_str list, struct mg_str *val,
> -                                         struct mg_str *eq_val) {
> -  if (list.len == 0) {
> -    /* End of the list */
> -    list = mg_mk_str(NULL);
> -  } else {
> -    const char *chr = NULL;
> -    *val = list;
> -
> -    if ((chr = mg_strchr(*val, ',')) != NULL) {
> -      /* Comma found. Store length and shift the list ptr */
> -      val->len = chr - val->p;
> -      chr++;
> -      list.len -= (chr - list.p);
> -      list.p = chr;
> -    } else {
> -      /* This value is the last one */
> -      list = mg_mk_str_n(list.p + list.len, 0);
> -    }
> -
> -    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->p = (const char *) memchr(val->p, '=', val->len);
> -      if (eq_val->p != NULL) {
> -        eq_val->p++; /* Skip over '=' character */
> -        eq_val->len = val->p + val->len - eq_val->p;
> -        val->len = (eq_val->p - val->p) - 1;
> -      }
> -    }
> -  }
> -
> -  return list;
> -}
> -
> -size_t mg_match_prefix_n(const struct mg_str, const struct mg_str) WEAK;
> -size_t mg_match_prefix_n(const struct mg_str pattern, const struct mg_str str) {
> -  const char *or_str;
> -  size_t res = 0, len = 0, i = 0, j = 0;
> -
> -  if ((or_str = (const char *) memchr(pattern.p, '|', pattern.len)) != NULL ||
> -      (or_str = (const char *) memchr(pattern.p, ',', pattern.len)) != NULL) {
> -    struct mg_str pstr = {pattern.p, (size_t)(or_str - pattern.p)};
> -    res = mg_match_prefix_n(pstr, str);
> -    if (res > 0) return res;
> -    pstr.p = or_str + 1;
> -    pstr.len = (pattern.p + pattern.len) - (or_str + 1);
> -    return mg_match_prefix_n(pstr, str);
> -  }
> -
> -  for (; i < pattern.len && j < str.len; i++, j++) {
> -    if (pattern.p[i] == '?') {
> -      continue;
> -    } else if (pattern.p[i] == '*') {
> -      i++;
> -      if (i < pattern.len && pattern.p[i] == '*') {
> -        i++;
> -        len = str.len - j;
> -      } else {
> -        len = 0;
> -        while (j + len < str.len && str.p[j + len] != '/') len++;
> -      }
> -      if (i == pattern.len || (pattern.p[i] == '$' && i == pattern.len - 1))
> -        return j + len;
> -      do {
> -        const struct mg_str pstr = {pattern.p + i, pattern.len - i};
> -        const struct mg_str sstr = {str.p + j + len, str.len - j - len};
> -        res = mg_match_prefix_n(pstr, sstr);
> -      } while (res == 0 && len != 0 && len-- > 0);
> -      return res == 0 ? 0 : j + res + len;
> -    } else if (str_util_lowercase(&pattern.p[i]) !=
> -               str_util_lowercase(&str.p[j])) {
> -      break;
> -    }
> -  }
> -  if (i < pattern.len && pattern.p[i] == '$') {
> -    return j == str.len ? str.len : 0;
> -  }
> -  return i == pattern.len ? j : 0;
> -}
> -
> -size_t mg_match_prefix(const char *, int, const char *) WEAK;
> -size_t mg_match_prefix(const char *pattern, int pattern_len, const char *str) {
> -  const struct mg_str pstr = {pattern, (size_t) pattern_len};
> -  struct mg_str s = {str, 0};
> -  if (str != NULL) s.len = strlen(str);
> -  return mg_match_prefix_n(pstr, s);
> -}
> -
> -#endif /* EXCLUDE_COMMON */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net.c"
> -#endif
> -
> -/* Amalgamated: #include "common/cs_time.h" */
> -/* Amalgamated: #include "mg_dns.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_resolv.h" */
> -/* Amalgamated: #include "mg_util.h" */
> -
> -#define MG_MAX_HOST_LEN 200
> -
> -#ifndef MG_TCP_IO_SIZE
> -#define MG_TCP_IO_SIZE 1460
> -#endif
> -#ifndef MG_UDP_IO_SIZE
> -#define MG_UDP_IO_SIZE 1460
> -#endif
> -
> -#define MG_COPY_COMMON_CONNECTION_OPTIONS(dst, src) \
> -  memcpy(dst, src, sizeof(*dst));
> -
> -/* Which flags can be pre-set by the user at connection creation time. */
> -#define _MG_ALLOWED_CONNECT_FLAGS_MASK                                   \
> -  (MG_F_USER_1 | MG_F_USER_2 | MG_F_USER_3 | MG_F_USER_4 | MG_F_USER_5 | \
> -   MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_ENABLE_BROADCAST)
> -/* Which flags should be modifiable by user's callbacks. */
> -#define _MG_CALLBACK_MODIFIABLE_FLAGS_MASK                               \
> -  (MG_F_USER_1 | MG_F_USER_2 | MG_F_USER_3 | MG_F_USER_4 | MG_F_USER_5 | \
> -   MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_SEND_AND_CLOSE |        \
> -   MG_F_CLOSE_IMMEDIATELY | MG_F_IS_WEBSOCKET | MG_F_DELETE_CHUNK)
> -
> -#ifndef intptr_t
> -#define intptr_t long
> -#endif
> -
> -MG_INTERNAL void mg_add_conn(struct mg_mgr *mgr, struct mg_connection *c) {
> -  DBG(("%p %p", mgr, c));
> -  c->mgr = mgr;
> -  c->next = mgr->active_connections;
> -  mgr->active_connections = c;
> -  c->prev = NULL;
> -  if (c->next != NULL) c->next->prev = c;
> -  if (c->sock != INVALID_SOCKET) {
> -    c->iface->vtable->add_conn(c);
> -  }
> -}
> -
> -MG_INTERNAL void mg_remove_conn(struct mg_connection *conn) {
> -  if (conn->prev == NULL) conn->mgr->active_connections = conn->next;
> -  if (conn->prev) conn->prev->next = conn->next;
> -  if (conn->next) conn->next->prev = conn->prev;
> -  conn->prev = conn->next = NULL;
> -  conn->iface->vtable->remove_conn(conn);
> -}
> -
> -MG_INTERNAL void mg_call(struct mg_connection *nc,
> -                         mg_event_handler_t ev_handler, void *user_data, int ev,
> -                         void *ev_data) {
> -  if (ev_handler == NULL) {
> -    /*
> -     * If protocol handler is specified, call it. Otherwise, call user-specified
> -     * event handler.
> -     */
> -    ev_handler = nc->proto_handler ? nc->proto_handler : nc->handler;
> -  }
> -  if (ev != MG_EV_POLL) {
> -    DBG(("%p %s ev=%d ev_data=%p flags=0x%lx rmbl=%d smbl=%d", nc,
> -         ev_handler == nc->handler ? "user" : "proto", ev, ev_data, nc->flags,
> -         (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
> -  }
> -
> -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
> -  if (nc->mgr->hexdump_file != NULL && ev != MG_EV_POLL && ev != MG_EV_RECV &&
> -      ev != MG_EV_SEND /* handled separately */) {
> -    mg_hexdump_connection(nc, nc->mgr->hexdump_file, NULL, 0, ev);
> -  }
> -#endif
> -  if (ev_handler != NULL) {
> -    unsigned long flags_before = nc->flags;
> -    ev_handler(nc, ev, ev_data MG_UD_ARG(user_data));
> -    /* Prevent user handler from fiddling with system flags. */
> -    if (ev_handler == nc->handler && nc->flags != flags_before) {
> -      nc->flags = (flags_before & ~_MG_CALLBACK_MODIFIABLE_FLAGS_MASK) |
> -                  (nc->flags & _MG_CALLBACK_MODIFIABLE_FLAGS_MASK);
> -    }
> -  }
> -  if (ev != MG_EV_POLL) nc->mgr->num_calls++;
> -  if (ev != MG_EV_POLL) {
> -    DBG(("%p after %s flags=0x%lx rmbl=%d smbl=%d", nc,
> -         ev_handler == nc->handler ? "user" : "proto", nc->flags,
> -         (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
> -  }
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -  (void) user_data;
> -#endif
> -}
> -
> -MG_INTERNAL void mg_timer(struct mg_connection *c, double now) {
> -  if (c->ev_timer_time > 0 && now >= c->ev_timer_time) {
> -    double old_value = c->ev_timer_time;
> -    c->ev_timer_time = 0;
> -    mg_call(c, NULL, c->user_data, MG_EV_TIMER, &old_value);
> -  }
> -}
> -
> -MG_INTERNAL size_t recv_avail_size(struct mg_connection *conn, size_t max) {
> -  size_t avail;
> -  if (conn->recv_mbuf_limit < conn->recv_mbuf.len) return 0;
> -  avail = conn->recv_mbuf_limit - conn->recv_mbuf.len;
> -  return avail > max ? max : avail;
> -}
> -
> -static int mg_do_recv(struct mg_connection *nc);
> -
> -int mg_if_poll(struct mg_connection *nc, double now) {
> -  if (nc->flags & MG_F_CLOSE_IMMEDIATELY) {
> -    mg_close_conn(nc);
> -    return 0;
> -  } else if (nc->flags & MG_F_SEND_AND_CLOSE) {
> -    if (nc->send_mbuf.len == 0) {
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      mg_close_conn(nc);
> -      return 0;
> -    }
> -  } else if (nc->flags & MG_F_RECV_AND_CLOSE) {
> -    mg_close_conn(nc);
> -    return 0;
> -  }
> -#if MG_ENABLE_SSL
> -  if ((nc->flags & (MG_F_SSL | MG_F_LISTENING | MG_F_CONNECTING)) == MG_F_SSL) {
> -    /* SSL library may have data to be delivered to the app in its buffers,
> -     * drain them. */
> -    int recved = 0;
> -    do {
> -      if (nc->flags & (MG_F_WANT_READ | MG_F_WANT_WRITE)) break;
> -      if (recv_avail_size(nc, MG_TCP_IO_SIZE) <= 0) break;
> -      recved = mg_do_recv(nc);
> -    } while (recved > 0);
> -  }
> -#endif /* MG_ENABLE_SSL */
> -  mg_timer(nc, now);
> -  {
> -    time_t now_t = (time_t) now;
> -    mg_call(nc, NULL, nc->user_data, MG_EV_POLL, &now_t);
> -  }
> -  return 1;
> -}
> -
> -static void mg_destroy_conn(struct mg_connection *conn, int destroy_if) {
> -  if (conn->sock != INVALID_SOCKET) { /* Don't print timer-only conns */
> -    LOG(LL_DEBUG, ("%p 0x%lx %d", conn, conn->flags, destroy_if));
> -  }
> -  if (destroy_if) conn->iface->vtable->destroy_conn(conn);
> -  if (conn->proto_data != NULL && conn->proto_data_destructor != NULL) {
> -    conn->proto_data_destructor(conn->proto_data);
> -  }
> -#if MG_ENABLE_SSL
> -  mg_ssl_if_conn_free(conn);
> -#endif
> -  mbuf_free(&conn->recv_mbuf);
> -  mbuf_free(&conn->send_mbuf);
> -
> -  memset(conn, 0, sizeof(*conn));
> -  MG_FREE(conn);
> -}
> -
> -void mg_close_conn(struct mg_connection *conn) {
> -  /* See if there's any remaining data to deliver. Skip if user completely
> -   * throttled the connection there will be no progress anyway. */
> -  if (conn->sock != INVALID_SOCKET && mg_do_recv(conn) == -2) {
> -    /* Receive is throttled, wait. */
> -    conn->flags |= MG_F_RECV_AND_CLOSE;
> -    return;
> -  }
> -#if MG_ENABLE_SSL
> -  if (conn->flags & MG_F_SSL_HANDSHAKE_DONE) {
> -    mg_ssl_if_conn_close_notify(conn);
> -  }
> -#endif
> -  /*
> -   * Clearly mark the connection as going away (if not already).
> -   * Some net_if impls (LwIP) need this for cleanly handling half-dead conns.
> -   */
> -  conn->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  mg_remove_conn(conn);
> -  conn->iface->vtable->destroy_conn(conn);
> -  mg_call(conn, NULL, conn->user_data, MG_EV_CLOSE, NULL);
> -  mg_destroy_conn(conn, 0 /* destroy_if */);
> -}
> -
> -void mg_mgr_init(struct mg_mgr *m, void *user_data) {
> -  struct mg_mgr_init_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  mg_mgr_init_opt(m, user_data, opts);
> -}
> -
> -void mg_mgr_init_opt(struct mg_mgr *m, void *user_data,
> -                     struct mg_mgr_init_opts opts) {
> -  memset(m, 0, sizeof(*m));
> -#if MG_ENABLE_BROADCAST
> -  m->ctl[0] = m->ctl[1] = INVALID_SOCKET;
> -#endif
> -  m->user_data = user_data;
> -
> -#ifdef _WIN32
> -  {
> -    WSADATA data;
> -    WSAStartup(MAKEWORD(2, 2), &data);
> -  }
> -#elif defined(__unix__)
> -  /* Ignore SIGPIPE signal, so if client cancels the request, it
> -   * won't kill the whole process. */
> -  signal(SIGPIPE, SIG_IGN);
> -#endif
> -
> -  {
> -    int i;
> -    if (opts.num_ifaces == 0) {
> -      opts.num_ifaces = mg_num_ifaces;
> -      opts.ifaces = mg_ifaces;
> -    }
> -    if (opts.main_iface != NULL) {
> -      opts.ifaces[MG_MAIN_IFACE] = opts.main_iface;
> -    }
> -    m->num_ifaces = opts.num_ifaces;
> -    m->ifaces =
> -        (struct mg_iface **) MG_MALLOC(sizeof(*m->ifaces) * opts.num_ifaces);
> -    for (i = 0; i < opts.num_ifaces; i++) {
> -      m->ifaces[i] = mg_if_create_iface(opts.ifaces[i], m);
> -      m->ifaces[i]->vtable->init(m->ifaces[i]);
> -    }
> -  }
> -  if (opts.nameserver != NULL) {
> -    m->nameserver = strdup(opts.nameserver);
> -  }
> -  DBG(("=================================="));
> -  DBG(("init mgr=%p", m));
> -#if MG_ENABLE_SSL
> -  {
> -    static int init_done;
> -    if (!init_done) {
> -      mg_ssl_if_init();
> -      init_done++;
> -    }
> -  }
> -#endif
> -}
> -
> -void mg_mgr_free(struct mg_mgr *m) {
> -  struct mg_connection *conn, *tmp_conn;
> -
> -  DBG(("%p", m));
> -  if (m == NULL) return;
> -  /* Do one last poll, see https://github.com/cesanta/mongoose/issues/286 */
> -  mg_mgr_poll(m, 0);
> -
> -#if MG_ENABLE_BROADCAST
> -  if (m->ctl[0] != INVALID_SOCKET) closesocket(m->ctl[0]);
> -  if (m->ctl[1] != INVALID_SOCKET) closesocket(m->ctl[1]);
> -  m->ctl[0] = m->ctl[1] = INVALID_SOCKET;
> -#endif
> -
> -  for (conn = m->active_connections; conn != NULL; conn = tmp_conn) {
> -    tmp_conn = conn->next;
> -    conn->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    mg_close_conn(conn);
> -  }
> -
> -  {
> -    int i;
> -    for (i = 0; i < m->num_ifaces; i++) {
> -      m->ifaces[i]->vtable->free(m->ifaces[i]);
> -      MG_FREE(m->ifaces[i]);
> -    }
> -    MG_FREE(m->ifaces);
> -  }
> -
> -  MG_FREE((char *) m->nameserver);
> -}
> -
> -int mg_mgr_poll(struct mg_mgr *m, int timeout_ms) {
> -  int i, num_calls_before = m->num_calls;
> -
> -  for (i = 0; i < m->num_ifaces; i++) {
> -    m->ifaces[i]->vtable->poll(m->ifaces[i], timeout_ms);
> -  }
> -
> -  return (m->num_calls - num_calls_before);
> -}
> -
> -int mg_vprintf(struct mg_connection *nc, const char *fmt, va_list ap) {
> -  char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
> -  int len;
> -
> -  if ((len = mg_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
> -    mg_send(nc, buf, len);
> -  }
> -  if (buf != mem && buf != NULL) {
> -    MG_FREE(buf); /* LCOV_EXCL_LINE */
> -  }               /* LCOV_EXCL_LINE */
> -
> -  return len;
> -}
> -
> -int mg_printf(struct mg_connection *conn, const char *fmt, ...) {
> -  int len;
> -  va_list ap;
> -  va_start(ap, fmt);
> -  len = mg_vprintf(conn, fmt, ap);
> -  va_end(ap);
> -  return len;
> -}
> -
> -#if MG_ENABLE_SYNC_RESOLVER
> -/* TODO(lsm): use non-blocking resolver */
> -static int mg_resolve2(const char *host, struct in_addr *ina) {
> -#if MG_ENABLE_GETADDRINFO
> -  int rv = 0;
> -  struct addrinfo hints, *servinfo, *p;
> -  struct sockaddr_in *h = NULL;
> -  memset(&hints, 0, sizeof hints);
> -  hints.ai_family = AF_INET;
> -  hints.ai_socktype = SOCK_STREAM;
> -  if ((rv = getaddrinfo(host, NULL, NULL, &servinfo)) != 0) {
> -    DBG(("getaddrinfo(%s) failed: %s", host, strerror(mg_get_errno())));
> -    return 0;
> -  }
> -  for (p = servinfo; p != NULL; p = p->ai_next) {
> -    memcpy(&h, &p->ai_addr, sizeof(h));
> -    memcpy(ina, &h->sin_addr, sizeof(*ina));
> -  }
> -  freeaddrinfo(servinfo);
> -  return 1;
> -#else
> -  struct hostent *he;
> -  if ((he = gethostbyname(host)) == NULL) {
> -    DBG(("gethostbyname(%s) failed: %s", host, strerror(mg_get_errno())));
> -  } else {
> -    memcpy(ina, he->h_addr_list[0], sizeof(*ina));
> -    return 1;
> -  }
> -  return 0;
> -#endif /* MG_ENABLE_GETADDRINFO */
> -}
> -
> -int mg_resolve(const char *host, char *buf, size_t n) {
> -  struct in_addr ad;
> -  return mg_resolve2(host, &ad) ? snprintf(buf, n, "%s", inet_ntoa(ad)) : 0;
> -}
> -#endif /* MG_ENABLE_SYNC_RESOLVER */
> -
> -MG_INTERNAL struct mg_connection *mg_create_connection_base(
> -    struct mg_mgr *mgr, mg_event_handler_t callback,
> -    struct mg_add_sock_opts opts) {
> -  struct mg_connection *conn;
> -
> -  if ((conn = (struct mg_connection *) MG_CALLOC(1, sizeof(*conn))) != NULL) {
> -    conn->sock = INVALID_SOCKET;
> -    conn->handler = callback;
> -    conn->mgr = mgr;
> -    conn->last_io_time = (time_t) mg_time();
> -    conn->iface =
> -        (opts.iface != NULL ? opts.iface : mgr->ifaces[MG_MAIN_IFACE]);
> -    conn->flags = opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK;
> -    conn->user_data = opts.user_data;
> -    /*
> -     * SIZE_MAX is defined as a long long constant in
> -     * system headers on some platforms and so it
> -     * doesn't compile with pedantic ansi flags.
> -     */
> -    conn->recv_mbuf_limit = ~0;
> -  } else {
> -    MG_SET_PTRPTR(opts.error_string, "failed to create connection");
> -  }
> -
> -  return conn;
> -}
> -
> -MG_INTERNAL struct mg_connection *mg_create_connection(
> -    struct mg_mgr *mgr, mg_event_handler_t callback,
> -    struct mg_add_sock_opts opts) {
> -  struct mg_connection *conn = mg_create_connection_base(mgr, callback, opts);
> -
> -  if (conn != NULL && !conn->iface->vtable->create_conn(conn)) {
> -    MG_FREE(conn);
> -    conn = NULL;
> -  }
> -  if (conn == NULL) {
> -    MG_SET_PTRPTR(opts.error_string, "failed to init connection");
> -  }
> -
> -  return conn;
> -}
> -
> -/*
> - * Address format: [PROTO://][HOST]:PORT
> - *
> - * HOST could be IPv4/IPv6 address or a host name.
> - * `host` is a destination buffer to hold parsed HOST part. Should be at least
> - * MG_MAX_HOST_LEN bytes long.
> - * `proto` is a returned socket type, either SOCK_STREAM or SOCK_DGRAM
> - *
> - * Return:
> - *   -1   on parse error
> - *    0   if HOST needs DNS lookup
> - *   >0   length of the address string
> - */
> -MG_INTERNAL int mg_parse_address(const char *str, union socket_address *sa,
> -                                 int *proto, char *host, size_t host_len) {
> -  unsigned int a, b, c, d, port = 0;
> -  int ch, len = 0;
> -#if MG_ENABLE_IPV6
> -  char buf[100];
> -#endif
> -
> -  /*
> -   * MacOS needs that. If we do not zero it, subsequent bind() will fail.
> -   * Also, all-zeroes in the socket address means binding to all addresses
> -   * for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT).
> -   */
> -  memset(sa, 0, sizeof(*sa));
> -  sa->sin.sin_family = AF_INET;
> -
> -  *proto = SOCK_STREAM;
> -
> -  if (strncmp(str, "udp://", 6) == 0) {
> -    str += 6;
> -    *proto = SOCK_DGRAM;
> -  } else if (strncmp(str, "tcp://", 6) == 0) {
> -    str += 6;
> -  }
> -
> -  if (sscanf(str, "%u.%u.%u.%u:%u%n", &a, &b, &c, &d, &port, &len) == 5) {
> -    /* Bind to a specific IPv4 address, e.g. 192.168.1.5:8080 */
> -    sa->sin.sin_addr.s_addr =
> -        htonl(((uint32_t) a << 24) | ((uint32_t) b << 16) | c << 8 | d);
> -    sa->sin.sin_port = htons((uint16_t) port);
> -#if MG_ENABLE_IPV6
> -  } else if (sscanf(str, "[%99[^]]]:%u%n", buf, &port, &len) == 2 &&
> -             inet_pton(AF_INET6, buf, &sa->sin6.sin6_addr)) {
> -    /* IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080 */
> -    sa->sin6.sin6_family = AF_INET6;
> -    sa->sin.sin_port = htons((uint16_t) port);
> -#endif
> -#if MG_ENABLE_ASYNC_RESOLVER
> -  } else if (strlen(str) < host_len &&
> -             sscanf(str, "%[^ :]:%u%n", host, &port, &len) == 2) {
> -    sa->sin.sin_port = htons((uint16_t) port);
> -    if (mg_resolve_from_hosts_file(host, sa) != 0) {
> -      /*
> -       * if resolving from hosts file failed and the host
> -       * we are trying to resolve is `localhost` - we should
> -       * try to resolve it using `gethostbyname` and do not try
> -       * to resolve it via DNS server if gethostbyname has failed too
> -       */
> -      if (mg_ncasecmp(host, "localhost", 9) != 0) {
> -        return 0;
> -      }
> -
> -#if MG_ENABLE_SYNC_RESOLVER
> -      if (!mg_resolve2(host, &sa->sin.sin_addr)) {
> -        return -1;
> -      }
> -#else
> -      return -1;
> -#endif
> -    }
> -#endif
> -  } else if (sscanf(str, ":%u%n", &port, &len) == 1 ||
> -             sscanf(str, "%u%n", &port, &len) == 1) {
> -    /* If only port is specified, bind to IPv4, INADDR_ANY */
> -    sa->sin.sin_port = htons((uint16_t) port);
> -  } else {
> -    return -1;
> -  }
> -
> -  /* Required for MG_ENABLE_ASYNC_RESOLVER=0 */
> -  (void) host;
> -  (void) host_len;
> -
> -  ch = str[len]; /* Character that follows the address */
> -  return port < 0xffffUL && (ch == '\0' || ch == ',' || isspace(ch)) ? len : -1;
> -}
> -
> -#if MG_ENABLE_SSL
> -MG_INTERNAL void mg_ssl_handshake(struct mg_connection *nc) {
> -  int err = 0;
> -  int server_side = (nc->listener != NULL);
> -  enum mg_ssl_if_result res;
> -  if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) return;
> -  res = mg_ssl_if_handshake(nc);
> -
> -  if (res == MG_SSL_OK) {
> -    nc->flags |= MG_F_SSL_HANDSHAKE_DONE;
> -    nc->flags &= ~(MG_F_WANT_READ | MG_F_WANT_WRITE);
> -    if (server_side) {
> -      mg_call(nc, NULL, nc->user_data, MG_EV_ACCEPT, &nc->sa);
> -    } else {
> -      mg_call(nc, NULL, nc->user_data, MG_EV_CONNECT, &err);
> -    }
> -  } else if (res == MG_SSL_WANT_READ) {
> -    nc->flags |= MG_F_WANT_READ;
> -  } else if (res == MG_SSL_WANT_WRITE) {
> -    nc->flags |= MG_F_WANT_WRITE;
> -  } else {
> -    if (!server_side) {
> -      err = res;
> -      mg_call(nc, NULL, nc->user_data, MG_EV_CONNECT, &err);
> -    }
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  }
> -}
> -#endif /* MG_ENABLE_SSL */
> -
> -struct mg_connection *mg_if_accept_new_conn(struct mg_connection *lc) {
> -  struct mg_add_sock_opts opts;
> -  struct mg_connection *nc;
> -  memset(&opts, 0, sizeof(opts));
> -  nc = mg_create_connection(lc->mgr, lc->handler, opts);
> -  if (nc == NULL) return NULL;
> -  nc->listener = lc;
> -  nc->proto_handler = lc->proto_handler;
> -  nc->user_data = lc->user_data;
> -  nc->recv_mbuf_limit = lc->recv_mbuf_limit;
> -  nc->iface = lc->iface;
> -  if (lc->flags & MG_F_SSL) nc->flags |= MG_F_SSL;
> -  mg_add_conn(nc->mgr, nc);
> -  LOG(LL_DEBUG, ("%p %p %d %#x", lc, nc, (int) nc->sock, (int) nc->flags));
> -  return nc;
> -}
> -
> -void mg_if_accept_tcp_cb(struct mg_connection *nc, union socket_address *sa,
> -                         size_t sa_len) {
> -  LOG(LL_DEBUG, ("%p %s://%s:%hu", nc, (nc->flags & MG_F_UDP ? "udp" : "tcp"),
> -                 inet_ntoa(sa->sin.sin_addr), ntohs(sa->sin.sin_port)));
> -  nc->sa = *sa;
> -#if MG_ENABLE_SSL
> -  if (nc->listener->flags & MG_F_SSL) {
> -    nc->flags |= MG_F_SSL;
> -    if (mg_ssl_if_conn_accept(nc, nc->listener) == MG_SSL_OK) {
> -      mg_ssl_handshake(nc);
> -    } else {
> -      mg_close_conn(nc);
> -    }
> -  } else
> -#endif
> -  {
> -    mg_call(nc, NULL, nc->user_data, MG_EV_ACCEPT, &nc->sa);
> -  }
> -  (void) sa_len;
> -}
> -
> -void mg_send(struct mg_connection *nc, const void *buf, int len) {
> -  nc->last_io_time = (time_t) mg_time();
> -  mbuf_append(&nc->send_mbuf, buf, len);
> -}
> -
> -static int mg_recv_tcp(struct mg_connection *nc, char *buf, size_t len);
> -static int mg_recv_udp(struct mg_connection *nc, char *buf, size_t len);
> -
> -static int mg_do_recv(struct mg_connection *nc) {
> -  int res = 0;
> -  char *buf = NULL;
> -  size_t len = (nc->flags & MG_F_UDP ? MG_UDP_IO_SIZE : MG_TCP_IO_SIZE);
> -  if ((nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_CONNECTING)) ||
> -      ((nc->flags & MG_F_LISTENING) && !(nc->flags & MG_F_UDP))) {
> -    return -1;
> -  }
> -  do {
> -    len = recv_avail_size(nc, len);
> -    if (len == 0) {
> -      res = -2;
> -      break;
> -    }
> -    if (nc->recv_mbuf.size < nc->recv_mbuf.len + len) {
> -      mbuf_resize(&nc->recv_mbuf, nc->recv_mbuf.len + len);
> -    }
> -    buf = nc->recv_mbuf.buf + nc->recv_mbuf.len;
> -    len = nc->recv_mbuf.size - nc->recv_mbuf.len;
> -    if (nc->flags & MG_F_UDP) {
> -      res = mg_recv_udp(nc, buf, len);
> -    } else {
> -      res = mg_recv_tcp(nc, buf, len);
> -    }
> -  } while (res > 0 && !(nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_UDP)));
> -  return res;
> -}
> -
> -void mg_if_can_recv_cb(struct mg_connection *nc) {
> -  mg_do_recv(nc);
> -}
> -
> -static int mg_recv_tcp(struct mg_connection *nc, char *buf, size_t len) {
> -  int n = 0;
> -#if MG_ENABLE_SSL
> -  if (nc->flags & MG_F_SSL) {
> -    if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) {
> -      n = mg_ssl_if_read(nc, buf, len);
> -      DBG(("%p <- %d bytes (SSL)", nc, n));
> -      if (n < 0) {
> -        if (n == MG_SSL_WANT_READ) {
> -          nc->flags |= MG_F_WANT_READ;
> -          n = 0;
> -        } else {
> -          nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        }
> -      } else if (n > 0) {
> -        nc->flags &= ~MG_F_WANT_READ;
> -      }
> -    } else {
> -      mg_ssl_handshake(nc);
> -    }
> -  } else
> -#endif
> -  {
> -    n = nc->iface->vtable->tcp_recv(nc, buf, len);
> -    DBG(("%p <- %d bytes", nc, n));
> -  }
> -  if (n > 0) {
> -    nc->recv_mbuf.len += n;
> -    nc->last_io_time = (time_t) mg_time();
> -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
> -    if (nc->mgr && nc->mgr->hexdump_file != NULL) {
> -      mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_RECV);
> -    }
> -#endif
> -    mbuf_trim(&nc->recv_mbuf);
> -    mg_call(nc, NULL, nc->user_data, MG_EV_RECV, &n);
> -  } else if (n < 0) {
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  }
> -  mbuf_trim(&nc->recv_mbuf);
> -  return n;
> -}
> -
> -static int mg_recv_udp(struct mg_connection *nc, char *buf, size_t len) {
> -  int n = 0;
> -  struct mg_connection *lc = nc;
> -  union socket_address sa;
> -  size_t sa_len = sizeof(sa);
> -  n = nc->iface->vtable->udp_recv(lc, buf, len, &sa, &sa_len);
> -  if (n < 0) {
> -    lc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    goto out;
> -  }
> -  if (nc->flags & MG_F_LISTENING) {
> -    /*
> -     * Do we have an existing connection for this source?
> -     * This is very inefficient for long connection lists.
> -     */
> -    lc = nc;
> -    for (nc = mg_next(lc->mgr, NULL); nc != NULL; nc = mg_next(lc->mgr, nc)) {
> -      if (memcmp(&nc->sa.sa, &sa.sa, sa_len) == 0 && nc->listener == lc) {
> -        break;
> -      }
> -    }
> -    if (nc == NULL) {
> -      struct mg_add_sock_opts opts;
> -      memset(&opts, 0, sizeof(opts));
> -      /* Create fake connection w/out sock initialization */
> -      nc = mg_create_connection_base(lc->mgr, lc->handler, opts);
> -      if (nc != NULL) {
> -        nc->sock = lc->sock;
> -        nc->listener = lc;
> -        nc->sa = sa;
> -        nc->proto_handler = lc->proto_handler;
> -        nc->user_data = lc->user_data;
> -        nc->recv_mbuf_limit = lc->recv_mbuf_limit;
> -        nc->flags = MG_F_UDP;
> -        /*
> -         * Long-lived UDP "connections" i.e. interactions that involve more
> -         * than one request and response are rare, most are transactional:
> -         * response is sent and the "connection" is closed. Or - should be.
> -         * But users (including ourselves) tend to forget about that part,
> -         * because UDP is connectionless and one does not think about
> -         * processing a UDP request as handling a connection that needs to be
> -         * closed. Thus, we begin with SEND_AND_CLOSE flag set, which should
> -         * be a reasonable default for most use cases, but it is possible to
> -         * turn it off the connection should be kept alive after processing.
> -         */
> -        nc->flags |= MG_F_SEND_AND_CLOSE;
> -        mg_add_conn(lc->mgr, nc);
> -        mg_call(nc, NULL, nc->user_data, MG_EV_ACCEPT, &nc->sa);
> -      }
> -    }
> -  }
> -  if (nc != NULL) {
> -    DBG(("%p <- %d bytes from %s:%d", nc, n, inet_ntoa(nc->sa.sin.sin_addr),
> -         ntohs(nc->sa.sin.sin_port)));
> -    if (nc == lc) {
> -      nc->recv_mbuf.len += n;
> -    } else {
> -      mbuf_append(&nc->recv_mbuf, buf, n);
> -    }
> -    mbuf_trim(&lc->recv_mbuf);
> -    lc->last_io_time = nc->last_io_time = (time_t) mg_time();
> -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
> -    if (nc->mgr && nc->mgr->hexdump_file != NULL) {
> -      mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_RECV);
> -    }
> -#endif
> -    if (n != 0) {
> -      mg_call(nc, NULL, nc->user_data, MG_EV_RECV, &n);
> -    }
> -  }
> -
> -out:
> -  mbuf_free(&lc->recv_mbuf);
> -  return n;
> -}
> -
> -void mg_if_can_send_cb(struct mg_connection *nc) {
> -  int n = 0;
> -  const char *buf = nc->send_mbuf.buf;
> -  size_t len = nc->send_mbuf.len;
> -
> -  if (nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_CONNECTING)) {
> -    return;
> -  }
> -  if (!(nc->flags & MG_F_UDP)) {
> -    if (nc->flags & MG_F_LISTENING) return;
> -    if (len > MG_TCP_IO_SIZE) len = MG_TCP_IO_SIZE;
> -  }
> -#if MG_ENABLE_SSL
> -  if (nc->flags & MG_F_SSL) {
> -    if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) {
> -      if (len > 0) {
> -        n = mg_ssl_if_write(nc, buf, len);
> -        DBG(("%p -> %d bytes (SSL)", nc, n));
> -      }
> -      if (n < 0) {
> -        if (n == MG_SSL_WANT_WRITE) {
> -          nc->flags |= MG_F_WANT_WRITE;
> -          n = 0;
> -        } else {
> -          nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        }
> -      } else {
> -        nc->flags &= ~MG_F_WANT_WRITE;
> -      }
> -    } else {
> -      mg_ssl_handshake(nc);
> -    }
> -  } else
> -#endif
> -      if (len > 0) {
> -    if (nc->flags & MG_F_UDP) {
> -      n = nc->iface->vtable->udp_send(nc, buf, len);
> -    } else {
> -      n = nc->iface->vtable->tcp_send(nc, buf, len);
> -    }
> -    DBG(("%p -> %d bytes", nc, n));
> -  }
> -
> -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
> -  if (n > 0 && nc->mgr && nc->mgr->hexdump_file != NULL) {
> -    mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_SEND);
> -  }
> -#endif
> -  if (n < 0) {
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  } else if (n > 0) {
> -    nc->last_io_time = (time_t) mg_time();
> -    mbuf_remove(&nc->send_mbuf, n);
> -    mbuf_trim(&nc->send_mbuf);
> -  }
> -  if (n != 0) mg_call(nc, NULL, nc->user_data, MG_EV_SEND, &n);
> -}
> -
> -/*
> - * Schedules an async connect for a resolved address and proto.
> - * Called from two places: `mg_connect_opt()` and from async resolver.
> - * When called from the async resolver, it must trigger `MG_EV_CONNECT` event
> - * with a failure flag to indicate connection failure.
> - */
> -MG_INTERNAL struct mg_connection *mg_do_connect(struct mg_connection *nc,
> -                                                int proto,
> -                                                union socket_address *sa) {
> -  LOG(LL_DEBUG, ("%p %s://%s:%hu", nc, proto == SOCK_DGRAM ? "udp" : "tcp",
> -                 inet_ntoa(sa->sin.sin_addr), ntohs(sa->sin.sin_port)));
> -
> -  nc->flags |= MG_F_CONNECTING;
> -  if (proto == SOCK_DGRAM) {
> -    nc->iface->vtable->connect_udp(nc);
> -  } else {
> -    nc->iface->vtable->connect_tcp(nc, sa);
> -  }
> -  mg_add_conn(nc->mgr, nc);
> -  return nc;
> -}
> -
> -void mg_if_connect_cb(struct mg_connection *nc, int err) {
> -  LOG(LL_DEBUG,
> -      ("%p %s://%s:%hu -> %d", nc, (nc->flags & MG_F_UDP ? "udp" : "tcp"),
> -       inet_ntoa(nc->sa.sin.sin_addr), ntohs(nc->sa.sin.sin_port), err));
> -  nc->flags &= ~MG_F_CONNECTING;
> -  if (err != 0) {
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  }
> -#if MG_ENABLE_SSL
> -  if (err == 0 && (nc->flags & MG_F_SSL)) {
> -    mg_ssl_handshake(nc);
> -  } else
> -#endif
> -  {
> -    mg_call(nc, NULL, nc->user_data, MG_EV_CONNECT, &err);
> -  }
> -}
> -
> -#if MG_ENABLE_ASYNC_RESOLVER
> -/*
> - * Callback for the async resolver on mg_connect_opt() call.
> - * Main task of this function is to trigger MG_EV_CONNECT event with
> - *    either failure (and dealloc the connection)
> - *    or success (and proceed with connect()
> - */
> -static void resolve_cb(struct mg_dns_message *msg, void *data,
> -                       enum mg_resolve_err e) {
> -  struct mg_connection *nc = (struct mg_connection *) data;
> -  int i;
> -  int failure = -1;
> -
> -  nc->flags &= ~MG_F_RESOLVING;
> -  if (msg != NULL) {
> -    /*
> -     * Take the first DNS A answer and run...
> -     */
> -    for (i = 0; i < msg->num_answers; i++) {
> -      if (msg->answers[i].rtype == MG_DNS_A_RECORD) {
> -        /*
> -         * Async resolver guarantees that there is at least one answer.
> -         * TODO(lsm): handle IPv6 answers too
> -         */
> -        mg_dns_parse_record_data(msg, &msg->answers[i], &nc->sa.sin.sin_addr,
> -                                 4);
> -        mg_do_connect(nc, nc->flags & MG_F_UDP ? SOCK_DGRAM : SOCK_STREAM,
> -                      &nc->sa);
> -        return;
> -      }
> -    }
> -  }
> -
> -  if (e == MG_RESOLVE_TIMEOUT) {
> -    double now = mg_time();
> -    mg_call(nc, NULL, nc->user_data, MG_EV_TIMER, &now);
> -  }
> -
> -  /*
> -   * If we get there was no MG_DNS_A_RECORD in the answer
> -   */
> -  mg_call(nc, NULL, nc->user_data, MG_EV_CONNECT, &failure);
> -  mg_call(nc, NULL, nc->user_data, MG_EV_CLOSE, NULL);
> -  mg_destroy_conn(nc, 1 /* destroy_if */);
> -}
> -#endif
> -
> -struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *address,
> -                                 MG_CB(mg_event_handler_t callback,
> -                                       void *user_data)) {
> -  struct mg_connect_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_connect_opt(mgr, address, MG_CB(callback, user_data), opts);
> -}
> -
> -static void mg_ev_handler_empty(struct mg_connection *c, int ev,
> -                         void *ev_data MG_UD_ARG(void *user_data)) {
> -  (void) c;
> -  (void) ev;
> -  (void) ev_data;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  (void) user_data;
> -#endif
> -}
> -
> -struct mg_connection *mg_connect_opt(struct mg_mgr *mgr, const char *address,
> -                                     MG_CB(mg_event_handler_t callback,
> -                                           void *user_data),
> -                                     struct mg_connect_opts opts) {
> -  struct mg_connection *nc = NULL;
> -  int proto, rc;
> -  struct mg_add_sock_opts add_sock_opts;
> -  char host[MG_MAX_HOST_LEN];
> -
> -  MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts);
> -
> -  if (callback == NULL) callback = mg_ev_handler_empty;
> -
> -  if ((nc = mg_create_connection(mgr, callback, add_sock_opts)) == NULL) {
> -    return NULL;
> -  }
> -
> -  if ((rc = mg_parse_address(address, &nc->sa, &proto, host, sizeof(host))) <
> -      0) {
> -    /* Address is malformed */
> -    MG_SET_PTRPTR(opts.error_string, "cannot parse address");
> -    mg_destroy_conn(nc, 1 /* destroy_if */);
> -    return NULL;
> -  }
> -
> -  nc->flags |= opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK;
> -  nc->flags |= (proto == SOCK_DGRAM) ? MG_F_UDP : 0;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  nc->user_data = user_data;
> -#else
> -  nc->user_data = opts.user_data;
> -#endif
> -
> -#if MG_ENABLE_SSL
> -  LOG(LL_DEBUG,
> -      ("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"),
> -       (opts.ssl_key ? opts.ssl_key : "-"),
> -       (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-")));
> -
> -  if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL ||
> -      opts.ssl_psk_identity != NULL) {
> -    const char *err_msg = NULL;
> -    struct mg_ssl_if_conn_params params;
> -    if (nc->flags & MG_F_UDP) {
> -      MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported");
> -      mg_destroy_conn(nc, 1 /* destroy_if */);
> -      return NULL;
> -    }
> -    memset(&params, 0, sizeof(params));
> -    params.cert = opts.ssl_cert;
> -    params.key = opts.ssl_key;
> -    params.ca_cert = opts.ssl_ca_cert;
> -    params.cipher_suites = opts.ssl_cipher_suites;
> -    params.psk_identity = opts.ssl_psk_identity;
> -    params.psk_key = opts.ssl_psk_key;
> -    if (opts.ssl_ca_cert != NULL) {
> -      if (opts.ssl_server_name != NULL) {
> -        if (strcmp(opts.ssl_server_name, "*") != 0) {
> -          params.server_name = opts.ssl_server_name;
> -        }
> -      } else if (rc == 0) { /* If it's a DNS name, use host. */
> -        params.server_name = host;
> -      }
> -    }
> -    if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
> -      MG_SET_PTRPTR(opts.error_string, err_msg);
> -      mg_destroy_conn(nc, 1 /* destroy_if */);
> -      return NULL;
> -    }
> -    nc->flags |= MG_F_SSL;
> -  }
> -#endif /* MG_ENABLE_SSL */
> -
> -  if (rc == 0) {
> -#if MG_ENABLE_ASYNC_RESOLVER
> -    /*
> -     * DNS resolution is required for host.
> -     * mg_parse_address() fills port in nc->sa, which we pass to resolve_cb()
> -     */
> -    struct mg_connection *dns_conn = NULL;
> -    struct mg_resolve_async_opts o;
> -    memset(&o, 0, sizeof(o));
> -    o.dns_conn = &dns_conn;
> -    o.nameserver = opts.nameserver;
> -    if (mg_resolve_async_opt(nc->mgr, host, MG_DNS_A_RECORD, resolve_cb, nc,
> -                             o) != 0) {
> -      MG_SET_PTRPTR(opts.error_string, "cannot schedule DNS lookup");
> -      mg_destroy_conn(nc, 1 /* destroy_if */);
> -      return NULL;
> -    }
> -    nc->priv_2 = dns_conn;
> -    nc->flags |= MG_F_RESOLVING;
> -    return nc;
> -#else
> -    MG_SET_PTRPTR(opts.error_string, "Resolver is disabled");
> -    mg_destroy_conn(nc, 1 /* destroy_if */);
> -    return NULL;
> -#endif
> -  } else {
> -    /* Address is parsed and resolved to IP. proceed with connect() */
> -    return mg_do_connect(nc, proto, &nc->sa);
> -  }
> -}
> -
> -struct mg_connection *mg_bind(struct mg_mgr *srv, const char *address,
> -                              MG_CB(mg_event_handler_t event_handler,
> -                                    void *user_data)) {
> -  struct mg_bind_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_bind_opt(srv, address, MG_CB(event_handler, user_data), opts);
> -}
> -
> -struct mg_connection *mg_bind_opt(struct mg_mgr *mgr, const char *address,
> -                                  MG_CB(mg_event_handler_t callback,
> -                                        void *user_data),
> -                                  struct mg_bind_opts opts) {
> -  union socket_address sa;
> -  struct mg_connection *nc = NULL;
> -  int proto, rc;
> -  struct mg_add_sock_opts add_sock_opts;
> -  char host[MG_MAX_HOST_LEN];
> -
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  opts.user_data = user_data;
> -#endif
> -
> -  if (callback == NULL) callback = mg_ev_handler_empty;
> -
> -  MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts);
> -
> -  if (mg_parse_address(address, &sa, &proto, host, sizeof(host)) <= 0) {
> -    MG_SET_PTRPTR(opts.error_string, "cannot parse address");
> -    return NULL;
> -  }
> -
> -  nc = mg_create_connection(mgr, callback, add_sock_opts);
> -  if (nc == NULL) {
> -    return NULL;
> -  }
> -
> -  nc->sa = sa;
> -  nc->flags |= MG_F_LISTENING;
> -  if (proto == SOCK_DGRAM) nc->flags |= MG_F_UDP;
> -
> -#if MG_ENABLE_SSL
> -  DBG(("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"),
> -       (opts.ssl_key ? opts.ssl_key : "-"),
> -       (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-")));
> -
> -  if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) {
> -    const char *err_msg = NULL;
> -    struct mg_ssl_if_conn_params params;
> -    if (nc->flags & MG_F_UDP) {
> -      MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported");
> -      mg_destroy_conn(nc, 1 /* destroy_if */);
> -      return NULL;
> -    }
> -    memset(&params, 0, sizeof(params));
> -    params.cert = opts.ssl_cert;
> -    params.key = opts.ssl_key;
> -    params.ca_cert = opts.ssl_ca_cert;
> -    params.cipher_suites = opts.ssl_cipher_suites;
> -    if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
> -      MG_SET_PTRPTR(opts.error_string, err_msg);
> -      mg_destroy_conn(nc, 1 /* destroy_if */);
> -      return NULL;
> -    }
> -    nc->flags |= MG_F_SSL;
> -  }
> -#endif /* MG_ENABLE_SSL */
> -
> -  if (nc->flags & MG_F_UDP) {
> -    rc = nc->iface->vtable->listen_udp(nc, &nc->sa);
> -  } else {
> -    rc = nc->iface->vtable->listen_tcp(nc, &nc->sa);
> -  }
> -  if (rc != 0) {
> -    DBG(("Failed to open listener: %d", rc));
> -    MG_SET_PTRPTR(opts.error_string, "failed to open listener");
> -    mg_destroy_conn(nc, 1 /* destroy_if */);
> -    return NULL;
> -  }
> -  mg_add_conn(nc->mgr, nc);
> -
> -  return nc;
> -}
> -
> -struct mg_connection *mg_next(struct mg_mgr *s, struct mg_connection *conn) {
> -  return conn == NULL ? s->active_connections : conn->next;
> -}
> -
> -#if MG_ENABLE_BROADCAST
> -void mg_broadcast(struct mg_mgr *mgr, mg_event_handler_t cb, void *data,
> -                  size_t len) {
> -  struct ctl_msg ctl_msg;
> -
> -  /*
> -   * Mongoose manager has a socketpair, `struct mg_mgr::ctl`,
> -   * where `mg_broadcast()` pushes the message.
> -   * `mg_mgr_poll()` wakes up, reads a message from the socket pair, and calls
> -   * specified callback for each connection. Thus the callback function executes
> -   * in event manager thread.
> -   */
> -  if (mgr->ctl[0] != INVALID_SOCKET && data != NULL &&
> -      len < sizeof(ctl_msg.message)) {
> -    size_t dummy;
> -
> -    ctl_msg.callback = cb;
> -    memcpy(ctl_msg.message, data, len);
> -    dummy = MG_SEND_FUNC(mgr->ctl[0], (char *) &ctl_msg,
> -                         offsetof(struct ctl_msg, message) + len, 0);
> -    dummy = MG_RECV_FUNC(mgr->ctl[0], (char *) &len, 1, 0);
> -    (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
> -  }
> -}
> -#endif /* MG_ENABLE_BROADCAST */
> -
> -static int isbyte(int n) {
> -  return n >= 0 && n <= 255;
> -}
> -
> -static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) {
> -  int n, a, b, c, d, slash = 32, len = 0;
> -
> -  if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
> -       sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
> -      isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 &&
> -      slash < 33) {
> -    len = n;
> -    *net =
> -        ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) | d;
> -    *mask = slash ? 0xffffffffU << (32 - slash) : 0;
> -  }
> -
> -  return len;
> -}
> -
> -int mg_check_ip_acl(const char *acl, uint32_t remote_ip) {
> -  int allowed, flag;
> -  uint32_t net, mask;
> -  struct mg_str vec;
> -
> -  /* If any ACL is set, deny by default */
> -  allowed = (acl == NULL || *acl == '\0') ? '+' : '-';
> -
> -  while ((acl = mg_next_comma_list_entry(acl, &vec, NULL)) != NULL) {
> -    flag = vec.p[0];
> -    if ((flag != '+' && flag != '-') ||
> -        parse_net(&vec.p[1], &net, &mask) == 0) {
> -      return -1;
> -    }
> -
> -    if (net == (remote_ip & mask)) {
> -      allowed = flag;
> -    }
> -  }
> -
> -  DBG(("%08x %c", (unsigned int) remote_ip, allowed));
> -  return allowed == '+';
> -}
> -
> -/* Move data from one connection to another */
> -void mg_forward(struct mg_connection *from, struct mg_connection *to) {
> -  mg_send(to, from->recv_mbuf.buf, from->recv_mbuf.len);
> -  mbuf_remove(&from->recv_mbuf, from->recv_mbuf.len);
> -}
> -
> -double mg_set_timer(struct mg_connection *c, double timestamp) {
> -  double result = c->ev_timer_time;
> -  c->ev_timer_time = timestamp;
> -  /*
> -   * If this connection is resolving, it's not in the list of active
> -   * connections, so not processed yet. It has a DNS resolver connection
> -   * linked to it. Set up a timer for the DNS connection.
> -   */
> -  DBG(("%p %p %d -> %lu", c, c->priv_2, (c->flags & MG_F_RESOLVING ? 1 : 0),
> -       (unsigned long) timestamp));
> -  if ((c->flags & MG_F_RESOLVING) && c->priv_2 != NULL) {
> -    mg_set_timer((struct mg_connection *) c->priv_2, timestamp);
> -  }
> -  return result;
> -}
> -
> -static void mg_sock_set(struct mg_connection *nc, sock_t sock) {
> -  if (sock != INVALID_SOCKET) {
> -    nc->iface->vtable->sock_set(nc, sock);
> -  }
> -}
> -
> -static void mg_if_get_conn_addr(struct mg_connection *nc, int remote,
> -                         union socket_address *sa) {
> -  nc->iface->vtable->get_conn_addr(nc, remote, sa);
> -}
> -
> -struct mg_connection *mg_add_sock_opt(struct mg_mgr *s, sock_t sock,
> -                                      MG_CB(mg_event_handler_t callback,
> -                                            void *user_data),
> -                                      struct mg_add_sock_opts opts) {
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  opts.user_data = user_data;
> -#endif
> -
> -  struct mg_connection *nc = mg_create_connection_base(s, callback, opts);
> -  if (nc != NULL) {
> -    mg_sock_set(nc, sock);
> -    mg_add_conn(nc->mgr, nc);
> -  }
> -  return nc;
> -}
> -
> -struct mg_connection *mg_add_sock(struct mg_mgr *s, sock_t sock,
> -                                  MG_CB(mg_event_handler_t callback,
> -                                        void *user_data)) {
> -  struct mg_add_sock_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_add_sock_opt(s, sock, MG_CB(callback, user_data), opts);
> -}
> -
> -double mg_time(void) {
> -  return cs_time();
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if_socket.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_NET_IF_SOCKET_H_
> -#define CS_MONGOOSE_SRC_NET_IF_SOCKET_H_
> -
> -/* Amalgamated: #include "mg_net_if.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -#ifndef MG_ENABLE_NET_IF_SOCKET
> -#define MG_ENABLE_NET_IF_SOCKET MG_NET_IF == MG_NET_IF_SOCKET
> -#endif
> -
> -extern const struct mg_iface_vtable mg_socket_iface_vtable;
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_MONGOOSE_SRC_NET_IF_SOCKET_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if_socks.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_NET_IF_SOCKS_H_
> -#define CS_MONGOOSE_SRC_NET_IF_SOCKS_H_
> -
> -#if MG_ENABLE_SOCKS
> -/* Amalgamated: #include "mg_net_if.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -extern const struct mg_iface_vtable mg_socks_iface_vtable;
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* MG_ENABLE_SOCKS */
> -#endif /* CS_MONGOOSE_SRC_NET_IF_SOCKS_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if.c"
> -#endif
> -/* Amalgamated: #include "mg_net_if.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_net_if_socket.h" */
> -
> -extern const struct mg_iface_vtable mg_default_iface_vtable;
> -
> -const struct mg_iface_vtable *mg_ifaces[] = {
> -    &mg_default_iface_vtable,
> -};
> -
> -int mg_num_ifaces = (int) (sizeof(mg_ifaces) / sizeof(mg_ifaces[0]));
> -
> -struct mg_iface *mg_if_create_iface(const struct mg_iface_vtable *vtable,
> -                                    struct mg_mgr *mgr) {
> -  struct mg_iface *iface = (struct mg_iface *) MG_CALLOC(1, sizeof(*iface));
> -  iface->mgr = mgr;
> -  iface->data = NULL;
> -  iface->vtable = vtable;
> -  return iface;
> -}
> -
> -struct mg_iface *mg_find_iface(struct mg_mgr *mgr,
> -                               const struct mg_iface_vtable *vtable,
> -                               struct mg_iface *from) {
> -  int i = 0;
> -  if (from != NULL) {
> -    for (i = 0; i < mgr->num_ifaces; i++) {
> -      if (mgr->ifaces[i] == from) {
> -        i++;
> -        break;
> -      }
> -    }
> -  }
> -
> -  for (; i < mgr->num_ifaces; i++) {
> -    if (mgr->ifaces[i]->vtable == vtable) {
> -      return mgr->ifaces[i];
> -    }
> -  }
> -  return NULL;
> -}
> -
> -double mg_mgr_min_timer(const struct mg_mgr *mgr) {
> -  double min_timer = 0;
> -  struct mg_connection *nc;
> -  for (nc = mgr->active_connections; nc != NULL; nc = nc->next) {
> -    if (nc->ev_timer_time <= 0) continue;
> -    if (min_timer == 0 || nc->ev_timer_time < min_timer) {
> -      min_timer = nc->ev_timer_time;
> -    }
> -  }
> -  return min_timer;
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if_null.c"
> -#endif
> -
> -static void mg_null_if_connect_tcp(struct mg_connection *c,
> -                                   const union socket_address *sa) {
> -  c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  (void) sa;
> -}
> -
> -static void mg_null_if_connect_udp(struct mg_connection *c) {
> -  c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -}
> -
> -static int mg_null_if_listen_tcp(struct mg_connection *c,
> -                                 union socket_address *sa) {
> -  (void) c;
> -  (void) sa;
> -  return -1;
> -}
> -
> -static int mg_null_if_listen_udp(struct mg_connection *c,
> -                                 union socket_address *sa) {
> -  (void) c;
> -  (void) sa;
> -  return -1;
> -}
> -
> -static int mg_null_if_tcp_send(struct mg_connection *c, const void *buf,
> -                               size_t len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  return -1;
> -}
> -
> -static int mg_null_if_udp_send(struct mg_connection *c, const void *buf,
> -                               size_t len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  return -1;
> -}
> -
> -static int mg_null_if_tcp_recv(struct mg_connection *c, void *buf, size_t len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  return -1;
> -}
> -
> -static int mg_null_if_udp_recv(struct mg_connection *c, void *buf, size_t len,
> -                        union socket_address *sa, size_t *sa_len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  (void) sa;
> -  (void) sa_len;
> -  return -1;
> -}
> -
> -static int mg_null_if_create_conn(struct mg_connection *c) {
> -  (void) c;
> -  return 1;
> -}
> -
> -static void mg_null_if_destroy_conn(struct mg_connection *c) {
> -  (void) c;
> -}
> -
> -static void mg_null_if_sock_set(struct mg_connection *c, sock_t sock) {
> -  (void) c;
> -  (void) sock;
> -}
> -
> -static void mg_null_if_init(struct mg_iface *iface) {
> -  (void) iface;
> -}
> -
> -static void mg_null_if_free(struct mg_iface *iface) {
> -  (void) iface;
> -}
> -
> -static void mg_null_if_add_conn(struct mg_connection *c) {
> -  c->sock = INVALID_SOCKET;
> -  c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -}
> -
> -static void mg_null_if_remove_conn(struct mg_connection *c) {
> -  (void) c;
> -}
> -
> -static time_t mg_null_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  struct mg_mgr *mgr = iface->mgr;
> -  struct mg_connection *nc, *tmp;
> -  double now = mg_time();
> -  /* We basically just run timers and poll. */
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    tmp = nc->next;
> -    mg_if_poll(nc, now);
> -  }
> -  (void) timeout_ms;
> -  return (time_t) now;
> -}
> -
> -static void mg_null_if_get_conn_addr(struct mg_connection *c, int remote,
> -                                     union socket_address *sa) {
> -  (void) c;
> -  (void) remote;
> -  (void) sa;
> -}
> -
> -#define MG_NULL_IFACE_VTABLE                                                   \
> -  {                                                                            \
> -    mg_null_if_init, mg_null_if_free, mg_null_if_add_conn,                     \
> -        mg_null_if_remove_conn, mg_null_if_poll, mg_null_if_listen_tcp,        \
> -        mg_null_if_listen_udp, mg_null_if_connect_tcp, mg_null_if_connect_udp, \
> -        mg_null_if_tcp_send, mg_null_if_udp_send, mg_null_if_tcp_recv,         \
> -        mg_null_if_udp_recv, mg_null_if_create_conn, mg_null_if_destroy_conn,  \
> -        mg_null_if_sock_set, mg_null_if_get_conn_addr,                         \
> -  }
> -
> -const struct mg_iface_vtable mg_null_iface_vtable = MG_NULL_IFACE_VTABLE;
> -
> -#if MG_NET_IF == MG_NET_IF_NULL
> -const struct mg_iface_vtable mg_default_iface_vtable = MG_NULL_IFACE_VTABLE;
> -#endif /* MG_NET_IF == MG_NET_IF_NULL */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if_socket.c"
> -#endif
> -
> -#if MG_ENABLE_NET_IF_SOCKET
> -
> -/* Amalgamated: #include "mg_net_if_socket.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_util.h" */
> -
> -static sock_t mg_open_listening_socket(union socket_address *sa, int type,
> -                                       int proto);
> -
> -static void mg_set_non_blocking_mode(sock_t sock) {
> -#ifdef _WIN32
> -  unsigned long on = 1;
> -  ioctlsocket(sock, FIONBIO, &on);
> -#else
> -  int flags = fcntl(sock, F_GETFL, 0);
> -  fcntl(sock, F_SETFL, flags | O_NONBLOCK);
> -#endif
> -}
> -
> -static int mg_is_error(void) {
> -  int err = mg_get_errno();
> -  return err != EINPROGRESS && err != EWOULDBLOCK
> -#ifndef WINCE
> -         && err != EAGAIN && err != EINTR
> -#endif
> -#ifdef _WIN32
> -         && WSAGetLastError() != WSAEINTR && WSAGetLastError() != WSAEWOULDBLOCK
> -#endif
> -      ;
> -}
> -
> -static void mg_socket_if_connect_tcp(struct mg_connection *nc,
> -                              const union socket_address *sa) {
> -  int rc, proto = 0;
> -  nc->sock = socket(AF_INET, SOCK_STREAM, proto);
> -  if (nc->sock == INVALID_SOCKET) {
> -    nc->err = mg_get_errno() ? mg_get_errno() : 1;
> -    return;
> -  }
> -#if !defined(MG_ESP8266)
> -  mg_set_non_blocking_mode(nc->sock);
> -#endif
> -  rc = connect(nc->sock, &sa->sa, sizeof(sa->sin));
> -  nc->err = rc < 0 && mg_is_error() ? mg_get_errno() : 0;
> -  DBG(("%p sock %d rc %d errno %d err %d", nc, (int) nc->sock, rc,
> -      mg_get_errno(), nc->err));
> -}
> -
> -static void mg_socket_if_connect_udp(struct mg_connection *nc) {
> -  nc->sock = socket(AF_INET, SOCK_DGRAM, 0);
> -  if (nc->sock == INVALID_SOCKET) {
> -    nc->err = mg_get_errno() ? mg_get_errno() : 1;
> -    return;
> -  }
> -  if (nc->flags & MG_F_ENABLE_BROADCAST) {
> -    int optval = 1;
> -    if (setsockopt(nc->sock, SOL_SOCKET, SO_BROADCAST, (const char *) &optval,
> -                   sizeof(optval)) < 0) {
> -      nc->err = mg_get_errno() ? mg_get_errno() : 1;
> -      return;
> -    }
> -  }
> -  nc->err = 0;
> -}
> -
> -static int mg_socket_if_listen_tcp(struct mg_connection *nc,
> -                            union socket_address *sa) {
> -  int proto = 0;
> -  sock_t sock = mg_open_listening_socket(sa, SOCK_STREAM, proto);
> -  if (sock == INVALID_SOCKET) {
> -    return (mg_get_errno() ? mg_get_errno() : 1);
> -  }
> -  mg_sock_set(nc, sock);
> -  return 0;
> -}
> -
> -static int mg_socket_if_listen_udp(struct mg_connection *nc,
> -                                   union socket_address *sa) {
> -  sock_t sock = mg_open_listening_socket(sa, SOCK_DGRAM, 0);
> -  if (sock == INVALID_SOCKET) return (mg_get_errno() ? mg_get_errno() : 1);
> -  mg_sock_set(nc, sock);
> -  return 0;
> -}
> -
> -static int mg_socket_if_tcp_send(struct mg_connection *nc, const void *buf,
> -                                 size_t len) {
> -  int n = (int) MG_SEND_FUNC(nc->sock, buf, len, 0);
> -  if (n < 0 && !mg_is_error()) n = 0;
> -  return n;
> -}
> -
> -static int mg_socket_if_udp_send(struct mg_connection *nc, const void *buf,
> -                                 size_t len) {
> -  int n = sendto(nc->sock, buf, len, 0, &nc->sa.sa, sizeof(nc->sa.sin));
> -  if (n < 0 && !mg_is_error()) n = 0;
> -  return n;
> -}
> -
> -static int mg_socket_if_tcp_recv(struct mg_connection *nc, void *buf,
> -                                 size_t len) {
> -  int n = (int) MG_RECV_FUNC(nc->sock, buf, len, 0);
> -  if (n == 0) {
> -    /* Orderly shutdown of the socket, try flushing output. */
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  } else if (n < 0 && !mg_is_error()) {
> -    n = 0;
> -  }
> -  return n;
> -}
> -
> -static int mg_socket_if_udp_recv(struct mg_connection *nc, void *buf,
> -                                 size_t len, union socket_address *sa,
> -                                 size_t *sa_len) {
> -  socklen_t sa_len_st = *sa_len;
> -  int n = recvfrom(nc->sock, buf, len, 0, &sa->sa, &sa_len_st);
> -  *sa_len = sa_len_st;
> -  if (n < 0 && !mg_is_error()) n = 0;
> -  return n;
> -}
> -
> -static int mg_socket_if_create_conn(struct mg_connection *nc) {
> -  (void) nc;
> -  return 1;
> -}
> -
> -static void mg_socket_if_destroy_conn(struct mg_connection *nc) {
> -  if (nc->sock == INVALID_SOCKET) return;
> -  if (!(nc->flags & MG_F_UDP)) {
> -    closesocket(nc->sock);
> -  } else {
> -    /* Only close outgoing UDP sockets or listeners. */
> -    if (nc->listener == NULL) closesocket(nc->sock);
> -  }
> -  nc->sock = INVALID_SOCKET;
> -}
> -
> -static int mg_accept_conn(struct mg_connection *lc) {
> -  struct mg_connection *nc;
> -  union socket_address sa;
> -  socklen_t sa_len = sizeof(sa);
> -  /* NOTE(lsm): on Windows, sock is always > FD_SETSIZE */
> -  sock_t sock = accept(lc->sock, &sa.sa, &sa_len);
> -  if (sock == INVALID_SOCKET) {
> -    if (mg_is_error()) {
> -      DBG(("%p: failed to accept: %d", lc, mg_get_errno()));
> -    }
> -    return 0;
> -  }
> -  nc = mg_if_accept_new_conn(lc);
> -  if (nc == NULL) {
> -    closesocket(sock);
> -    return 0;
> -  }
> -  DBG(("%p conn from %s:%d", nc, inet_ntoa(sa.sin.sin_addr),
> -       ntohs(sa.sin.sin_port)));
> -  mg_sock_set(nc, sock);
> -  mg_if_accept_tcp_cb(nc, &sa, sa_len);
> -  return 1;
> -}
> -
> -/* 'sa' must be an initialized address to bind to */
> -static sock_t mg_open_listening_socket(union socket_address *sa, int type,
> -                                       int proto) {
> -  socklen_t sa_len =
> -      (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6);
> -  sock_t sock = INVALID_SOCKET;
> -#if !MG_LWIP
> -  int on = 1;
> -#endif
> -
> -  if ((sock = socket(sa->sa.sa_family, type, proto)) != INVALID_SOCKET &&
> -#if !MG_LWIP /* LWIP doesn't support either */
> -#if defined(_WIN32) && defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE)
> -      /* "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" http://goo.gl/RmrFTm */
> -      !setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (void *) &on,
> -                  sizeof(on)) &&
> -#endif
> -
> -#if !defined(_WIN32) || !defined(SO_EXCLUSIVEADDRUSE)
> -      /*
> -       * SO_RESUSEADDR is not enabled on Windows because the semantics of
> -       * SO_REUSEADDR on UNIX and Windows is different. On Windows,
> -       * SO_REUSEADDR allows to bind a socket to a port without error even if
> -       * the port is already open by another program. This is not the behavior
> -       * SO_REUSEADDR was designed for, and leads to hard-to-track failure
> -       * scenarios. Therefore, SO_REUSEADDR was disabled on Windows unless
> -       * SO_EXCLUSIVEADDRUSE is supported and set on a socket.
> -       */
> -      !setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) &&
> -#endif
> -#endif /* !MG_LWIP */
> -
> -      !bind(sock, &sa->sa, sa_len) &&
> -      (type == SOCK_DGRAM || listen(sock, SOMAXCONN) == 0)) {
> -#if !MG_LWIP
> -    mg_set_non_blocking_mode(sock);
> -    /* In case port was set to 0, get the real port number */
> -    (void) getsockname(sock, &sa->sa, &sa_len);
> -#endif
> -  } else if (sock != INVALID_SOCKET) {
> -    closesocket(sock);
> -    sock = INVALID_SOCKET;
> -  }
> -
> -  return sock;
> -}
> -
> -#define _MG_F_FD_CAN_READ 1
> -#define _MG_F_FD_CAN_WRITE 1 << 1
> -#define _MG_F_FD_ERROR 1 << 2
> -
> -static void mg_mgr_handle_conn(struct mg_connection *nc, int fd_flags, double now) {
> -  int worth_logging =
> -      fd_flags != 0 || (nc->flags & (MG_F_WANT_READ | MG_F_WANT_WRITE));
> -  if (worth_logging) {
> -    DBG(("%p fd=%d fd_flags=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc,
> -         (int) nc->sock, fd_flags, nc->flags, (int) nc->recv_mbuf.len,
> -         (int) nc->send_mbuf.len));
> -  }
> -
> -  if (!mg_if_poll(nc, now)) return;
> -
> -  if (nc->flags & MG_F_CONNECTING) {
> -    if (fd_flags != 0) {
> -      int err = 0;
> -#if !defined(MG_ESP8266)
> -      if (!(nc->flags & MG_F_UDP)) {
> -        socklen_t len = sizeof(err);
> -        int ret =
> -            getsockopt(nc->sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
> -        if (ret != 0) {
> -          err = 1;
> -        } else if (err == EAGAIN || err == EWOULDBLOCK) {
> -          err = 0;
> -        }
> -      }
> -#else
> -      /*
> -       * On ESP8266 we use blocking connect.
> -       */
> -      err = nc->err;
> -#endif
> -      mg_if_connect_cb(nc, err);
> -    } else if (nc->err != 0) {
> -      mg_if_connect_cb(nc, nc->err);
> -    }
> -  }
> -
> -  if (fd_flags & _MG_F_FD_CAN_READ) {
> -    if (nc->flags & MG_F_UDP) {
> -      mg_if_can_recv_cb(nc);
> -    } else {
> -      if (nc->flags & MG_F_LISTENING) {
> -        /*
> -         * We're not looping here, and accepting just one connection at
> -         * a time. The reason is that eCos does not respect non-blocking
> -         * flag on a listening socket and hangs in a loop.
> -         */
> -        mg_accept_conn(nc);
> -      } else {
> -        mg_if_can_recv_cb(nc);
> -      }
> -    }
> -  }
> -
> -  if (fd_flags & _MG_F_FD_CAN_WRITE) mg_if_can_send_cb(nc);
> -
> -  if (worth_logging) {
> -    DBG(("%p after fd=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc, (int) nc->sock,
> -         nc->flags, (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
> -  }
> -}
> -
> -#if MG_ENABLE_BROADCAST
> -static void mg_mgr_handle_ctl_sock(struct mg_mgr *mgr) {
> -  struct ctl_msg ctl_msg;
> -  int len = (int) MG_RECV_FUNC(mgr->ctl[1], (char *) &ctl_msg, sizeof(ctl_msg), 0);
> -  size_t dummy = MG_SEND_FUNC(mgr->ctl[1], ctl_msg.message, 1, 0);
> -  DBG(("read %d from ctl socket", len));
> -  (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
> -  if (len >= (int) sizeof(ctl_msg.callback) && ctl_msg.callback != NULL) {
> -    struct mg_connection *nc;
> -    for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
> -      ctl_msg.callback(nc, MG_EV_POLL,
> -                       ctl_msg.message MG_UD_ARG(nc->user_data));
> -    }
> -  }
> -}
> -#endif
> -
> -/* Associate a socket to a connection. */
> -static void mg_socket_if_sock_set(struct mg_connection *nc, sock_t sock) {
> -  mg_set_non_blocking_mode(sock);
> -  mg_set_close_on_exec(sock);
> -  nc->sock = sock;
> -  DBG(("%p %d", nc, (int) sock));
> -}
> -
> -static void mg_socket_if_init(struct mg_iface *iface) {
> -  (void) iface;
> -  DBG(("%p using select()", iface->mgr));
> -#if MG_ENABLE_BROADCAST
> -  mg_socketpair(iface->mgr->ctl, SOCK_DGRAM);
> -#endif
> -}
> -
> -static void mg_socket_if_free(struct mg_iface *iface) {
> -  (void) iface;
> -}
> -
> -static void mg_socket_if_add_conn(struct mg_connection *nc) {
> -  (void) nc;
> -}
> -
> -static void mg_socket_if_remove_conn(struct mg_connection *nc) {
> -  (void) nc;
> -}
> -
> -static void mg_add_to_set(sock_t sock, fd_set *set, sock_t *max_fd) {
> -  if (sock != INVALID_SOCKET
> -#ifdef __unix__
> -      && sock < (sock_t) FD_SETSIZE
> -#endif
> -      ) {
> -    FD_SET(sock, set);
> -    if (*max_fd == INVALID_SOCKET || sock > *max_fd) {
> -      *max_fd = sock;
> -    }
> -  }
> -}
> -
> -static time_t mg_socket_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  struct mg_mgr *mgr = iface->mgr;
> -  double now = mg_time();
> -  double min_timer;
> -  struct mg_connection *nc, *tmp;
> -  struct timeval tv;
> -  fd_set read_set, write_set, err_set;
> -  sock_t max_fd = INVALID_SOCKET;
> -  int num_fds, num_ev, num_timers = 0;
> -#ifdef __unix__
> -  int try_dup = 1;
> -#endif
> -
> -  FD_ZERO(&read_set);
> -  FD_ZERO(&write_set);
> -  FD_ZERO(&err_set);
> -#if MG_ENABLE_BROADCAST
> -  mg_add_to_set(mgr->ctl[1], &read_set, &max_fd);
> -#endif
> -
> -  /*
> -   * Note: it is ok to have connections with sock == INVALID_SOCKET in the list,
> -   * e.g. timer-only "connections".
> -   */
> -  min_timer = 0;
> -  for (nc = mgr->active_connections, num_fds = 0; nc != NULL; nc = tmp) {
> -    tmp = nc->next;
> -
> -    if (nc->sock != INVALID_SOCKET) {
> -      num_fds++;
> -
> -#ifdef __unix__
> -      /* A hack to make sure all our file descriptos fit into FD_SETSIZE. */
> -      if (nc->sock >= (sock_t) FD_SETSIZE && try_dup) {
> -        int new_sock = dup(nc->sock);
> -        if (new_sock >= 0) {
> -          if (new_sock < (sock_t) FD_SETSIZE) {
> -            closesocket(nc->sock);
> -            DBG(("new sock %d -> %d", nc->sock, new_sock));
> -            nc->sock = new_sock;
> -          } else {
> -            closesocket(new_sock);
> -            DBG(("new sock is still larger than FD_SETSIZE, disregard"));
> -            try_dup = 0;
> -          }
> -        } else {
> -          try_dup = 0;
> -        }
> -      }
> -#endif
> -
> -      if (nc->recv_mbuf.len < nc->recv_mbuf_limit &&
> -          (!(nc->flags & MG_F_UDP) || nc->listener == NULL)) {
> -        mg_add_to_set(nc->sock, &read_set, &max_fd);
> -      }
> -
> -      if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) ||
> -          (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) {
> -        mg_add_to_set(nc->sock, &write_set, &max_fd);
> -        mg_add_to_set(nc->sock, &err_set, &max_fd);
> -      }
> -    }
> -
> -    if (nc->ev_timer_time > 0) {
> -      if (num_timers == 0 || nc->ev_timer_time < min_timer) {
> -        min_timer = nc->ev_timer_time;
> -      }
> -      num_timers++;
> -    }
> -  }
> -
> -  /*
> -   * If there is a timer to be fired earlier than the requested timeout,
> -   * adjust the timeout.
> -   */
> -  if (num_timers > 0) {
> -    double timer_timeout_ms = (min_timer - mg_time()) * 1000 + 1 /* rounding */;
> -    if (timer_timeout_ms < timeout_ms) {
> -      timeout_ms = (int) timer_timeout_ms;
> -    }
> -  }
> -  if (timeout_ms < 0) timeout_ms = 0;
> -
> -  tv.tv_sec = timeout_ms / 1000;
> -  tv.tv_usec = (timeout_ms % 1000) * 1000;
> -
> -  num_ev = select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv);
> -  now = mg_time();
> -#if 0
> -  DBG(("select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev, num_fds,
> -       timeout_ms));
> -#endif
> -
> -#if MG_ENABLE_BROADCAST
> -  if (num_ev > 0 && mgr->ctl[1] != INVALID_SOCKET &&
> -      FD_ISSET(mgr->ctl[1], &read_set)) {
> -    mg_mgr_handle_ctl_sock(mgr);
> -  }
> -#endif
> -
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    int fd_flags = 0;
> -    if (nc->sock != INVALID_SOCKET) {
> -      if (num_ev > 0) {
> -        fd_flags = (FD_ISSET(nc->sock, &read_set) &&
> -                            (!(nc->flags & MG_F_UDP) || nc->listener == NULL)
> -                        ? _MG_F_FD_CAN_READ
> -                        : 0) |
> -                   (FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE : 0) |
> -                   (FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0);
> -      }
> -#if MG_LWIP
> -      /* With LWIP socket emulation layer, we don't get write events for UDP */
> -      if ((nc->flags & MG_F_UDP) && nc->listener == NULL) {
> -        fd_flags |= _MG_F_FD_CAN_WRITE;
> -      }
> -#endif
> -    }
> -    tmp = nc->next;
> -    mg_mgr_handle_conn(nc, fd_flags, now);
> -  }
> -
> -  return (time_t) now;
> -}
> -
> -#if MG_ENABLE_BROADCAST
> -MG_INTERNAL void mg_socketpair_close(sock_t *sock) {
> -  while (1) {
> -    if (closesocket(*sock) == -1 && errno == EINTR) continue;
> -    break;
> -  }
> -  *sock = INVALID_SOCKET;
> -}
> -
> -MG_INTERNAL sock_t
> -mg_socketpair_accept(sock_t sock, union socket_address *sa, socklen_t sa_len) {
> -  sock_t rc;
> -  while (1) {
> -    if ((rc = accept(sock, &sa->sa, &sa_len)) == INVALID_SOCKET &&
> -        errno == EINTR)
> -      continue;
> -    break;
> -  }
> -  return rc;
> -}
> -
> -int mg_socketpair(sock_t sp[2], int sock_type) {
> -  union socket_address sa, sa2;
> -  sock_t sock;
> -  socklen_t len = sizeof(sa.sin);
> -  int ret = 0;
> -
> -  sock = sp[0] = sp[1] = INVALID_SOCKET;
> -
> -  (void) memset(&sa, 0, sizeof(sa));
> -  sa.sin.sin_family = AF_INET;
> -  sa.sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
> -  sa2 = sa;
> -
> -  if ((sock = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) {
> -  } else if (bind(sock, &sa.sa, len) != 0) {
> -  } else if (sock_type == SOCK_STREAM && listen(sock, 1) != 0) {
> -  } else if (getsockname(sock, &sa.sa, &len) != 0) {
> -  } else if ((sp[0] = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) {
> -  } else if (sock_type == SOCK_STREAM && connect(sp[0], &sa.sa, len) != 0) {
> -  } else if (sock_type == SOCK_DGRAM &&
> -             (bind(sp[0], &sa2.sa, len) != 0 ||
> -              getsockname(sp[0], &sa2.sa, &len) != 0 ||
> -              connect(sp[0], &sa.sa, len) != 0 ||
> -              connect(sock, &sa2.sa, len) != 0)) {
> -  } else if ((sp[1] = (sock_type == SOCK_DGRAM ? sock : mg_socketpair_accept(
> -                                                            sock, &sa, len))) ==
> -             INVALID_SOCKET) {
> -  } else {
> -    mg_set_close_on_exec(sp[0]);
> -    mg_set_close_on_exec(sp[1]);
> -    if (sock_type == SOCK_STREAM) mg_socketpair_close(&sock);
> -    ret = 1;
> -  }
> -
> -  if (!ret) {
> -    if (sp[0] != INVALID_SOCKET) mg_socketpair_close(&sp[0]);
> -    if (sp[1] != INVALID_SOCKET) mg_socketpair_close(&sp[1]);
> -    if (sock != INVALID_SOCKET) mg_socketpair_close(&sock);
> -  }
> -
> -  return ret;
> -}
> -#endif /* MG_ENABLE_BROADCAST */
> -
> -static void mg_sock_get_addr(sock_t sock, int remote,
> -                             union socket_address *sa) {
> -  socklen_t slen = sizeof(*sa);
> -  memset(sa, 0, slen);
> -  if (remote) {
> -    getpeername(sock, &sa->sa, &slen);
> -  } else {
> -    getsockname(sock, &sa->sa, &slen);
> -  }
> -}
> -
> -void mg_sock_to_str(sock_t sock, char *buf, size_t len, int flags) {
> -  union socket_address sa;
> -  mg_sock_get_addr(sock, flags & MG_SOCK_STRINGIFY_REMOTE, &sa);
> -  mg_sock_addr_to_str(&sa, buf, len, flags);
> -}
> -
> -static void mg_socket_if_get_conn_addr(struct mg_connection *nc, int remote,
> -                                union socket_address *sa) {
> -  if ((nc->flags & MG_F_UDP) && remote) {
> -    memcpy(sa, &nc->sa, sizeof(*sa));
> -    return;
> -  }
> -  mg_sock_get_addr(nc->sock, remote, sa);
> -}
> -
> -/* clang-format off */
> -#define MG_SOCKET_IFACE_VTABLE                                          \
> -  {                                                                     \
> -    mg_socket_if_init,                                                  \
> -    mg_socket_if_free,                                                  \
> -    mg_socket_if_add_conn,                                              \
> -    mg_socket_if_remove_conn,                                           \
> -    mg_socket_if_poll,                                                  \
> -    mg_socket_if_listen_tcp,                                            \
> -    mg_socket_if_listen_udp,                                            \
> -    mg_socket_if_connect_tcp,                                           \
> -    mg_socket_if_connect_udp,                                           \
> -    mg_socket_if_tcp_send,                                              \
> -    mg_socket_if_udp_send,                                              \
> -    mg_socket_if_tcp_recv,                                              \
> -    mg_socket_if_udp_recv,                                              \
> -    mg_socket_if_create_conn,                                           \
> -    mg_socket_if_destroy_conn,                                          \
> -    mg_socket_if_sock_set,                                              \
> -    mg_socket_if_get_conn_addr,                                         \
> -  }
> -/* clang-format on */
> -
> -const struct mg_iface_vtable mg_socket_iface_vtable = MG_SOCKET_IFACE_VTABLE;
> -#if MG_NET_IF == MG_NET_IF_SOCKET
> -const struct mg_iface_vtable mg_default_iface_vtable = MG_SOCKET_IFACE_VTABLE;
> -#endif
> -
> -#endif /* MG_ENABLE_NET_IF_SOCKET */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if_socks.c"
> -#endif
> -
> -#if MG_ENABLE_SOCKS
> -
> -struct socksdata {
> -  char *proxy_addr;        /* HOST:PORT of the socks5 proxy server */
> -  struct mg_connection *s; /* Respective connection to the server */
> -  struct mg_connection *c; /* Connection to the client */
> -};
> -
> -static void socks_if_disband(struct socksdata *d) {
> -  LOG(LL_DEBUG, ("disbanding proxy %p %p", d->c, d->s));
> -  if (d->c) {
> -    d->c->flags |= MG_F_SEND_AND_CLOSE;
> -    d->c->user_data = NULL;
> -    d->c = NULL;
> -  }
> -  if (d->s) {
> -    d->s->flags |= MG_F_SEND_AND_CLOSE;
> -    d->s->user_data = NULL;
> -    d->s = NULL;
> -  }
> -}
> -
> -static void socks_if_relay(struct mg_connection *s) {
> -  struct socksdata *d = (struct socksdata *) s->user_data;
> -  if (d == NULL || d->c == NULL || !(s->flags & MG_SOCKS_CONNECT_DONE) ||
> -      d->s == NULL) {
> -    return;
> -  }
> -  if (s->recv_mbuf.len > 0) mg_if_can_recv_cb(d->c);
> -  if (d->c->send_mbuf.len > 0 && s->send_mbuf.len == 0) mg_if_can_send_cb(d->c);
> -}
> -
> -static void socks_if_handler(struct mg_connection *c, int ev, void *ev_data) {
> -  struct socksdata *d = (struct socksdata *) c->user_data;
> -  if (d == NULL) return;
> -  if (ev == MG_EV_CONNECT) {
> -    int res = *(int *) ev_data;
> -    if (res == 0) {
> -      /* Send handshake to the proxy server */
> -      unsigned char buf[] = {MG_SOCKS_VERSION, 1, MG_SOCKS_HANDSHAKE_NOAUTH};
> -      mg_send(d->s, buf, sizeof(buf));
> -      LOG(LL_DEBUG, ("Sent handshake to %s", d->proxy_addr));
> -    } else {
> -      LOG(LL_ERROR, ("Cannot connect to %s: %d", d->proxy_addr, res));
> -      d->c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    }
> -  } else if (ev == MG_EV_CLOSE) {
> -    socks_if_disband(d);
> -  } else if (ev == MG_EV_RECV) {
> -    /* Handle handshake reply */
> -    if (!(c->flags & MG_SOCKS_HANDSHAKE_DONE)) {
> -      /* TODO(lsm): process IPv6 too */
> -      unsigned char buf[10] = {MG_SOCKS_VERSION, MG_SOCKS_CMD_CONNECT, 0,
> -                               MG_SOCKS_ADDR_IPV4};
> -      if (c->recv_mbuf.len < 2) return;
> -      if ((unsigned char) c->recv_mbuf.buf[1] == MG_SOCKS_HANDSHAKE_FAILURE) {
> -        LOG(LL_ERROR, ("Server kicked us out"));
> -        socks_if_disband(d);
> -        return;
> -      }
> -      mbuf_remove(&c->recv_mbuf, 2);
> -      c->flags |= MG_SOCKS_HANDSHAKE_DONE;
> -
> -      /* Send connect request */
> -      memcpy(buf + 4, &d->c->sa.sin.sin_addr, 4);
> -      memcpy(buf + 8, &d->c->sa.sin.sin_port, 2);
> -      mg_send(c, buf, sizeof(buf));
> -      LOG(LL_DEBUG, ("%p Sent connect request", c));
> -    }
> -    /* Process connect request */
> -    if ((c->flags & MG_SOCKS_HANDSHAKE_DONE) &&
> -        !(c->flags & MG_SOCKS_CONNECT_DONE)) {
> -      if (c->recv_mbuf.len < 10) return;
> -      if (c->recv_mbuf.buf[1] != MG_SOCKS_SUCCESS) {
> -        LOG(LL_ERROR, ("Socks connection error: %d", c->recv_mbuf.buf[1]));
> -        socks_if_disband(d);
> -        return;
> -      }
> -      mbuf_remove(&c->recv_mbuf, 10);
> -      c->flags |= MG_SOCKS_CONNECT_DONE;
> -      LOG(LL_DEBUG, ("%p Connect done %p", c, d->c));
> -      mg_if_connect_cb(d->c, 0);
> -    }
> -    socks_if_relay(c);
> -  } else if (ev == MG_EV_SEND || ev == MG_EV_POLL) {
> -    socks_if_relay(c);
> -  }
> -}
> -
> -static void mg_socks_if_connect_tcp(struct mg_connection *c,
> -                                    const union socket_address *sa) {
> -  struct socksdata *d = (struct socksdata *) c->iface->data;
> -  d->c = c;
> -  d->s = mg_connect(c->mgr, d->proxy_addr, socks_if_handler);
> -  d->s->user_data = d;
> -  LOG(LL_DEBUG, ("%p %s %p %p", c, d->proxy_addr, d, d->s));
> -  (void) sa;
> -}
> -
> -static void mg_socks_if_connect_udp(struct mg_connection *c) {
> -  (void) c;
> -}
> -
> -static int mg_socks_if_listen_tcp(struct mg_connection *c,
> -                                  union socket_address *sa) {
> -  (void) c;
> -  (void) sa;
> -  return 0;
> -}
> -
> -static int mg_socks_if_listen_udp(struct mg_connection *c,
> -                                  union socket_address *sa) {
> -  (void) c;
> -  (void) sa;
> -  return -1;
> -}
> -
> -static int mg_socks_if_tcp_send(struct mg_connection *c, const void *buf,
> -                                size_t len) {
> -  int res;
> -  struct socksdata *d = (struct socksdata *) c->iface->data;
> -  if (d->s == NULL) return -1;
> -  res = (int) mbuf_append(&d->s->send_mbuf, buf, len);
> -  DBG(("%p -> %d -> %p", c, res, d->s));
> -  return res;
> -}
> -
> -static int mg_socks_if_udp_send(struct mg_connection *c, const void *buf,
> -                                size_t len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  return -1;
> -}
> -
> -int mg_socks_if_tcp_recv(struct mg_connection *c, void *buf, size_t len) {
> -  struct socksdata *d = (struct socksdata *) c->iface->data;
> -  if (d->s == NULL) return -1;
> -  if (len > d->s->recv_mbuf.len) len = d->s->recv_mbuf.len;
> -  if (len > 0) {
> -    memcpy(buf, d->s->recv_mbuf.buf, len);
> -    mbuf_remove(&d->s->recv_mbuf, len);
> -  }
> -  DBG(("%p <- %d <- %p", c, (int) len, d->s));
> -  return len;
> -}
> -
> -int mg_socks_if_udp_recv(struct mg_connection *c, void *buf, size_t len,
> -                         union socket_address *sa, size_t *sa_len) {
> -  (void) c;
> -  (void) buf;
> -  (void) len;
> -  (void) sa;
> -  (void) sa_len;
> -  return -1;
> -}
> -
> -static int mg_socks_if_create_conn(struct mg_connection *c) {
> -  (void) c;
> -  return 1;
> -}
> -
> -static void mg_socks_if_destroy_conn(struct mg_connection *c) {
> -  c->iface->vtable->free(c->iface);
> -  MG_FREE(c->iface);
> -  c->iface = NULL;
> -  LOG(LL_DEBUG, ("%p", c));
> -}
> -
> -static void mg_socks_if_sock_set(struct mg_connection *c, sock_t sock) {
> -  (void) c;
> -  (void) sock;
> -}
> -
> -static void mg_socks_if_init(struct mg_iface *iface) {
> -  (void) iface;
> -}
> -
> -static void mg_socks_if_free(struct mg_iface *iface) {
> -  struct socksdata *d = (struct socksdata *) iface->data;
> -  LOG(LL_DEBUG, ("%p", iface));
> -  if (d != NULL) {
> -    socks_if_disband(d);
> -    MG_FREE(d->proxy_addr);
> -    MG_FREE(d);
> -    iface->data = NULL;
> -  }
> -}
> -
> -static void mg_socks_if_add_conn(struct mg_connection *c) {
> -  c->sock = INVALID_SOCKET;
> -}
> -
> -static void mg_socks_if_remove_conn(struct mg_connection *c) {
> -  (void) c;
> -}
> -
> -static time_t mg_socks_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  LOG(LL_DEBUG, ("%p", iface));
> -  (void) iface;
> -  (void) timeout_ms;
> -  return (time_t) cs_time();
> -}
> -
> -static void mg_socks_if_get_conn_addr(struct mg_connection *c, int remote,
> -                                      union socket_address *sa) {
> -  LOG(LL_DEBUG, ("%p", c));
> -  (void) c;
> -  (void) remote;
> -  (void) sa;
> -}
> -
> -const struct mg_iface_vtable mg_socks_iface_vtable = {
> -    mg_socks_if_init,          mg_socks_if_free,
> -    mg_socks_if_add_conn,      mg_socks_if_remove_conn,
> -    mg_socks_if_poll,          mg_socks_if_listen_tcp,
> -    mg_socks_if_listen_udp,    mg_socks_if_connect_tcp,
> -    mg_socks_if_connect_udp,   mg_socks_if_tcp_send,
> -    mg_socks_if_udp_send,      mg_socks_if_tcp_recv,
> -    mg_socks_if_udp_recv,      mg_socks_if_create_conn,
> -    mg_socks_if_destroy_conn,  mg_socks_if_sock_set,
> -    mg_socks_if_get_conn_addr,
> -};
> -
> -struct mg_iface *mg_socks_mk_iface(struct mg_mgr *mgr, const char *proxy_addr) {
> -  struct mg_iface *iface = mg_if_create_iface(&mg_socks_iface_vtable, mgr);
> -  iface->data = MG_CALLOC(1, sizeof(struct socksdata));
> -  ((struct socksdata *) iface->data)->proxy_addr = strdup(proxy_addr);
> -  return iface;
> -}
> -
> -#endif
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_ssl_if_openssl.c"
> -#endif
> -
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_OPENSSL
> -
> -#ifdef __APPLE__
> -#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
> -#endif
> -
> -#include <openssl/ssl.h>
> -#include <openssl/err.h>
> -#ifndef KR_VERSION
> -#include <openssl/tls1.h>
> -#endif
> -
> -static const char *mg_default_session_id_context = "mongoose";
> -
> -struct mg_ssl_if_ctx {
> -  SSL *ssl;
> -  SSL_CTX *ssl_ctx;
> -  struct mbuf psk;
> -  size_t identity_len;
> -};
> -
> -void mg_ssl_if_init(void) {
> -  SSL_library_init();
> -}
> -
> -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc,
> -                                            struct mg_connection *lc) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx));
> -  struct mg_ssl_if_ctx *lc_ctx = (struct mg_ssl_if_ctx *) lc->ssl_if_data;
> -  nc->ssl_if_data = ctx;
> -  if (ctx == NULL || lc_ctx == NULL) return MG_SSL_ERROR;
> -  ctx->ssl_ctx = lc_ctx->ssl_ctx;
> -  if ((ctx->ssl = SSL_new(ctx->ssl_ctx)) == NULL) {
> -    return MG_SSL_ERROR;
> -  }
> -  return MG_SSL_OK;
> -}
> -
> -static enum mg_ssl_if_result mg_use_cert(SSL_CTX *ctx, const char *cert,
> -                                         const char *key, const char **err_msg);
> -static enum mg_ssl_if_result mg_use_ca_cert(SSL_CTX *ctx, const char *cert);
> -static enum mg_ssl_if_result mg_set_cipher_list(SSL_CTX *ctx, const char *cl);
> -static enum mg_ssl_if_result mg_ssl_if_ossl_set_psk(struct mg_ssl_if_ctx *ctx,
> -                                                    const char *identity,
> -                                                    const char *key_str);
> -
> -enum mg_ssl_if_result mg_ssl_if_conn_init(
> -    struct mg_connection *nc, const struct mg_ssl_if_conn_params *params,
> -    const char **err_msg) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx));
> -  DBG(("%p %s,%s,%s", nc, (params->cert ? params->cert : ""),
> -       (params->key ? params->key : ""),
> -       (params->ca_cert ? params->ca_cert : "")));
> -  if (ctx == NULL) {
> -    MG_SET_PTRPTR(err_msg, "Out of memory");
> -    return MG_SSL_ERROR;
> -  }
> -  nc->ssl_if_data = ctx;
> -  if (nc->flags & MG_F_LISTENING) {
> -    ctx->ssl_ctx = SSL_CTX_new(SSLv23_server_method());
> -  } else {
> -    ctx->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
> -  }
> -  if (ctx->ssl_ctx == NULL) {
> -    MG_SET_PTRPTR(err_msg, "Failed to create SSL context");
> -    return MG_SSL_ERROR;
> -  }
> -
> -#ifndef KR_VERSION
> -  /* Disable deprecated protocols. */
> -  SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2);
> -  SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv3);
> -  SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1);
> -  SSL_CTX_set_session_id_context(ctx->ssl_ctx,
> -                                 (void *) mg_default_session_id_context,
> -                                 strlen(mg_default_session_id_context));
> -#ifdef MG_SSL_OPENSSL_NO_COMPRESSION
> -  SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_COMPRESSION);
> -#endif
> -#ifdef MG_SSL_OPENSSL_CIPHER_SERVER_PREFERENCE
> -  SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
> -#endif
> -#else
> -/* Krypton only supports TLSv1.2 anyway. */
> -#endif
> -
> -  if (params->cert != NULL &&
> -      mg_use_cert(ctx->ssl_ctx, params->cert, params->key, err_msg) !=
> -          MG_SSL_OK) {
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (params->ca_cert != NULL &&
> -      mg_use_ca_cert(ctx->ssl_ctx, params->ca_cert) != MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL CA cert");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (mg_set_cipher_list(ctx->ssl_ctx, params->cipher_suites) != MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid cipher suite list");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  mbuf_init(&ctx->psk, 0);
> -  if (mg_ssl_if_ossl_set_psk(ctx, params->psk_identity, params->psk_key) !=
> -      MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid PSK settings");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (!(nc->flags & MG_F_LISTENING) &&
> -      (ctx->ssl = SSL_new(ctx->ssl_ctx)) == NULL) {
> -    MG_SET_PTRPTR(err_msg, "Failed to create SSL session");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (params->server_name != NULL) {
> -#ifdef KR_VERSION
> -    SSL_CTX_kr_set_verify_name(ctx->ssl_ctx, params->server_name);
> -#else
> -    SSL_set_tlsext_host_name(ctx->ssl, params->server_name);
> -#endif
> -  }
> -
> -  nc->flags |= MG_F_SSL;
> -
> -  return MG_SSL_OK;
> -}
> -
> -static enum mg_ssl_if_result mg_ssl_if_ssl_err(struct mg_connection *nc,
> -                                               int res) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int err = SSL_get_error(ctx->ssl, res);
> -  /*
> -   * We've just fetched the last error from the queue.
> -   * Now we need to clear the error queue. If we do not, then the following
> -   * can happen (actually reported):
> -   *  - A new connection is accept()-ed with cert error (e.g. self-signed cert)
> -   *  - Since all accept()-ed connections share listener's context,
> -   *  - *ALL* SSL accepted connection report read error on the next poll cycle.
> -   *    Thus a single errored connection can close all the rest, unrelated ones.
> -   * Clearing the error keeps the shared SSL_CTX in an OK state.
> -   */
> -  ERR_clear_error();
> -  if (err == SSL_ERROR_WANT_READ) return MG_SSL_WANT_READ;
> -  if (err == SSL_ERROR_WANT_WRITE) return MG_SSL_WANT_WRITE;
> -  DBG(("%p %p SSL error: %d %d", nc, ctx->ssl_ctx, res, err));
> -  nc->err = err;
> -  return MG_SSL_ERROR;
> -}
> -
> -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int server_side = (nc->listener != NULL);
> -  int res;
> -  /* If descriptor is not yet set, do it now. */
> -  if (SSL_get_fd(ctx->ssl) < 0) {
> -    if (SSL_set_fd(ctx->ssl, nc->sock) != 1) return MG_SSL_ERROR;
> -  }
> -  res = server_side ? SSL_accept(ctx->ssl) : SSL_connect(ctx->ssl);
> -  if (res != 1) return mg_ssl_if_ssl_err(nc, res);
> -  return MG_SSL_OK;
> -}
> -
> -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t buf_size) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int n = SSL_read(ctx->ssl, buf, buf_size);
> -  DBG(("%p %d -> %d", nc, (int) buf_size, n));
> -  if (n < 0) return mg_ssl_if_ssl_err(nc, n);
> -  if (n == 0) nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  return n;
> -}
> -
> -int mg_ssl_if_write(struct mg_connection *nc, const void *data, size_t len) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int n = SSL_write(ctx->ssl, data, len);
> -  DBG(("%p %d -> %d", nc, (int) len, n));
> -  if (n <= 0) return mg_ssl_if_ssl_err(nc, n);
> -  return n;
> -}
> -
> -void mg_ssl_if_conn_close_notify(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  if (ctx == NULL) return;
> -  SSL_shutdown(ctx->ssl);
> -}
> -
> -void mg_ssl_if_conn_free(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  if (ctx == NULL) return;
> -  nc->ssl_if_data = NULL;
> -  if (ctx->ssl != NULL) SSL_free(ctx->ssl);
> -  if (ctx->ssl_ctx != NULL && nc->listener == NULL) SSL_CTX_free(ctx->ssl_ctx);
> -  mbuf_free(&ctx->psk);
> -  memset(ctx, 0, sizeof(*ctx));
> -  MG_FREE(ctx);
> -}
> -
> -/*
> - * Cipher suite options used for TLS negotiation.
> - * https://wiki.mozilla.org/Security/Server_Side_TLS#Recommended_configurations
> - */
> -static const char mg_s_cipher_list[] =
> -#if defined(MG_SSL_CRYPTO_MODERN)
> -    "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:"
> -    "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:"
> -    "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:"
> -    "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:"
> -    "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:"
> -    "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:"
> -    "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:"
> -    "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:"
> -    "!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK"
> -#elif defined(MG_SSL_CRYPTO_OLD)
> -    "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:"
> -    "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:"
> -    "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:"
> -    "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:"
> -    "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:"
> -    "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:"
> -    "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:"
> -    "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:ECDHE-RSA-DES-CBC3-SHA:"
> -    "ECDHE-ECDSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:"
> -    "AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:DES-CBC3-SHA:"
> -    "HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:"
> -    "!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA"
> -#else /* Default - intermediate. */
> -    "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:"
> -    "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:"
> -    "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:"
> -    "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:"
> -    "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:"
> -    "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:"
> -    "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:"
> -    "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:"
> -    "AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:"
> -    "DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:"
> -    "!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA"
> -#endif
> -    ;
> -
> -/*
> - * Default DH params for PFS cipher negotiation. This is a 2048-bit group.
> - * Will be used if none are provided by the user in the certificate file.
> - */
> -#if !MG_DISABLE_PFS && !defined(KR_VERSION)
> -static const char mg_s_default_dh_params[] =
> -    "\
> ------BEGIN DH PARAMETERS-----\n\
> -MIIBCAKCAQEAlvbgD/qh9znWIlGFcV0zdltD7rq8FeShIqIhkQ0C7hYFThrBvF2E\n\
> -Z9bmgaP+sfQwGpVlv9mtaWjvERbu6mEG7JTkgmVUJrUt/wiRzwTaCXBqZkdUO8Tq\n\
> -+E6VOEQAilstG90ikN1Tfo+K6+X68XkRUIlgawBTKuvKVwBhuvlqTGerOtnXWnrt\n\
> -ym//hd3cd5PBYGBix0i7oR4xdghvfR2WLVu0LgdThTBb6XP7gLd19cQ1JuBtAajZ\n\
> -wMuPn7qlUkEFDIkAZy59/Hue/H2Q2vU/JsvVhHWCQBL4F1ofEAt50il6ZxR1QfFK\n\
> -9VGKDC4oOgm9DlxwwBoC2FjqmvQlqVV3kwIBAg==\n\
> ------END DH PARAMETERS-----\n";
> -#endif
> -
> -static enum mg_ssl_if_result mg_use_ca_cert(SSL_CTX *ctx, const char *cert) {
> -  if (cert == NULL || strcmp(cert, "*") == 0) {
> -    return MG_SSL_OK;
> -  }
> -  SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
> -  return SSL_CTX_load_verify_locations(ctx, cert, NULL) == 1 ? MG_SSL_OK
> -                                                             : MG_SSL_ERROR;
> -}
> -
> -static enum mg_ssl_if_result mg_use_cert(SSL_CTX *ctx, const char *cert,
> -                                         const char *key,
> -                                         const char **err_msg) {
> -  if (key == NULL) key = cert;
> -  if (cert == NULL || cert[0] == '\0' || key == NULL || key[0] == '\0') {
> -    return MG_SSL_OK;
> -  } else if (SSL_CTX_use_certificate_file(ctx, cert, 1) == 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL cert");
> -    return MG_SSL_ERROR;
> -  } else if (SSL_CTX_use_PrivateKey_file(ctx, key, 1) == 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL key");
> -    return MG_SSL_ERROR;
> -  } else if (SSL_CTX_use_certificate_chain_file(ctx, cert) == 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid CA bundle");
> -    return MG_SSL_ERROR;
> -  } else {
> -    SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
> -#if !MG_DISABLE_PFS && !defined(KR_VERSION)
> -    BIO *bio = NULL;
> -    DH *dh = NULL;
> -
> -    /* Try to read DH parameters from the cert/key file. */
> -    bio = BIO_new_file(cert, "r");
> -    if (bio != NULL) {
> -      dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
> -      BIO_free(bio);
> -    }
> -    /*
> -     * If there are no DH params in the file, fall back to hard-coded ones.
> -     * Not ideal, but better than nothing.
> -     */
> -    if (dh == NULL) {
> -      bio = BIO_new_mem_buf((void *) mg_s_default_dh_params, -1);
> -      dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
> -      BIO_free(bio);
> -    }
> -    if (dh != NULL) {
> -      SSL_CTX_set_tmp_dh(ctx, dh);
> -      SSL_CTX_set_options(ctx, SSL_OP_SINGLE_DH_USE);
> -      DH_free(dh);
> -    }
> -#if OPENSSL_VERSION_NUMBER > 0x10002000L
> -    SSL_CTX_set_ecdh_auto(ctx, 1);
> -#endif
> -#endif
> -  }
> -  return MG_SSL_OK;
> -}
> -
> -static enum mg_ssl_if_result mg_set_cipher_list(SSL_CTX *ctx, const char *cl) {
> -  return (SSL_CTX_set_cipher_list(ctx, cl ? cl : mg_s_cipher_list) == 1
> -              ? MG_SSL_OK
> -              : MG_SSL_ERROR);
> -}
> -
> -#if !defined(KR_VERSION) && !defined(LIBRESSL_VERSION_NUMBER)
> -static unsigned int mg_ssl_if_ossl_psk_cb(SSL *ssl, const char *hint,
> -                                          char *identity,
> -                                          unsigned int max_identity_len,
> -                                          unsigned char *psk,
> -                                          unsigned int max_psk_len) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) SSL_CTX_get_app_data(SSL_get_SSL_CTX(ssl));
> -  size_t key_len = ctx->psk.len - ctx->identity_len - 1;
> -  DBG(("hint: '%s'", (hint ? hint : "")));
> -  if (ctx->identity_len + 1 > max_identity_len) {
> -    DBG(("identity too long"));
> -    return 0;
> -  }
> -  if (key_len > max_psk_len) {
> -    DBG(("key too long"));
> -    return 0;
> -  }
> -  memcpy(identity, ctx->psk.buf, ctx->identity_len + 1);
> -  memcpy(psk, ctx->psk.buf + ctx->identity_len + 1, key_len);
> -  (void) ssl;
> -  return key_len;
> -}
> -
> -static enum mg_ssl_if_result mg_ssl_if_ossl_set_psk(struct mg_ssl_if_ctx *ctx,
> -                                                    const char *identity,
> -                                                    const char *key_str) {
> -  unsigned char key[32];
> -  size_t key_len;
> -  size_t i = 0;
> -  if (identity == NULL && key_str == NULL) return MG_SSL_OK;
> -  if (identity == NULL || key_str == NULL) return MG_SSL_ERROR;
> -  key_len = strlen(key_str);
> -  if (key_len != 32 && key_len != 64) return MG_SSL_ERROR;
> -  memset(key, 0, sizeof(key));
> -  key_len = 0;
> -  for (i = 0; key_str[i] != '\0'; i++) {
> -    unsigned char c;
> -    char hc = tolower((int) key_str[i]);
> -    if (hc >= '0' && hc <= '9') {
> -      c = hc - '0';
> -    } else if (hc >= 'a' && hc <= 'f') {
> -      c = hc - 'a' + 0xa;
> -    } else {
> -      return MG_SSL_ERROR;
> -    }
> -    key_len = i / 2;
> -    key[key_len] <<= 4;
> -    key[key_len] |= c;
> -  }
> -  key_len++;
> -  DBG(("identity = '%s', key = (%u)", identity, (unsigned int) key_len));
> -  ctx->identity_len = strlen(identity);
> -  mbuf_append(&ctx->psk, identity, ctx->identity_len + 1);
> -  mbuf_append(&ctx->psk, key, key_len);
> -  SSL_CTX_set_psk_client_callback(ctx->ssl_ctx, mg_ssl_if_ossl_psk_cb);
> -  SSL_CTX_set_app_data(ctx->ssl_ctx, ctx);
> -  return MG_SSL_OK;
> -}
> -#else
> -static enum mg_ssl_if_result mg_ssl_if_ossl_set_psk(struct mg_ssl_if_ctx *ctx,
> -                                                    const char *identity,
> -                                                    const char *key_str) {
> -  (void) ctx;
> -  (void) identity;
> -  (void) key_str;
> -  /* Krypton / LibreSSL does not support PSK. */
> -  return MG_SSL_ERROR;
> -}
> -#endif /* !defined(KR_VERSION) && !defined(LIBRESSL_VERSION_NUMBER) */
> -
> -const char *mg_set_ssl(struct mg_connection *nc, const char *cert,
> -                       const char *ca_cert) {
> -  const char *err_msg = NULL;
> -  struct mg_ssl_if_conn_params params;
> -  memset(&params, 0, sizeof(params));
> -  params.cert = cert;
> -  params.ca_cert = ca_cert;
> -  if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
> -    return err_msg;
> -  }
> -  return NULL;
> -}
> -
> -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_OPENSSL */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_ssl_if_mbedtls.c"
> -#endif
> -
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_MBEDTLS
> -
> -#include <mbedtls/debug.h>
> -#include <mbedtls/ecp.h>
> -#include <mbedtls/net.h>
> -#include <mbedtls/platform.h>
> -#include <mbedtls/ssl.h>
> -#include <mbedtls/ssl_internal.h>
> -#include <mbedtls/x509_crt.h>
> -#include <mbedtls/version.h>
> -
> -static void mg_ssl_mbed_log(void *ctx, int level, const char *file, int line,
> -                            const char *str) {
> -  enum cs_log_level cs_level;
> -  switch (level) {
> -    case 1:
> -      cs_level = LL_ERROR;
> -      break;
> -    case 2:
> -      cs_level = LL_INFO;
> -      break;
> -    case 3:
> -      cs_level = LL_DEBUG;
> -      break;
> -    default:
> -      cs_level = LL_VERBOSE_DEBUG;
> -  }
> -  /* mbedTLS passes strings with \n at the end, strip it. */
> -  LOG(cs_level, ("%p %.*s", ctx, (int) (strlen(str) - 1), str));
> -  (void) ctx;
> -  (void) str;
> -  (void) file;
> -  (void) line;
> -  (void) cs_level;
> -}
> -
> -struct mg_ssl_if_ctx {
> -  mbedtls_ssl_config *conf;
> -  mbedtls_ssl_context *ssl;
> -  mbedtls_x509_crt *cert;
> -  mbedtls_pk_context *key;
> -#ifdef MBEDTLS_X509_CA_CHAIN_ON_DISK
> -  char *ca_chain_file;
> -#else
> -  mbedtls_x509_crt *ca_cert;
> -#endif
> -  struct mbuf cipher_suites;
> -  size_t saved_len;
> -};
> -
> -/* Must be provided by the platform. ctx is struct mg_connection. */
> -extern int mg_ssl_if_mbed_random(void *ctx, unsigned char *buf, size_t len);
> -
> -void mg_ssl_if_init(void) {
> -  LOG(LL_INFO, ("%s", MBEDTLS_VERSION_STRING_FULL));
> -}
> -
> -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc,
> -                                            struct mg_connection *lc) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx));
> -  struct mg_ssl_if_ctx *lc_ctx = (struct mg_ssl_if_ctx *) lc->ssl_if_data;
> -  nc->ssl_if_data = ctx;
> -  if (ctx == NULL || lc_ctx == NULL) return MG_SSL_ERROR;
> -  ctx->ssl = (mbedtls_ssl_context *) MG_CALLOC(1, sizeof(*ctx->ssl));
> -  if (mbedtls_ssl_setup(ctx->ssl, lc_ctx->conf) != 0) {
> -    return MG_SSL_ERROR;
> -  }
> -  return MG_SSL_OK;
> -}
> -
> -static enum mg_ssl_if_result mg_use_cert(struct mg_ssl_if_ctx *ctx,
> -                                         const char *cert, const char *key,
> -                                         const char **err_msg);
> -static enum mg_ssl_if_result mg_use_ca_cert(struct mg_ssl_if_ctx *ctx,
> -                                            const char *cert);
> -static enum mg_ssl_if_result mg_set_cipher_list(struct mg_ssl_if_ctx *ctx,
> -                                                const char *ciphers);
> -#ifdef MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
> -static enum mg_ssl_if_result mg_ssl_if_mbed_set_psk(struct mg_ssl_if_ctx *ctx,
> -                                                    const char *identity,
> -                                                    const char *key);
> -#endif
> -
> -enum mg_ssl_if_result mg_ssl_if_conn_init(
> -    struct mg_connection *nc, const struct mg_ssl_if_conn_params *params,
> -    const char **err_msg) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx));
> -  DBG(("%p %s,%s,%s", nc, (params->cert ? params->cert : ""),
> -       (params->key ? params->key : ""),
> -       (params->ca_cert ? params->ca_cert : "")));
> -
> -  if (ctx == NULL) {
> -    MG_SET_PTRPTR(err_msg, "Out of memory");
> -    return MG_SSL_ERROR;
> -  }
> -  nc->ssl_if_data = ctx;
> -  ctx->conf = (mbedtls_ssl_config *) MG_CALLOC(1, sizeof(*ctx->conf));
> -  mbuf_init(&ctx->cipher_suites, 0);
> -  mbedtls_ssl_config_init(ctx->conf);
> -  mbedtls_ssl_conf_dbg(ctx->conf, mg_ssl_mbed_log, nc);
> -  if (mbedtls_ssl_config_defaults(
> -          ctx->conf, (nc->flags & MG_F_LISTENING ? MBEDTLS_SSL_IS_SERVER
> -                                                 : MBEDTLS_SSL_IS_CLIENT),
> -          MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
> -    MG_SET_PTRPTR(err_msg, "Failed to init SSL config");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  /* TLS 1.2 and up */
> -  mbedtls_ssl_conf_min_version(ctx->conf, MBEDTLS_SSL_MAJOR_VERSION_3,
> -                               MBEDTLS_SSL_MINOR_VERSION_3);
> -  mbedtls_ssl_conf_rng(ctx->conf, mg_ssl_if_mbed_random, nc);
> -
> -  if (params->cert != NULL &&
> -      mg_use_cert(ctx, params->cert, params->key, err_msg) != MG_SSL_OK) {
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (params->ca_cert != NULL &&
> -      mg_use_ca_cert(ctx, params->ca_cert) != MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL CA cert");
> -    return MG_SSL_ERROR;
> -  }
> -
> -  if (mg_set_cipher_list(ctx, params->cipher_suites) != MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid cipher suite list");
> -    return MG_SSL_ERROR;
> -  }
> -
> -#ifdef MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
> -  if (mg_ssl_if_mbed_set_psk(ctx, params->psk_identity, params->psk_key) !=
> -      MG_SSL_OK) {
> -    MG_SET_PTRPTR(err_msg, "Invalid PSK settings");
> -    return MG_SSL_ERROR;
> -  }
> -#endif
> -
> -  if (!(nc->flags & MG_F_LISTENING)) {
> -    ctx->ssl = (mbedtls_ssl_context *) MG_CALLOC(1, sizeof(*ctx->ssl));
> -    mbedtls_ssl_init(ctx->ssl);
> -    if (mbedtls_ssl_setup(ctx->ssl, ctx->conf) != 0) {
> -      MG_SET_PTRPTR(err_msg, "Failed to create SSL session");
> -      return MG_SSL_ERROR;
> -    }
> -    if (params->server_name != NULL &&
> -        mbedtls_ssl_set_hostname(ctx->ssl, params->server_name) != 0) {
> -      return MG_SSL_ERROR;
> -    }
> -  }
> -
> -#ifdef MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN
> -  if (mbedtls_ssl_conf_max_frag_len(ctx->conf,
> -#if MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN == 512
> -                                    MBEDTLS_SSL_MAX_FRAG_LEN_512
> -#elif MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN == 1024
> -                                    MBEDTLS_SSL_MAX_FRAG_LEN_1024
> -#elif MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN == 2048
> -                                    MBEDTLS_SSL_MAX_FRAG_LEN_2048
> -#elif MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN == 4096
> -                                    MBEDTLS_SSL_MAX_FRAG_LEN_4096
> -#else
> -#error Invalid MG_SSL_IF_MBEDTLS_MAX_FRAG_LEN
> -#endif
> -                                    ) != 0) {
> -    return MG_SSL_ERROR;
> -  }
> -#endif
> -
> -  nc->flags |= MG_F_SSL;
> -
> -  return MG_SSL_OK;
> -}
> -
> -static int mg_ssl_if_mbed_send(void *ctx, const unsigned char *buf,
> -                               size_t len) {
> -  struct mg_connection *nc = (struct mg_connection *) ctx;
> -  int n = nc->iface->vtable->tcp_send(nc, buf, len);
> -  if (n > 0) return n;
> -  if (n == 0) return MBEDTLS_ERR_SSL_WANT_WRITE;
> -  return MBEDTLS_ERR_NET_SEND_FAILED;
> -}
> -
> -static int mg_ssl_if_mbed_recv(void *ctx, unsigned char *buf, size_t len) {
> -  struct mg_connection *nc = (struct mg_connection *) ctx;
> -  int n = nc->iface->vtable->tcp_recv(nc, buf, len);
> -  if (n > 0) return n;
> -  if (n == 0) return MBEDTLS_ERR_SSL_WANT_READ;
> -  return MBEDTLS_ERR_NET_RECV_FAILED;
> -}
> -
> -static enum mg_ssl_if_result mg_ssl_if_mbed_err(struct mg_connection *nc,
> -                                                int ret) {
> -  enum mg_ssl_if_result res = MG_SSL_OK;
> -  if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
> -    res = MG_SSL_WANT_READ;
> -  } else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
> -    res = MG_SSL_WANT_WRITE;
> -  } else if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
> -    LOG(LL_DEBUG, ("%p TLS connection closed by peer", nc));
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    res = MG_SSL_OK;
> -  } else {
> -    LOG(LL_ERROR, ("%p mbedTLS error: -0x%04x", nc, -ret));
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    res = MG_SSL_ERROR;
> -  }
> -  nc->err = ret;
> -  return res;
> -}
> -
> -static void mg_ssl_if_mbed_free_certs_and_keys(struct mg_ssl_if_ctx *ctx) {
> -  if (ctx->cert != NULL) {
> -    mbedtls_x509_crt_free(ctx->cert);
> -    MG_FREE(ctx->cert);
> -    ctx->cert = NULL;
> -    mbedtls_pk_free(ctx->key);
> -    MG_FREE(ctx->key);
> -    ctx->key = NULL;
> -  }
> -#ifdef MBEDTLS_X509_CA_CHAIN_ON_DISK
> -  MG_FREE(ctx->ca_chain_file);
> -  ctx->ca_chain_file = NULL;
> -#else
> -  if (ctx->ca_cert != NULL) {
> -    mbedtls_ssl_conf_ca_chain(ctx->conf, NULL, NULL);
> -    mbedtls_x509_crt_free(ctx->ca_cert);
> -    MG_FREE(ctx->ca_cert);
> -    ctx->ca_cert = NULL;
> -  }
> -#endif
> -}
> -
> -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int err;
> -  /* If bio is not yet set, do it now. */
> -  if (ctx->ssl->p_bio == NULL) {
> -    mbedtls_ssl_set_bio(ctx->ssl, nc, mg_ssl_if_mbed_send, mg_ssl_if_mbed_recv,
> -                        NULL);
> -  }
> -  err = mbedtls_ssl_handshake(ctx->ssl);
> -  if (err != 0) return mg_ssl_if_mbed_err(nc, err);
> -#ifdef MG_SSL_IF_MBEDTLS_FREE_CERTS
> -  /*
> -   * Free the peer certificate, we don't need it after handshake.
> -   * Note that this effectively disables renegotiation.
> -   */
> -  mbedtls_x509_crt_free(ctx->ssl->session->peer_cert);
> -  mbedtls_free(ctx->ssl->session->peer_cert);
> -  ctx->ssl->session->peer_cert = NULL;
> -  /* On a client connection we can also free our own and CA certs. */
> -  if (nc->listener == NULL) {
> -    if (ctx->conf->key_cert != NULL) {
> -      /* Note that this assumes one key_cert entry, which matches our init. */
> -      MG_FREE(ctx->conf->key_cert);
> -      ctx->conf->key_cert = NULL;
> -    }
> -    mbedtls_ssl_conf_ca_chain(ctx->conf, NULL, NULL);
> -    mg_ssl_if_mbed_free_certs_and_keys(ctx);
> -  }
> -#endif
> -  return MG_SSL_OK;
> -}
> -
> -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t len) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  int n = mbedtls_ssl_read(ctx->ssl, (unsigned char *) buf, len);
> -  DBG(("%p %d -> %d", nc, (int) len, n));
> -  if (n < 0) return mg_ssl_if_mbed_err(nc, n);
> -  if (n == 0) nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  return n;
> -}
> -
> -int mg_ssl_if_write(struct mg_connection *nc, const void *buf, size_t len) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  /* Per mbedTLS docs, if write returns WANT_READ or WANT_WRITE, the operation
> -   * should be retried with the same data and length.
> -   * Here we assume that the data being pushed will remain the same but the
> -   * amount may grow between calls so we save the length that was used and
> -   * retry. The assumption being that the data itself won't change and won't
> -   * be removed. */
> -  size_t l = len;
> -  if (ctx->saved_len > 0 && ctx->saved_len < l) l = ctx->saved_len;
> -  int n = mbedtls_ssl_write(ctx->ssl, (const unsigned char *) buf, l);
> -  DBG(("%p %d,%d,%d -> %d", nc, (int) len, (int) ctx->saved_len, (int) l, n));
> -  if (n < 0) {
> -    if (n == MBEDTLS_ERR_SSL_WANT_READ || n == MBEDTLS_ERR_SSL_WANT_WRITE) {
> -      ctx->saved_len = len;
> -    }
> -    return mg_ssl_if_mbed_err(nc, n);
> -  } else if (n > 0) {
> -    ctx->saved_len = 0;
> -  }
> -  return n;
> -}
> -
> -void mg_ssl_if_conn_close_notify(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  if (ctx == NULL) return;
> -  mbedtls_ssl_close_notify(ctx->ssl);
> -}
> -
> -void mg_ssl_if_conn_free(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  if (ctx == NULL) return;
> -  nc->ssl_if_data = NULL;
> -  if (ctx->ssl != NULL) {
> -    mbedtls_ssl_free(ctx->ssl);
> -    MG_FREE(ctx->ssl);
> -  }
> -  if (ctx->conf != NULL) {
> -    mbedtls_ssl_config_free(ctx->conf);
> -    MG_FREE(ctx->conf);
> -  }
> -  mg_ssl_if_mbed_free_certs_and_keys(ctx);
> -  mbuf_free(&ctx->cipher_suites);
> -  memset(ctx, 0, sizeof(*ctx));
> -  MG_FREE(ctx);
> -}
> -
> -static enum mg_ssl_if_result mg_use_ca_cert(struct mg_ssl_if_ctx *ctx,
> -                                            const char *ca_cert) {
> -  if (ca_cert == NULL || strcmp(ca_cert, "*") == 0) {
> -    mbedtls_ssl_conf_authmode(ctx->conf, MBEDTLS_SSL_VERIFY_NONE);
> -    return MG_SSL_OK;
> -  }
> -#ifdef MBEDTLS_X509_CA_CHAIN_ON_DISK
> -  ctx->ca_chain_file = strdup(ca_cert);
> -  if (ctx->ca_chain_file == NULL) return MG_SSL_ERROR;
> -  if (mbedtls_ssl_conf_ca_chain_file(ctx->conf, ctx->ca_chain_file, NULL) != 0) {
> -    return MG_SSL_ERROR;
> -  }
> -#else
> -  ctx->ca_cert = (mbedtls_x509_crt *) MG_CALLOC(1, sizeof(*ctx->ca_cert));
> -  mbedtls_x509_crt_init(ctx->ca_cert);
> -  if (mbedtls_x509_crt_parse_file(ctx->ca_cert, ca_cert) != 0) {
> -    return MG_SSL_ERROR;
> -  }
> -  mbedtls_ssl_conf_ca_chain(ctx->conf, ctx->ca_cert, NULL);
> -#endif
> -  mbedtls_ssl_conf_authmode(ctx->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
> -  return MG_SSL_OK;
> -}
> -
> -static enum mg_ssl_if_result mg_use_cert(struct mg_ssl_if_ctx *ctx,
> -                                         const char *cert, const char *key,
> -                                         const char **err_msg) {
> -  if (key == NULL) key = cert;
> -  if (cert == NULL || cert[0] == '\0' || key == NULL || key[0] == '\0') {
> -    return MG_SSL_OK;
> -  }
> -  ctx->cert = (mbedtls_x509_crt *) MG_CALLOC(1, sizeof(*ctx->cert));
> -  mbedtls_x509_crt_init(ctx->cert);
> -  ctx->key = (mbedtls_pk_context *) MG_CALLOC(1, sizeof(*ctx->key));
> -  mbedtls_pk_init(ctx->key);
> -  if (mbedtls_x509_crt_parse_file(ctx->cert, cert) != 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL cert");
> -    return MG_SSL_ERROR;
> -  }
> -  if (mbedtls_pk_parse_keyfile(ctx->key, key, NULL) != 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL key");
> -    return MG_SSL_ERROR;
> -  }
> -  if (mbedtls_ssl_conf_own_cert(ctx->conf, ctx->cert, ctx->key) != 0) {
> -    MG_SET_PTRPTR(err_msg, "Invalid SSL key or cert");
> -    return MG_SSL_ERROR;
> -  }
> -  return MG_SSL_OK;
> -}
> -
> -static const int mg_s_cipher_list[] = {
> -#if CS_PLATFORM != CS_P_ESP8266
> -    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
> -    MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA,
> -#else
> -    /*
> -     * ECDHE is way too slow on ESP8266 w/o cryptochip, this sometimes results
> -     * in WiFi STA deauths. Use weaker but faster cipher suites. Sad but true.
> -     * Disable DHE completely because it's just hopelessly slow.
> -     */
> -    MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
> -    MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
> -    MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA,
> -#endif /* CS_PLATFORM != CS_P_ESP8266 */
> -    0,
> -};
> -
> -/*
> - * Ciphers can be specified as a colon-separated list of cipher suite names.
> - * These can be found in
> - * https://github.com/ARMmbed/mbedtls/blob/development/library/ssl_ciphersuites.c#L267
> - * E.g.: TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-CCM
> - */
> -static enum mg_ssl_if_result mg_set_cipher_list(struct mg_ssl_if_ctx *ctx,
> -                                                const char *ciphers) {
> -  if (ciphers != NULL) {
> -    int l, id;
> -    const char *s = ciphers, *e;
> -    char tmp[50];
> -    while (s != NULL) {
> -      e = strchr(s, ':');
> -      l = (e != NULL ? (e - s) : (int) strlen(s));
> -      strncpy(tmp, s, l);
> -      tmp[l] = '\0';
> -      id = mbedtls_ssl_get_ciphersuite_id(tmp);
> -      DBG(("%s -> %04x", tmp, id));
> -      if (id != 0) {
> -        mbuf_append(&ctx->cipher_suites, &id, sizeof(id));
> -      }
> -      s = (e != NULL ? e + 1 : NULL);
> -    }
> -    if (ctx->cipher_suites.len == 0) return MG_SSL_ERROR;
> -    id = 0;
> -    mbuf_append(&ctx->cipher_suites, &id, sizeof(id));
> -    mbuf_trim(&ctx->cipher_suites);
> -    mbedtls_ssl_conf_ciphersuites(ctx->conf,
> -                                  (const int *) ctx->cipher_suites.buf);
> -  } else {
> -    mbedtls_ssl_conf_ciphersuites(ctx->conf, mg_s_cipher_list);
> -  }
> -  return MG_SSL_OK;
> -}
> -
> -#ifdef MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
> -static enum mg_ssl_if_result mg_ssl_if_mbed_set_psk(struct mg_ssl_if_ctx *ctx,
> -                                                    const char *identity,
> -                                                    const char *key_str) {
> -  unsigned char key[32];
> -  size_t key_len;
> -  if (identity == NULL && key_str == NULL) return MG_SSL_OK;
> -  if (identity == NULL || key_str == NULL) return MG_SSL_ERROR;
> -  key_len = strlen(key_str);
> -  if (key_len != 32 && key_len != 64) return MG_SSL_ERROR;
> -  size_t i = 0;
> -  memset(key, 0, sizeof(key));
> -  key_len = 0;
> -  for (i = 0; key_str[i] != '\0'; i++) {
> -    unsigned char c;
> -    char hc = tolower((int) key_str[i]);
> -    if (hc >= '0' && hc <= '9') {
> -      c = hc - '0';
> -    } else if (hc >= 'a' && hc <= 'f') {
> -      c = hc - 'a' + 0xa;
> -    } else {
> -      return MG_SSL_ERROR;
> -    }
> -    key_len = i / 2;
> -    key[key_len] <<= 4;
> -    key[key_len] |= c;
> -  }
> -  key_len++;
> -  DBG(("identity = '%s', key = (%u)", identity, (unsigned int) key_len));
> -  /* mbedTLS makes copies of psk and identity. */
> -  if (mbedtls_ssl_conf_psk(ctx->conf, (const unsigned char *) key, key_len,
> -                           (const unsigned char *) identity,
> -                           strlen(identity)) != 0) {
> -    return MG_SSL_ERROR;
> -  }
> -  return MG_SSL_OK;
> -}
> -#endif
> -
> -const char *mg_set_ssl(struct mg_connection *nc, const char *cert,
> -                       const char *ca_cert) {
> -  const char *err_msg = NULL;
> -  struct mg_ssl_if_conn_params params;
> -  memset(&params, 0, sizeof(params));
> -  params.cert = cert;
> -  params.ca_cert = ca_cert;
> -  if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
> -    return err_msg;
> -  }
> -  return NULL;
> -}
> -
> -/* Lazy RNG. Warning: it would be a bad idea to do this in production! */
> -#ifdef MG_SSL_MBED_DUMMY_RANDOM
> -int mg_ssl_if_mbed_random(void *ctx, unsigned char *buf, size_t len) {
> -  (void) ctx;
> -  while (len--) *buf++ = rand();
> -  return 0;
> -}
> -#endif
> -
> -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_MBEDTLS */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_uri.c"
> -#endif
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_uri.h" */
> -
> -/*
> - * scan string until encountering one of `seps`, keeping track of component
> - * boundaries in `res`.
> - *
> - * `p` will point to the char after the separator or it will be `end`.
> - */
> -static void parse_uri_component(const char **p, const char *end,
> -                                const char *seps, struct mg_str *res) {
> -  const char *q;
> -  res->p = *p;
> -  for (; *p < end; (*p)++) {
> -    for (q = seps; *q != '\0'; q++) {
> -      if (**p == *q) break;
> -    }
> -    if (*q != '\0') break;
> -  }
> -  res->len = (*p) - res->p;
> -  if (*p < end) (*p)++;
> -}
> -
> -int mg_parse_uri(const struct mg_str uri, struct mg_str *scheme,
> -                 struct mg_str *user_info, struct mg_str *host,
> -                 unsigned int *port, struct mg_str *path, struct mg_str *query,
> -                 struct mg_str *fragment) {
> -  struct mg_str rscheme = {0, 0}, ruser_info = {0, 0}, rhost = {0, 0},
> -                rpath = {0, 0}, rquery = {0, 0}, rfragment = {0, 0};
> -  unsigned int rport = 0;
> -  enum {
> -    P_START,
> -    P_SCHEME_OR_PORT,
> -    P_USER_INFO,
> -    P_HOST,
> -    P_PORT,
> -    P_REST
> -  } state = P_START;
> -
> -  const char *p = uri.p, *end = p + uri.len;
> -  while (p < end) {
> -    switch (state) {
> -      case P_START:
> -        /*
> -         * expecting on of:
> -         * - `scheme://xxxx`
> -         * - `xxxx:port`
> -         * - `[a:b:c]:port`
> -         * - `xxxx/path`
> -         */
> -        if (*p == '[') {
> -          state = P_HOST;
> -          break;
> -        }
> -        for (; p < end; p++) {
> -          if (*p == ':') {
> -            state = P_SCHEME_OR_PORT;
> -            break;
> -          } else if (*p == '/') {
> -            state = P_REST;
> -            break;
> -          }
> -        }
> -        if (state == P_START || state == P_REST) {
> -          rhost.p = uri.p;
> -          rhost.len = p - uri.p;
> -        }
> -        break;
> -      case P_SCHEME_OR_PORT:
> -        if (end - p >= 3 && strncmp(p, "://", 3) == 0) {
> -          rscheme.p = uri.p;
> -          rscheme.len = p - uri.p;
> -          state = P_USER_INFO;
> -          p += 3;
> -        } else {
> -          rhost.p = uri.p;
> -          rhost.len = p - uri.p;
> -          state = P_PORT;
> -        }
> -        break;
> -      case P_USER_INFO:
> -        ruser_info.p = p;
> -        for (; p < end; p++) {
> -          if (*p == '@' || *p == '[' || *p == '/') {
> -            break;
> -          }
> -        }
> -        if (p == end || *p == '/' || *p == '[') {
> -          /* backtrack and parse as host */
> -          p = ruser_info.p;
> -        }
> -        ruser_info.len = p - ruser_info.p;
> -        state = P_HOST;
> -        break;
> -      case P_HOST:
> -        if (*p == '@') p++;
> -        rhost.p = p;
> -        if (*p == '[') {
> -          int found = 0;
> -          for (; !found && p < end; p++) {
> -            found = (*p == ']');
> -          }
> -          if (!found) return -1;
> -        } else {
> -          for (; p < end; p++) {
> -            if (*p == ':' || *p == '/') break;
> -          }
> -        }
> -        rhost.len = p - rhost.p;
> -        if (p < end) {
> -          if (*p == ':') {
> -            state = P_PORT;
> -            break;
> -          } else if (*p == '/') {
> -            state = P_REST;
> -            break;
> -          }
> -        }
> -        break;
> -      case P_PORT:
> -        p++;
> -        for (; p < end; p++) {
> -          if (*p == '/') {
> -            state = P_REST;
> -            break;
> -          }
> -          rport *= 10;
> -          rport += *p - '0';
> -        }
> -        break;
> -      case P_REST:
> -        /* `p` points to separator. `path` includes the separator */
> -        parse_uri_component(&p, end, "?#", &rpath);
> -        if (p < end && *(p - 1) == '?') {
> -          parse_uri_component(&p, end, "#", &rquery);
> -        }
> -        parse_uri_component(&p, end, "", &rfragment);
> -        break;
> -    }
> -  }
> -
> -  if (scheme != 0) *scheme = rscheme;
> -  if (user_info != 0) *user_info = ruser_info;
> -  if (host != 0) *host = rhost;
> -  if (port != 0) *port = rport;
> -  if (path != 0) *path = rpath;
> -  if (query != 0) *query = rquery;
> -  if (fragment != 0) *fragment = rfragment;
> -
> -  return 0;
> -}
> -
> -/* Normalize the URI path. Remove/resolve "." and "..". */
> -int mg_normalize_uri_path(const struct mg_str *in, struct mg_str *out) {
> -  const char *s = in->p, *se = s + in->len;
> -  char *cp = (char *) out->p, *d;
> -
> -  if (in->len == 0 || *s != '/') {
> -    out->len = 0;
> -    return 0;
> -  }
> -
> -  d = cp;
> -
> -  while (s < se) {
> -    const char *next = s;
> -    struct mg_str component;
> -    parse_uri_component(&next, se, "/", &component);
> -    if (mg_vcmp(&component, ".") == 0) {
> -      /* Yum. */
> -    } else if (mg_vcmp(&component, "..") == 0) {
> -      /* Backtrack to previous slash. */
> -      if (d > cp + 1 && *(d - 1) == '/') d--;
> -      while (d > cp && *(d - 1) != '/') d--;
> -    } else {
> -      memmove(d, s, next - s);
> -      d += next - s;
> -    }
> -    s = next;
> -  }
> -  if (d == cp) *d++ = '/';
> -
> -  out->p = cp;
> -  out->len = d - cp;
> -  return 1;
> -}
> -
> -int mg_assemble_uri(const struct mg_str *scheme, const struct mg_str *user_info,
> -                    const struct mg_str *host, unsigned int port,
> -                    const struct mg_str *path, const struct mg_str *query,
> -                    const struct mg_str *fragment, int normalize_path,
> -                    struct mg_str *uri) {
> -  int result = -1;
> -  struct mbuf out;
> -  mbuf_init(&out, 0);
> -
> -  if (scheme != NULL && scheme->len > 0) {
> -    mbuf_append(&out, scheme->p, scheme->len);
> -    mbuf_append(&out, "://", 3);
> -  }
> -
> -  if (user_info != NULL && user_info->len > 0) {
> -    mbuf_append(&out, user_info->p, user_info->len);
> -    mbuf_append(&out, "@", 1);
> -  }
> -
> -  if (host != NULL && host->len > 0) {
> -    mbuf_append(&out, host->p, host->len);
> -  }
> -
> -  if (port != 0) {
> -    char port_str[20];
> -    int port_str_len = sprintf(port_str, ":%u", port);
> -    mbuf_append(&out, port_str, port_str_len);
> -  }
> -
> -  if (path != NULL && path->len > 0) {
> -    if (normalize_path) {
> -      struct mg_str npath = mg_strdup(*path);
> -      if (npath.len != path->len) goto out;
> -      if (!mg_normalize_uri_path(path, &npath)) {
> -        free((void *) npath.p);
> -        goto out;
> -      }
> -      mbuf_append(&out, npath.p, npath.len);
> -      free((void *) npath.p);
> -    } else {
> -      mbuf_append(&out, path->p, path->len);
> -    }
> -  } else if (normalize_path) {
> -    mbuf_append(&out, "/", 1);
> -  }
> -
> -  if (query != NULL && query->len > 0) {
> -    mbuf_append(&out, "?", 1);
> -    mbuf_append(&out, query->p, query->len);
> -  }
> -
> -  if (fragment != NULL && fragment->len > 0) {
> -    mbuf_append(&out, "#", 1);
> -    mbuf_append(&out, fragment->p, fragment->len);
> -  }
> -
> -  result = 0;
> -
> -out:
> -  if (result == 0) {
> -    uri->p = out.buf;
> -    uri->len = out.len;
> -  } else {
> -    mbuf_free(&out);
> -    uri->p = NULL;
> -    uri->len = 0;
> -  }
> -  return result;
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http.c"
> -#endif
> -
> -#if MG_ENABLE_HTTP
> -
> -/* Amalgamated: #include "common/cs_md5.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_util.h" */
> -
> -/* altbuf {{{ */
> -
> -/*
> - * Alternate buffer: fills the client-provided buffer with data; and if it's
> - * not large enough, allocates another buffer (via mbuf), similar to asprintf.
> - */
> -struct altbuf {
> -  struct mbuf m;
> -  char *user_buf;
> -  size_t len;
> -  size_t user_buf_size;
> -};
> -
> -/*
> - * Initializes altbuf; `buf`, `buf_size` is the client-provided buffer.
> - */
> -MG_INTERNAL void altbuf_init(struct altbuf *ab, char *buf, size_t buf_size) {
> -  mbuf_init(&ab->m, 0);
> -  ab->user_buf = buf;
> -  ab->user_buf_size = buf_size;
> -  ab->len = 0;
> -}
> -
> -/*
> - * Appends a single char to the altbuf.
> - */
> -MG_INTERNAL void altbuf_append(struct altbuf *ab, char c) {
> -  if (ab->len < ab->user_buf_size) {
> -    /* The data fits into the original buffer */
> -    ab->user_buf[ab->len++] = c;
> -  } else {
> -    /* The data can't fit into the original buffer, so write it to mbuf.  */
> -
> -    /*
> -     * First of all, see if that's the first byte which overflows the original
> -     * buffer: if so, copy the existing data from there to a newly allocated
> -     * mbuf.
> -     */
> -    if (ab->len > 0 && ab->m.len == 0) {
> -      mbuf_append(&ab->m, ab->user_buf, ab->len);
> -    }
> -
> -    mbuf_append(&ab->m, &c, 1);
> -    ab->len = ab->m.len;
> -  }
> -}
> -
> -/*
> - * Resets any data previously appended to altbuf.
> - */
> -MG_INTERNAL void altbuf_reset(struct altbuf *ab) {
> -  mbuf_free(&ab->m);
> -  ab->len = 0;
> -}
> -
> -/*
> - * Returns whether the additional buffer was allocated (and thus the data
> - * is in the mbuf, not the client-provided buffer)
> - */
> -MG_INTERNAL int altbuf_reallocated(struct altbuf *ab) {
> -  return ab->len > ab->user_buf_size;
> -}
> -
> -/*
> - * Returns the actual buffer with data, either the client-provided or a newly
> - * allocated one. If `trim` is non-zero, mbuf-backed buffer is trimmed first.
> - */
> -MG_INTERNAL char *altbuf_get_buf(struct altbuf *ab, int trim) {
> -  if (altbuf_reallocated(ab)) {
> -    if (trim) {
> -      mbuf_trim(&ab->m);
> -    }
> -    return ab->m.buf;
> -  } else {
> -    return ab->user_buf;
> -  }
> -}
> -
> -/* }}} */
> -
> -static const char *mg_version_header = "Mongoose/" MG_VERSION;
> -
> -enum mg_http_proto_data_type { DATA_NONE, DATA_FILE, DATA_PUT };
> -
> -struct mg_http_proto_data_file {
> -  FILE *fp;      /* Opened file. */
> -  int64_t cl;    /* Content-Length. How many bytes to send. */
> -  int64_t sent;  /* How many bytes have been already sent. */
> -  int keepalive; /* Keep connection open after sending. */
> -  enum mg_http_proto_data_type type;
> -};
> -
> -#if MG_ENABLE_HTTP_CGI
> -struct mg_http_proto_data_cgi {
> -  struct mg_connection *cgi_nc;
> -};
> -#endif
> -
> -struct mg_http_proto_data_chuncked {
> -  int64_t body_len; /* How many bytes of chunked body was reassembled. */
> -};
> -
> -struct mg_http_endpoint {
> -  struct mg_http_endpoint *next;
> -  struct mg_str uri_pattern; /* owned */
> -  char *auth_domain;         /* owned */
> -  char *auth_file;           /* owned */
> -
> -  mg_event_handler_t handler;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  void *user_data;
> -#endif
> -};
> -
> -enum mg_http_multipart_stream_state {
> -  MPS_BEGIN,
> -  MPS_WAITING_FOR_BOUNDARY,
> -  MPS_WAITING_FOR_CHUNK,
> -  MPS_GOT_BOUNDARY,
> -  MPS_FINALIZE,
> -  MPS_FINISHED
> -};
> -
> -struct mg_http_multipart_stream {
> -  const char *boundary;
> -  int boundary_len;
> -  const char *var_name;
> -  const char *file_name;
> -  void *user_data;
> -  enum mg_http_multipart_stream_state state;
> -  int processing_part;
> -  int data_avail;
> -};
> -
> -struct mg_reverse_proxy_data {
> -  struct mg_connection *linked_conn;
> -};
> -
> -struct mg_ws_proto_data {
> -  /*
> -   * Defragmented size of the frame so far.
> -   *
> -   * First byte of nc->recv_mbuf.buf is an op, the rest of the data is
> -   * defragmented data.
> -   */
> -  size_t reass_len;
> -};
> -
> -struct mg_http_proto_data {
> -#if MG_ENABLE_FILESYSTEM
> -  struct mg_http_proto_data_file file;
> -#endif
> -#if MG_ENABLE_HTTP_CGI
> -  struct mg_http_proto_data_cgi cgi;
> -#endif
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -  struct mg_http_multipart_stream mp_stream;
> -#endif
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -  struct mg_ws_proto_data ws_data;
> -#endif
> -  struct mg_http_proto_data_chuncked chunk;
> -  struct mg_http_endpoint *endpoints;
> -  mg_event_handler_t endpoint_handler;
> -  struct mg_reverse_proxy_data reverse_proxy_data;
> -  size_t rcvd; /* How many bytes we have received. */
> -};
> -
> -static void mg_http_proto_data_destructor(void *proto_data);
> -
> -struct mg_connection *mg_connect_http_base(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *scheme1, const char *scheme2,
> -    const char *scheme_ssl1, const char *scheme_ssl2, const char *url,
> -    struct mg_str *path, struct mg_str *user_info, struct mg_str *host);
> -
> -MG_INTERNAL struct mg_http_proto_data *mg_http_create_proto_data(
> -    struct mg_connection *c) {
> -  /* If we have proto data from previous connection, flush it. */
> -  if (c->proto_data != NULL) {
> -    void *pd = c->proto_data;
> -    c->proto_data = NULL;
> -    mg_http_proto_data_destructor(pd);
> -  }
> -  c->proto_data = MG_CALLOC(1, sizeof(struct mg_http_proto_data));
> -  c->proto_data_destructor = mg_http_proto_data_destructor;
> -  return (struct mg_http_proto_data *) c->proto_data;
> -}
> -
> -static struct mg_http_proto_data *mg_http_get_proto_data(
> -    struct mg_connection *c) {
> -  return (struct mg_http_proto_data *) c->proto_data;
> -}
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -static void mg_http_free_proto_data_mp_stream(
> -    struct mg_http_multipart_stream *mp) {
> -  MG_FREE((void *) mp->boundary);
> -  MG_FREE((void *) mp->var_name);
> -  MG_FREE((void *) mp->file_name);
> -  memset(mp, 0, sizeof(*mp));
> -}
> -#endif
> -
> -#if MG_ENABLE_FILESYSTEM
> -static void mg_http_free_proto_data_file(struct mg_http_proto_data_file *d) {
> -  if (d != NULL) {
> -    if (d->fp != NULL) {
> -      fclose(d->fp);
> -    }
> -    memset(d, 0, sizeof(struct mg_http_proto_data_file));
> -  }
> -}
> -#endif
> -
> -static void mg_http_free_proto_data_endpoints(struct mg_http_endpoint **ep) {
> -  struct mg_http_endpoint *current = *ep;
> -
> -  while (current != NULL) {
> -    struct mg_http_endpoint *tmp = current->next;
> -    MG_FREE((void *) current->uri_pattern.p);
> -    MG_FREE((void *) current->auth_domain);
> -    MG_FREE((void *) current->auth_file);
> -    MG_FREE(current);
> -    current = tmp;
> -  }
> -
> -  *ep = NULL;
> -}
> -
> -static void mg_http_free_reverse_proxy_data(struct mg_reverse_proxy_data *rpd) {
> -  if (rpd->linked_conn != NULL) {
> -    /*
> -     * Connection has linked one, we have to unlink & close it
> -     * since _this_ connection is going to die and
> -     * it doesn't make sense to keep another one
> -     */
> -    struct mg_http_proto_data *pd = mg_http_get_proto_data(rpd->linked_conn);
> -    if (pd->reverse_proxy_data.linked_conn != NULL) {
> -      pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE;
> -      pd->reverse_proxy_data.linked_conn = NULL;
> -    }
> -    rpd->linked_conn = NULL;
> -  }
> -}
> -
> -static void mg_http_proto_data_destructor(void *proto_data) {
> -  struct mg_http_proto_data *pd = (struct mg_http_proto_data *) proto_data;
> -#if MG_ENABLE_FILESYSTEM
> -  mg_http_free_proto_data_file(&pd->file);
> -#endif
> -#if MG_ENABLE_HTTP_CGI
> -  mg_http_free_proto_data_cgi(&pd->cgi);
> -#endif
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -  mg_http_free_proto_data_mp_stream(&pd->mp_stream);
> -#endif
> -  mg_http_free_proto_data_endpoints(&pd->endpoints);
> -  mg_http_free_reverse_proxy_data(&pd->reverse_proxy_data);
> -  MG_FREE(proto_data);
> -}
> -
> -#if MG_ENABLE_FILESYSTEM
> -
> -#define MIME_ENTRY(_ext, _type) \
> -  { _ext, sizeof(_ext) - 1, _type }
> -static const struct {
> -  const char *extension;
> -  size_t ext_len;
> -  const char *mime_type;
> -} mg_static_builtin_mime_types[] = {
> -    MIME_ENTRY("html", "text/html"),
> -    MIME_ENTRY("html", "text/html"),
> -    MIME_ENTRY("htm", "text/html"),
> -    MIME_ENTRY("shtm", "text/html"),
> -    MIME_ENTRY("shtml", "text/html"),
> -    MIME_ENTRY("css", "text/css"),
> -    MIME_ENTRY("js", "application/x-javascript"),
> -    MIME_ENTRY("ico", "image/x-icon"),
> -    MIME_ENTRY("gif", "image/gif"),
> -    MIME_ENTRY("jpg", "image/jpeg"),
> -    MIME_ENTRY("jpeg", "image/jpeg"),
> -    MIME_ENTRY("png", "image/png"),
> -    MIME_ENTRY("svg", "image/svg+xml"),
> -    MIME_ENTRY("txt", "text/plain"),
> -    MIME_ENTRY("torrent", "application/x-bittorrent"),
> -    MIME_ENTRY("wav", "audio/x-wav"),
> -    MIME_ENTRY("mp3", "audio/x-mp3"),
> -    MIME_ENTRY("mid", "audio/mid"),
> -    MIME_ENTRY("m3u", "audio/x-mpegurl"),
> -    MIME_ENTRY("ogg", "application/ogg"),
> -    MIME_ENTRY("ram", "audio/x-pn-realaudio"),
> -    MIME_ENTRY("xml", "text/xml"),
> -    MIME_ENTRY("ttf", "application/x-font-ttf"),
> -    MIME_ENTRY("json", "application/json"),
> -    MIME_ENTRY("xslt", "application/xml"),
> -    MIME_ENTRY("xsl", "application/xml"),
> -    MIME_ENTRY("ra", "audio/x-pn-realaudio"),
> -    MIME_ENTRY("doc", "application/msword"),
> -    MIME_ENTRY("exe", "application/octet-stream"),
> -    MIME_ENTRY("zip", "application/x-zip-compressed"),
> -    MIME_ENTRY("xls", "application/excel"),
> -    MIME_ENTRY("tgz", "application/x-tar-gz"),
> -    MIME_ENTRY("tar", "application/x-tar"),
> -    MIME_ENTRY("gz", "application/x-gunzip"),
> -    MIME_ENTRY("arj", "application/x-arj-compressed"),
> -    MIME_ENTRY("rar", "application/x-rar-compressed"),
> -    MIME_ENTRY("rtf", "application/rtf"),
> -    MIME_ENTRY("pdf", "application/pdf"),
> -    MIME_ENTRY("swf", "application/x-shockwave-flash"),
> -    MIME_ENTRY("mpg", "video/mpeg"),
> -    MIME_ENTRY("webm", "video/webm"),
> -    MIME_ENTRY("mpeg", "video/mpeg"),
> -    MIME_ENTRY("mov", "video/quicktime"),
> -    MIME_ENTRY("mp4", "video/mp4"),
> -    MIME_ENTRY("m4v", "video/x-m4v"),
> -    MIME_ENTRY("asf", "video/x-ms-asf"),
> -    MIME_ENTRY("avi", "video/x-msvideo"),
> -    MIME_ENTRY("bmp", "image/bmp"),
> -    {NULL, 0, NULL},
> -};
> -
> -static struct mg_str mg_get_mime_types_entry(struct mg_str path) {
> -  size_t i;
> -  for (i = 0; mg_static_builtin_mime_types[i].extension != NULL; i++) {
> -    if (path.len < mg_static_builtin_mime_types[i].ext_len + 1) continue;
> -    struct mg_str ext = MG_MK_STR_N(mg_static_builtin_mime_types[i].extension,
> -                                    mg_static_builtin_mime_types[i].ext_len);
> -    struct mg_str pext = MG_MK_STR_N(path.p + (path.len - ext.len), ext.len);
> -    if (pext.p[-1] == '.' && mg_strcasecmp(ext, pext) == 0) {
> -      return mg_mk_str(mg_static_builtin_mime_types[i].mime_type);
> -    }
> -  }
> -  return mg_mk_str(NULL);
> -}
> -
> -MG_INTERNAL int mg_get_mime_type_encoding(
> -    struct mg_str path, struct mg_str *type, struct mg_str *encoding,
> -    const struct mg_serve_http_opts *opts) {
> -  const char *ext, *overrides;
> -  struct mg_str k, v;
> -
> -  overrides = opts->custom_mime_types;
> -  while ((overrides = mg_next_comma_list_entry(overrides, &k, &v)) != NULL) {
> -    ext = path.p + (path.len - k.len);
> -    if (path.len > k.len && mg_vcasecmp(&k, ext) == 0) {
> -      *type = v;
> -      return 1;
> -    }
> -  }
> -
> -  *type = mg_get_mime_types_entry(path);
> -
> -  /* Check for .html.gz, .js.gz, etc. */
> -  if (mg_vcmp(type, "application/x-gunzip") == 0) {
> -    struct mg_str path2 = mg_mk_str_n(path.p, path.len - 3);
> -    struct mg_str type2 = mg_get_mime_types_entry(path2);
> -    LOG(LL_ERROR, ("'%.*s' '%.*s' '%.*s'", (int) path.len, path.p,
> -                   (int) path2.len, path2.p, (int) type2.len, type2.p));
> -    if (type2.len > 0) {
> -      *type = type2;
> -      *encoding = mg_mk_str("gzip");
> -    }
> -  }
> -
> -  return (type->len > 0);
> -}
> -#endif
> -
> -/*
> - * Check whether full request is buffered. Return:
> - *   -1  if request is malformed
> - *    0  if request is not yet fully buffered
> - *   >0  actual request length, including last \r\n\r\n
> - */
> -static int mg_http_get_request_len(const char *s, int buf_len) {
> -  const unsigned char *buf = (unsigned char *) s;
> -  int i;
> -
> -  for (i = 0; i < buf_len; i++) {
> -    if (!isprint(buf[i]) && buf[i] != '\r' && buf[i] != '\n' && buf[i] < 128) {
> -      return -1;
> -    } else if (buf[i] == '\n' && i + 1 < buf_len && buf[i + 1] == '\n') {
> -      return i + 2;
> -    } else if (buf[i] == '\n' && i + 2 < buf_len && buf[i + 1] == '\r' &&
> -               buf[i + 2] == '\n') {
> -      return i + 3;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -static const char *mg_http_parse_headers(const char *s, const char *end,
> -                                         int len, struct http_message *req) {
> -  int i = 0;
> -  while (i < (int) ARRAY_SIZE(req->header_names) - 1) {
> -    struct mg_str *k = &req->header_names[i], *v = &req->header_values[i];
> -
> -    s = mg_skip(s, end, ": ", k);
> -    s = mg_skip(s, end, "\r\n", v);
> -
> -    while (v->len > 0 && v->p[v->len - 1] == ' ') {
> -      v->len--; /* Trim trailing spaces in header value */
> -    }
> -
> -    /*
> -     * If header value is empty - skip it and go to next (if any).
> -     * NOTE: Do not add it to headers_values because such addition changes API
> -     * behaviour
> -     */
> -    if (k->len != 0 && v->len == 0) {
> -      continue;
> -    }
> -
> -    if (k->len == 0 || v->len == 0) {
> -      k->p = v->p = NULL;
> -      k->len = v->len = 0;
> -      break;
> -    }
> -
> -    if (!mg_ncasecmp(k->p, "Content-Length", 14)) {
> -      req->body.len = (size_t) to64(v->p);
> -      req->message.len = len + req->body.len;
> -    }
> -
> -    i++;
> -  }
> -
> -  return s;
> -}
> -
> -int mg_parse_http(const char *s, int n, struct http_message *hm, int is_req) {
> -  const char *end, *qs;
> -  int len = mg_http_get_request_len(s, n);
> -
> -  if (len <= 0) return len;
> -
> -  memset(hm, 0, sizeof(*hm));
> -  hm->message.p = s;
> -  hm->body.p = s + len;
> -  hm->message.len = hm->body.len = (size_t) ~0;
> -  end = s + len;
> -
> -  /* Request is fully buffered. Skip leading whitespaces. */
> -  while (s < end && isspace(*(unsigned char *) s)) s++;
> -
> -  if (is_req) {
> -    /* Parse request line: method, URI, proto */
> -    s = mg_skip(s, end, " ", &hm->method);
> -    s = mg_skip(s, end, " ", &hm->uri);
> -    s = mg_skip(s, end, "\r\n", &hm->proto);
> -    if (hm->uri.p <= hm->method.p || hm->proto.p <= hm->uri.p) return -1;
> -
> -    /* If URI contains '?' character, initialize query_string */
> -    if ((qs = (char *) memchr(hm->uri.p, '?', hm->uri.len)) != NULL) {
> -      hm->query_string.p = qs + 1;
> -      hm->query_string.len = &hm->uri.p[hm->uri.len] - (qs + 1);
> -      hm->uri.len = qs - hm->uri.p;
> -    }
> -  } else {
> -    s = mg_skip(s, end, " ", &hm->proto);
> -    if (end - s < 4 || s[0] < '0' || s[0] > '9' || s[3] != ' ') return -1;
> -    hm->resp_code = atoi(s);
> -    if (hm->resp_code < 100 || hm->resp_code >= 600) return -1;
> -    s += 4;
> -    s = mg_skip(s, end, "\r\n", &hm->resp_status_msg);
> -  }
> -
> -  s = mg_http_parse_headers(s, end, len, hm);
> -
> -  /*
> -   * mg_parse_http() is used to parse both HTTP requests and HTTP
> -   * responses. If HTTP response does not have Content-Length set, then
> -   * body is read until socket is closed, i.e. body.len is infinite (~0).
> -   *
> -   * For HTTP requests though, according to
> -   * http://tools.ietf.org/html/rfc7231#section-8.1.3,
> -   * only POST and PUT methods have defined body semantics.
> -   * Therefore, if Content-Length is not specified and methods are
> -   * not one of PUT or POST, set body length to 0.
> -   *
> -   * So,
> -   * if it is HTTP request, and Content-Length is not set,
> -   * and method is not (PUT or POST) then reset body length to zero.
> -   */
> -  if (hm->body.len == (size_t) ~0 && is_req &&
> -      mg_vcasecmp(&hm->method, "PUT") != 0 &&
> -      mg_vcasecmp(&hm->method, "POST") != 0) {
> -    hm->body.len = 0;
> -    hm->message.len = len;
> -  }
> -
> -  return len;
> -}
> -
> -struct mg_str *mg_get_http_header(struct http_message *hm, const char *name) {
> -  size_t i, len = strlen(name);
> -
> -  for (i = 0; hm->header_names[i].len > 0; i++) {
> -    struct mg_str *h = &hm->header_names[i], *v = &hm->header_values[i];
> -    if (h->p != NULL && h->len == len && !mg_ncasecmp(h->p, name, len))
> -      return v;
> -  }
> -
> -  return NULL;
> -}
> -
> -#if MG_ENABLE_FILESYSTEM
> -static void mg_http_transfer_file_data(struct mg_connection *nc) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  char buf[MG_MAX_HTTP_SEND_MBUF];
> -  size_t n = 0, to_read = 0, left = (size_t)(pd->file.cl - pd->file.sent);
> -
> -  if (pd->file.type == DATA_FILE) {
> -    struct mbuf *io = &nc->send_mbuf;
> -    if (io->len >= MG_MAX_HTTP_SEND_MBUF) {
> -      to_read = 0;
> -    } else {
> -      to_read = MG_MAX_HTTP_SEND_MBUF - io->len;
> -    }
> -    if (to_read > left) {
> -      to_read = left;
> -    }
> -    if (to_read > 0) {
> -      n = mg_fread(buf, 1, to_read, pd->file.fp);
> -      if (n > 0) {
> -        mg_send(nc, buf, n);
> -        pd->file.sent += n;
> -        DBG(("%p sent %d (total %d)", nc, (int) n, (int) pd->file.sent));
> -      }
> -    } else {
> -      /* Rate-limited */
> -    }
> -    if (pd->file.sent >= pd->file.cl) {
> -      LOG(LL_DEBUG, ("%p done, %d bytes, ka %d", nc, (int) pd->file.sent,
> -                     pd->file.keepalive));
> -      if (!pd->file.keepalive) nc->flags |= MG_F_SEND_AND_CLOSE;
> -      mg_http_free_proto_data_file(&pd->file);
> -    }
> -  } else if (pd->file.type == DATA_PUT) {
> -    struct mbuf *io = &nc->recv_mbuf;
> -    size_t to_write = left <= 0 ? 0 : left < io->len ? (size_t) left : io->len;
> -    size_t n1 = mg_fwrite(io->buf, 1, to_write, pd->file.fp);
> -    if (n1 > 0) {
> -      mbuf_remove(io, n1);
> -      pd->file.sent += n1;
> -    }
> -    if (n1 == 0 || pd->file.sent >= pd->file.cl) {
> -      if (!pd->file.keepalive) nc->flags |= MG_F_SEND_AND_CLOSE;
> -      mg_http_free_proto_data_file(&pd->file);
> -    }
> -  }
> -#if MG_ENABLE_HTTP_CGI
> -  else if (pd->cgi.cgi_nc != NULL) {
> -    /* This is POST data that needs to be forwarded to the CGI process */
> -    if (pd->cgi.cgi_nc != NULL) {
> -      mg_forward(nc, pd->cgi.cgi_nc);
> -    } else {
> -      nc->flags |= MG_F_SEND_AND_CLOSE;
> -    }
> -  }
> -#endif
> -}
> -#endif /* MG_ENABLE_FILESYSTEM */
> -
> -/*
> - * Parse chunked-encoded buffer. Return 0 if the buffer is not encoded, or
> - * if it's incomplete. If the chunk is fully buffered, return total number of
> - * bytes in a chunk, and store data in `data`, `data_len`.
> - */
> -static size_t mg_http_parse_chunk(char *buf, size_t len, char **chunk_data,
> -                                  size_t *chunk_len) {
> -  unsigned char *s = (unsigned char *) buf;
> -  size_t n = 0; /* scanned chunk length */
> -  size_t i = 0; /* index in s */
> -
> -  /* Scan chunk length. That should be a hexadecimal number. */
> -  while (i < len && isxdigit(s[i])) {
> -    n *= 16;
> -    n += (s[i] >= '0' && s[i] <= '9') ? s[i] - '0' : tolower(s[i]) - 'a' + 10;
> -    i++;
> -    if (i > 6) {
> -      /* Chunk size is unreasonable. */
> -      return 0;
> -    }
> -  }
> -
> -  /* Skip new line */
> -  if (i == 0 || i + 2 > len || s[i] != '\r' || s[i + 1] != '\n') {
> -    return 0;
> -  }
> -  i += 2;
> -
> -  /* Record where the data is */
> -  *chunk_data = (char *) s + i;
> -  *chunk_len = n;
> -
> -  /* Skip data */
> -  i += n;
> -
> -  /* Skip new line */
> -  if (i == 0 || i + 2 > len || s[i] != '\r' || s[i + 1] != '\n') {
> -    return 0;
> -  }
> -  return i + 2;
> -}
> -
> -MG_INTERNAL size_t mg_handle_chunked(struct mg_connection *nc,
> -                                     struct http_message *hm, char *buf,
> -                                     size_t blen) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  char *data;
> -  size_t i, n, data_len, body_len, zero_chunk_received = 0;
> -  /* Find out piece of received data that is not yet reassembled */
> -  body_len = (size_t) pd->chunk.body_len;
> -  assert(blen >= body_len);
> -
> -  /* Traverse all fully buffered chunks */
> -  for (i = body_len;
> -       (n = mg_http_parse_chunk(buf + i, blen - i, &data, &data_len)) > 0;
> -       i += n) {
> -    /* Collapse chunk data to the rest of HTTP body */
> -    memmove(buf + body_len, data, data_len);
> -    body_len += data_len;
> -    hm->body.len = body_len;
> -
> -    if (data_len == 0) {
> -      zero_chunk_received = 1;
> -      i += n;
> -      break;
> -    }
> -  }
> -
> -  if (i > body_len) {
> -    /* Shift unparsed content to the parsed body */
> -    assert(i <= blen);
> -    memmove(buf + body_len, buf + i, blen - i);
> -    memset(buf + body_len + blen - i, 0, i - body_len);
> -    nc->recv_mbuf.len -= i - body_len;
> -    pd->chunk.body_len = body_len;
> -
> -    /* Send MG_EV_HTTP_CHUNK event */
> -    nc->flags &= ~MG_F_DELETE_CHUNK;
> -    mg_call(nc, nc->handler, nc->user_data, MG_EV_HTTP_CHUNK, hm);
> -
> -    /* Delete processed data if user set MG_F_DELETE_CHUNK flag */
> -    if (nc->flags & MG_F_DELETE_CHUNK) {
> -      memset(buf, 0, body_len);
> -      memmove(buf, buf + body_len, blen - i);
> -      nc->recv_mbuf.len -= body_len;
> -      hm->body.len = 0;
> -      pd->chunk.body_len = 0;
> -    }
> -
> -    if (zero_chunk_received) {
> -      /* Total message size is len(body) + len(headers) */
> -      hm->message.len =
> -          (size_t) pd->chunk.body_len + blen - i + (hm->body.p - hm->message.p);
> -    }
> -  }
> -
> -  return body_len;
> -}
> -
> -static struct mg_http_endpoint *mg_http_get_endpoint_handler(struct mg_connection *nc,
> -                                                      struct mg_str *uri_path) {
> -  struct mg_http_proto_data *pd;
> -  struct mg_http_endpoint *ret = NULL;
> -  int matched, matched_max = 0;
> -  struct mg_http_endpoint *ep;
> -
> -  if (nc == NULL) return NULL;
> -
> -  pd = mg_http_get_proto_data(nc);
> -
> -  if (pd == NULL) return NULL;
> -
> -  ep = pd->endpoints;
> -  while (ep != NULL) {
> -    if ((matched = mg_match_prefix_n(ep->uri_pattern, *uri_path)) > 0) {
> -      if (matched > matched_max) {
> -        /* Looking for the longest suitable handler */
> -        ret = ep;
> -        matched_max = matched;
> -      }
> -    }
> -
> -    ep = ep->next;
> -  }
> -
> -  return ret;
> -}
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -static void mg_http_multipart_continue(struct mg_connection *nc);
> -
> -static void mg_http_multipart_begin(struct mg_connection *nc,
> -                                    struct http_message *hm, int req_len);
> -
> -#endif
> -
> -static void mg_http_call_endpoint_handler(struct mg_connection *nc, int ev,
> -                                          struct http_message *hm);
> -
> -static void deliver_chunk(struct mg_connection *c, struct http_message *hm,
> -                          int req_len) {
> -  /* Incomplete message received. Send MG_EV_HTTP_CHUNK event */
> -  hm->body.len = c->recv_mbuf.len - req_len;
> -  c->flags &= ~MG_F_DELETE_CHUNK;
> -  mg_call(c, c->handler, c->user_data, MG_EV_HTTP_CHUNK, hm);
> -  /* Delete processed data if user set MG_F_DELETE_CHUNK flag */
> -  if (c->flags & MG_F_DELETE_CHUNK) c->recv_mbuf.len = req_len;
> -}
> -
> -/*
> - * lx106 compiler has a bug (TODO(mkm) report and insert tracking bug here)
> - * If a big structure is declared in a big function, lx106 gcc will make it
> - * even bigger (round up to 4k, from 700 bytes of actual size).
> - */
> -#ifdef __xtensa__
> -static void mg_http_handler2(struct mg_connection *nc, int ev,
> -                             void *ev_data MG_UD_ARG(void *user_data),
> -                             struct http_message *hm) __attribute__((noinline));
> -
> -void mg_http_handler(struct mg_connection *nc, int ev,
> -                     void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct http_message hm;
> -  mg_http_handler2(nc, ev, ev_data MG_UD_ARG(user_data), &hm);
> -}
> -
> -static void mg_http_handler2(struct mg_connection *nc, int ev,
> -                             void *ev_data MG_UD_ARG(void *user_data),
> -                             struct http_message *hm) {
> -#else  /* !__XTENSA__ */
> -static void mg_http_handler(struct mg_connection *nc, int ev,
> -                     void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct http_message shm, *hm = &shm;
> -#endif /* __XTENSA__ */
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  struct mbuf *io = &nc->recv_mbuf;
> -  int req_len;
> -  const int is_req = (nc->listener != NULL);
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -  struct mg_str *vec;
> -#endif
> -  if (ev == MG_EV_CLOSE) {
> -#if MG_ENABLE_HTTP_CGI
> -    /* Close associated CGI forwarder connection */
> -    if (pd != NULL && pd->cgi.cgi_nc != NULL) {
> -      pd->cgi.cgi_nc->user_data = NULL;
> -      pd->cgi.cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    }
> -#endif
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -    if (pd != NULL && pd->mp_stream.boundary != NULL) {
> -      /*
> -       * Multipart message is in progress, but connection is closed.
> -       * Finish part and request with an error flag.
> -       */
> -      struct mg_http_multipart_part mp;
> -      memset(&mp, 0, sizeof(mp));
> -      mp.status = -1;
> -      mp.user_data = pd->mp_stream.user_data;
> -      mp.var_name = pd->mp_stream.var_name;
> -      mp.file_name = pd->mp_stream.file_name;
> -      mg_call(nc, (pd->endpoint_handler ? pd->endpoint_handler : nc->handler),
> -              nc->user_data, MG_EV_HTTP_PART_END, &mp);
> -      mp.var_name = NULL;
> -      mp.file_name = NULL;
> -      mg_call(nc, (pd->endpoint_handler ? pd->endpoint_handler : nc->handler),
> -              nc->user_data, MG_EV_HTTP_MULTIPART_REQUEST_END, &mp);
> -    } else
> -#endif
> -        if (io->len > 0 &&
> -            (req_len = mg_parse_http(io->buf, io->len, hm, is_req)) > 0) {
> -      /*
> -       * For HTTP messages without Content-Length, always send HTTP message
> -       * before MG_EV_CLOSE message.
> -       */
> -      int ev2 = is_req ? MG_EV_HTTP_REQUEST : MG_EV_HTTP_REPLY;
> -      hm->message.len = io->len;
> -      hm->body.len = io->buf + io->len - hm->body.p;
> -      deliver_chunk(nc, hm, req_len);
> -      mg_http_call_endpoint_handler(nc, ev2, hm);
> -    }
> -    if (pd != NULL && pd->endpoint_handler != NULL &&
> -        pd->endpoint_handler != nc->handler) {
> -      mg_call(nc, pd->endpoint_handler, nc->user_data, ev, NULL);
> -    }
> -  }
> -
> -#if MG_ENABLE_FILESYSTEM
> -  if (pd != NULL && pd->file.fp != NULL) {
> -    mg_http_transfer_file_data(nc);
> -  }
> -#endif
> -
> -  mg_call(nc, nc->handler, nc->user_data, ev, ev_data);
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -  if (pd != NULL && pd->mp_stream.boundary != NULL &&
> -      (ev == MG_EV_RECV || ev == MG_EV_POLL)) {
> -    if (ev == MG_EV_RECV) {
> -      pd->rcvd += *(int *) ev_data;
> -      mg_http_multipart_continue(nc);
> -    } else if (pd->mp_stream.data_avail) {
> -      /* Try re-delivering the data. */
> -      mg_http_multipart_continue(nc);
> -    }
> -    return;
> -  }
> -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */
> -
> -  if (ev == MG_EV_RECV) {
> -    struct mg_str *s;
> -
> -  again:
> -    req_len = mg_parse_http(io->buf, io->len, hm, is_req);
> -
> -    if (req_len > 0) {
> -      /* New request - new proto data */
> -      pd = mg_http_create_proto_data(nc);
> -      pd->rcvd = io->len;
> -    }
> -
> -    if (req_len > 0 &&
> -        (s = mg_get_http_header(hm, "Transfer-Encoding")) != NULL &&
> -        mg_vcasecmp(s, "chunked") == 0) {
> -      mg_handle_chunked(nc, hm, io->buf + req_len, io->len - req_len);
> -    }
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -    if (req_len > 0 && (s = mg_get_http_header(hm, "Content-Type")) != NULL &&
> -        s->len >= 9 && strncmp(s->p, "multipart", 9) == 0) {
> -      mg_http_multipart_begin(nc, hm, req_len);
> -      mg_http_multipart_continue(nc);
> -      return;
> -    }
> -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */
> -
> -    /* TODO(alashkin): refactor this ifelseifelseifelseifelse */
> -    if ((req_len < 0 ||
> -         (req_len == 0 && io->len >= MG_MAX_HTTP_REQUEST_SIZE))) {
> -      DBG(("invalid request"));
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    } else if (req_len == 0) {
> -      /* Do nothing, request is not yet fully buffered */
> -    }
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -    else if (nc->listener == NULL && (nc->flags & MG_F_IS_WEBSOCKET)) {
> -      /* We're websocket client, got handshake response from server. */
> -      DBG(("%p WebSocket upgrade code %d", nc, hm->resp_code));
> -      if (hm->resp_code == 101 &&
> -          mg_get_http_header(hm, "Sec-WebSocket-Accept")) {
> -        /* TODO(lsm): check the validity of accept Sec-WebSocket-Accept */
> -        mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_HANDSHAKE_DONE,
> -                hm);
> -        mbuf_remove(io, req_len);
> -        nc->proto_handler = mg_ws_handler;
> -        mg_ws_handler(nc, MG_EV_RECV, ev_data MG_UD_ARG(user_data));
> -      } else {
> -        mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_HANDSHAKE_DONE,
> -                hm);
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        mbuf_remove(io, req_len);
> -      }
> -    } else if (nc->listener != NULL &&
> -               (vec = mg_get_http_header(hm, "Sec-WebSocket-Key")) != NULL) {
> -      struct mg_http_endpoint *ep;
> -
> -      /* This is a websocket request. Switch protocol handlers. */
> -      mbuf_remove(io, req_len);
> -      nc->proto_handler = mg_ws_handler;
> -      nc->flags |= MG_F_IS_WEBSOCKET;
> -
> -      /*
> -       * If we have a handler set up with mg_register_http_endpoint(),
> -       * deliver subsequent websocket events to this handler after the
> -       * protocol switch.
> -       */
> -      ep = mg_http_get_endpoint_handler(nc->listener, &hm->uri);
> -      if (ep != NULL) {
> -        nc->handler = ep->handler;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -        nc->user_data = ep->user_data;
> -#endif
> -      }
> -
> -      /* Send handshake */
> -      mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_HANDSHAKE_REQUEST,
> -              hm);
> -      if (!(nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_SEND_AND_CLOSE))) {
> -        if (nc->send_mbuf.len == 0) {
> -          mg_ws_handshake(nc, vec, hm);
> -        }
> -        mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_HANDSHAKE_DONE,
> -                hm);
> -        mg_ws_handler(nc, MG_EV_RECV, ev_data MG_UD_ARG(user_data));
> -      }
> -    }
> -#endif /* MG_ENABLE_HTTP_WEBSOCKET */
> -    else if (hm->message.len > pd->rcvd) {
> -      /* Not yet received all HTTP body, deliver MG_EV_HTTP_CHUNK */
> -      deliver_chunk(nc, hm, req_len);
> -      if (nc->recv_mbuf_limit > 0 && nc->recv_mbuf.len >= nc->recv_mbuf_limit) {
> -        LOG(LL_ERROR, ("%p recv buffer (%lu bytes) exceeds the limit "
> -                       "%lu bytes, and not drained, closing",
> -                       nc, (unsigned long) nc->recv_mbuf.len,
> -                       (unsigned long) nc->recv_mbuf_limit));
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      }
> -    } else {
> -      /* We did receive all HTTP body. */
> -      int request_done = 1;
> -      int trigger_ev = nc->listener ? MG_EV_HTTP_REQUEST : MG_EV_HTTP_REPLY;
> -      char addr[32];
> -      mg_sock_addr_to_str(&nc->sa, addr, sizeof(addr),
> -                          MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);
> -      DBG(("%p %s %.*s %.*s", nc, addr, (int) hm->method.len, hm->method.p,
> -           (int) hm->uri.len, hm->uri.p));
> -      deliver_chunk(nc, hm, req_len);
> -      /* Whole HTTP message is fully buffered, call event handler */
> -      mg_http_call_endpoint_handler(nc, trigger_ev, hm);
> -      mbuf_remove(io, hm->message.len);
> -      pd->rcvd -= hm->message.len;
> -#if MG_ENABLE_FILESYSTEM
> -      /* We don't have a generic mechanism of communicating that we are done
> -       * responding to a request (should probably add one). But if we are
> -       * serving
> -       * a file, we are definitely not done. */
> -      if (pd->file.fp != NULL) request_done = 0;
> -#endif
> -#if MG_ENABLE_HTTP_CGI
> -      /* If this is a CGI request, we are not done either. */
> -      if (pd->cgi.cgi_nc != NULL) request_done = 0;
> -#endif
> -      if (request_done && io->len > 0) goto again;
> -    }
> -  }
> -}
> -
> -static size_t mg_get_line_len(const char *buf, size_t buf_len) {
> -  size_t len = 0;
> -  while (len < buf_len && buf[len] != '\n') len++;
> -  return len == buf_len ? 0 : len + 1;
> -}
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -static void mg_http_multipart_begin(struct mg_connection *nc,
> -                                    struct http_message *hm, int req_len) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  struct mg_str *ct;
> -  struct mbuf *io = &nc->recv_mbuf;
> -
> -  char boundary_buf[100];
> -  char *boundary = boundary_buf;
> -  int boundary_len;
> -
> -  ct = mg_get_http_header(hm, "Content-Type");
> -  if (ct == NULL) {
> -    /* We need more data - or it isn't multipart mesage */
> -    goto exit_mp;
> -  }
> -
> -  /* Content-type should start with "multipart" */
> -  if (ct->len < 9 || strncmp(ct->p, "multipart", 9) != 0) {
> -    goto exit_mp;
> -  }
> -
> -  boundary_len =
> -      mg_http_parse_header2(ct, "boundary", &boundary, sizeof(boundary_buf));
> -  if (boundary_len == 0) {
> -    /*
> -     * Content type is multipart, but there is no boundary,
> -     * probably malformed request
> -     */
> -    nc->flags = MG_F_CLOSE_IMMEDIATELY;
> -    DBG(("invalid request"));
> -    goto exit_mp;
> -  }
> -
> -  /* If we reach this place - that is multipart request */
> -
> -  if (pd->mp_stream.boundary != NULL) {
> -    /*
> -     * Another streaming request was in progress,
> -     * looks like protocol error
> -     */
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  } else {
> -    struct mg_http_endpoint *ep = NULL;
> -    pd->mp_stream.state = MPS_BEGIN;
> -    pd->mp_stream.boundary = strdup(boundary);
> -    pd->mp_stream.boundary_len = strlen(boundary);
> -    pd->mp_stream.var_name = pd->mp_stream.file_name = NULL;
> -    pd->endpoint_handler = nc->handler;
> -
> -    ep = mg_http_get_endpoint_handler(nc->listener, &hm->uri);
> -    if (ep != NULL) {
> -      pd->endpoint_handler = ep->handler;
> -    }
> -
> -    mg_http_call_endpoint_handler(nc, MG_EV_HTTP_MULTIPART_REQUEST, hm);
> -
> -    mbuf_remove(io, req_len);
> -  }
> -exit_mp:
> -  if (boundary != boundary_buf) MG_FREE(boundary);
> -}
> -
> -#define CONTENT_DISPOSITION "Content-Disposition: "
> -
> -static size_t mg_http_multipart_call_handler(struct mg_connection *c, int ev,
> -                                             const char *data,
> -                                             size_t data_len) {
> -  struct mg_http_multipart_part mp;
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -  memset(&mp, 0, sizeof(mp));
> -
> -  mp.var_name = pd->mp_stream.var_name;
> -  mp.file_name = pd->mp_stream.file_name;
> -  mp.user_data = pd->mp_stream.user_data;
> -  mp.data.p = data;
> -  mp.data.len = data_len;
> -  mp.num_data_consumed = data_len;
> -  mg_call(c, pd->endpoint_handler, c->user_data, ev, &mp);
> -  pd->mp_stream.user_data = mp.user_data;
> -  pd->mp_stream.data_avail = (mp.num_data_consumed != data_len);
> -  return mp.num_data_consumed;
> -}
> -
> -static int mg_http_multipart_finalize(struct mg_connection *c) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -
> -  mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_END, NULL, 0);
> -  MG_FREE((void *) pd->mp_stream.file_name);
> -  pd->mp_stream.file_name = NULL;
> -  MG_FREE((void *) pd->mp_stream.var_name);
> -  pd->mp_stream.var_name = NULL;
> -  mg_http_multipart_call_handler(c, MG_EV_HTTP_MULTIPART_REQUEST_END, NULL, 0);
> -  mg_http_free_proto_data_mp_stream(&pd->mp_stream);
> -  pd->mp_stream.state = MPS_FINISHED;
> -
> -  return 1;
> -}
> -
> -static int mg_http_multipart_wait_for_boundary(struct mg_connection *c) {
> -  const char *boundary;
> -  struct mbuf *io = &c->recv_mbuf;
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -
> -  if (pd->mp_stream.boundary == NULL) {
> -    pd->mp_stream.state = MPS_FINALIZE;
> -    DBG(("Invalid request: boundary not initialized"));
> -    return 0;
> -  }
> -
> -  if ((int) io->len < pd->mp_stream.boundary_len + 2) {
> -    return 0;
> -  }
> -
> -  boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len);
> -  if (boundary != NULL) {
> -    const char *boundary_end = (boundary + pd->mp_stream.boundary_len);
> -    if (io->len - (boundary_end - io->buf) < 4) {
> -      return 0;
> -    }
> -    if (strncmp(boundary_end, "--\r\n", 4) == 0) {
> -      pd->mp_stream.state = MPS_FINALIZE;
> -      mbuf_remove(io, (boundary_end - io->buf) + 4);
> -    } else {
> -      pd->mp_stream.state = MPS_GOT_BOUNDARY;
> -    }
> -  } else {
> -    return 0;
> -  }
> -
> -  return 1;
> -}
> -
> -static void mg_http_parse_header_internal(struct mg_str *hdr,
> -                                          const char *var_name,
> -                                          struct altbuf *ab);
> -
> -static int mg_http_multipart_process_boundary(struct mg_connection *c) {
> -  int data_size;
> -  const char *boundary, *block_begin;
> -  struct mbuf *io = &c->recv_mbuf;
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -  struct altbuf ab_file_name, ab_var_name;
> -  int line_len;
> -  boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len);
> -  block_begin = boundary + pd->mp_stream.boundary_len + 2;
> -  data_size = io->len - (block_begin - io->buf);
> -
> -  altbuf_init(&ab_file_name, NULL, 0);
> -  altbuf_init(&ab_var_name, NULL, 0);
> -
> -  while (data_size > 0 &&
> -         (line_len = mg_get_line_len(block_begin, data_size)) != 0) {
> -    if (line_len > (int) sizeof(CONTENT_DISPOSITION) &&
> -        mg_ncasecmp(block_begin, CONTENT_DISPOSITION,
> -                    sizeof(CONTENT_DISPOSITION) - 1) == 0) {
> -      struct mg_str header;
> -
> -      header.p = block_begin + sizeof(CONTENT_DISPOSITION) - 1;
> -      header.len = line_len - sizeof(CONTENT_DISPOSITION) - 1;
> -
> -      altbuf_reset(&ab_var_name);
> -      mg_http_parse_header_internal(&header, "name", &ab_var_name);
> -
> -      altbuf_reset(&ab_file_name);
> -      mg_http_parse_header_internal(&header, "filename", &ab_file_name);
> -
> -      block_begin += line_len;
> -      data_size -= line_len;
> -
> -      continue;
> -    }
> -
> -    if (line_len == 2 && mg_ncasecmp(block_begin, "\r\n", 2) == 0) {
> -      mbuf_remove(io, block_begin - io->buf + 2);
> -
> -      if (pd->mp_stream.processing_part != 0) {
> -        mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_END, NULL, 0);
> -      }
> -
> -      /* Reserve 2 bytes for "\r\n" in file_name and var_name */
> -      altbuf_append(&ab_file_name, '\0');
> -      altbuf_append(&ab_file_name, '\0');
> -      altbuf_append(&ab_var_name, '\0');
> -      altbuf_append(&ab_var_name, '\0');
> -
> -      MG_FREE((void *) pd->mp_stream.file_name);
> -      pd->mp_stream.file_name = altbuf_get_buf(&ab_file_name, 1 /* trim */);
> -      MG_FREE((void *) pd->mp_stream.var_name);
> -      pd->mp_stream.var_name = altbuf_get_buf(&ab_var_name, 1 /* trim */);
> -
> -      mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_BEGIN, NULL, 0);
> -      pd->mp_stream.state = MPS_WAITING_FOR_CHUNK;
> -      pd->mp_stream.processing_part++;
> -      return 1;
> -    }
> -
> -    block_begin += line_len;
> -  }
> -
> -  pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY;
> -
> -  altbuf_reset(&ab_var_name);
> -  altbuf_reset(&ab_file_name);
> -
> -  return 0;
> -}
> -
> -static int mg_http_multipart_continue_wait_for_chunk(struct mg_connection *c) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -  struct mbuf *io = &c->recv_mbuf;
> -
> -  const char *boundary;
> -  if ((int) io->len < pd->mp_stream.boundary_len + 6 /* \r\n, --, -- */) {
> -    return 0;
> -  }
> -
> -  boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len);
> -  if (boundary == NULL) {
> -    int data_len = (io->len - (pd->mp_stream.boundary_len + 6));
> -    if (data_len > 0) {
> -      size_t consumed = mg_http_multipart_call_handler(
> -          c, MG_EV_HTTP_PART_DATA, io->buf, (size_t) data_len);
> -      mbuf_remove(io, consumed);
> -    }
> -    return 0;
> -  } else if (boundary != NULL) {
> -    size_t data_len = ((size_t)(boundary - io->buf) - 4);
> -    size_t consumed = mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_DATA,
> -                                                     io->buf, data_len);
> -    mbuf_remove(io, consumed);
> -    if (consumed == data_len) {
> -      mbuf_remove(io, 4);
> -      pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY;
> -      return 1;
> -    } else {
> -      return 0;
> -    }
> -  } else {
> -    return 0;
> -  }
> -}
> -
> -static void mg_http_multipart_continue(struct mg_connection *c) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(c);
> -  while (1) {
> -    switch (pd->mp_stream.state) {
> -      case MPS_BEGIN: {
> -        pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY;
> -        break;
> -      }
> -      case MPS_WAITING_FOR_BOUNDARY: {
> -        if (mg_http_multipart_wait_for_boundary(c) == 0) {
> -          return;
> -        }
> -        break;
> -      }
> -      case MPS_GOT_BOUNDARY: {
> -        if (mg_http_multipart_process_boundary(c) == 0) {
> -          return;
> -        }
> -        break;
> -      }
> -      case MPS_WAITING_FOR_CHUNK: {
> -        if (mg_http_multipart_continue_wait_for_chunk(c) == 0) {
> -          return;
> -        }
> -        break;
> -      }
> -      case MPS_FINALIZE: {
> -        if (mg_http_multipart_finalize(c) == 0) {
> -          return;
> -        }
> -        break;
> -      }
> -      case MPS_FINISHED: {
> -        return;
> -      }
> -    }
> -  }
> -}
> -
> -struct file_upload_state {
> -  char *lfn;
> -  size_t num_recd;
> -  FILE *fp;
> -};
> -
> -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */
> -
> -void mg_set_protocol_http_websocket(struct mg_connection *nc) {
> -  nc->proto_handler = mg_http_handler;
> -}
> -
> -static const char *mg_status_message(int status_code) {
> -  switch (status_code) {
> -    case 206:
> -      return "Partial Content";
> -    case 301:
> -      return "Moved";
> -    case 302:
> -      return "Found";
> -    case 400:
> -      return "Bad Request";
> -    case 401:
> -      return "Unauthorized";
> -    case 403:
> -      return "Forbidden";
> -    case 404:
> -      return "Not Found";
> -    case 416:
> -      return "Requested Range Not Satisfiable";
> -    case 418:
> -      return "I'm a teapot";
> -    case 500:
> -      return "Internal Server Error";
> -    case 502:
> -      return "Bad Gateway";
> -    case 503:
> -      return "Service Unavailable";
> -
> -#if MG_ENABLE_EXTRA_ERRORS_DESC
> -    case 100:
> -      return "Continue";
> -    case 101:
> -      return "Switching Protocols";
> -    case 102:
> -      return "Processing";
> -    case 200:
> -      return "OK";
> -    case 201:
> -      return "Created";
> -    case 202:
> -      return "Accepted";
> -    case 203:
> -      return "Non-Authoritative Information";
> -    case 204:
> -      return "No Content";
> -    case 205:
> -      return "Reset Content";
> -    case 207:
> -      return "Multi-Status";
> -    case 208:
> -      return "Already Reported";
> -    case 226:
> -      return "IM Used";
> -    case 300:
> -      return "Multiple Choices";
> -    case 303:
> -      return "See Other";
> -    case 304:
> -      return "Not Modified";
> -    case 305:
> -      return "Use Proxy";
> -    case 306:
> -      return "Switch Proxy";
> -    case 307:
> -      return "Temporary Redirect";
> -    case 308:
> -      return "Permanent Redirect";
> -    case 402:
> -      return "Payment Required";
> -    case 405:
> -      return "Method Not Allowed";
> -    case 406:
> -      return "Not Acceptable";
> -    case 407:
> -      return "Proxy Authentication Required";
> -    case 408:
> -      return "Request Timeout";
> -    case 409:
> -      return "Conflict";
> -    case 410:
> -      return "Gone";
> -    case 411:
> -      return "Length Required";
> -    case 412:
> -      return "Precondition Failed";
> -    case 413:
> -      return "Payload Too Large";
> -    case 414:
> -      return "URI Too Long";
> -    case 415:
> -      return "Unsupported Media Type";
> -    case 417:
> -      return "Expectation Failed";
> -    case 422:
> -      return "Unprocessable Entity";
> -    case 423:
> -      return "Locked";
> -    case 424:
> -      return "Failed Dependency";
> -    case 426:
> -      return "Upgrade Required";
> -    case 428:
> -      return "Precondition Required";
> -    case 429:
> -      return "Too Many Requests";
> -    case 431:
> -      return "Request Header Fields Too Large";
> -    case 451:
> -      return "Unavailable For Legal Reasons";
> -    case 501:
> -      return "Not Implemented";
> -    case 504:
> -      return "Gateway Timeout";
> -    case 505:
> -      return "HTTP Version Not Supported";
> -    case 506:
> -      return "Variant Also Negotiates";
> -    case 507:
> -      return "Insufficient Storage";
> -    case 508:
> -      return "Loop Detected";
> -    case 510:
> -      return "Not Extended";
> -    case 511:
> -      return "Network Authentication Required";
> -#endif /* MG_ENABLE_EXTRA_ERRORS_DESC */
> -
> -    default:
> -      return "OK";
> -  }
> -}
> -
> -static void mg_send_response_line_s(struct mg_connection *nc, int status_code,
> -                             const struct mg_str extra_headers) {
> -  mg_printf(nc, "HTTP/1.1 %d %s\r\n", status_code,
> -            mg_status_message(status_code));
> -#ifndef MG_HIDE_SERVER_INFO
> -  mg_printf(nc, "Server: %s\r\n", mg_version_header);
> -#endif
> -  if (extra_headers.len > 0) {
> -    mg_printf(nc, "%.*s\r\n", (int) extra_headers.len, extra_headers.p);
> -  }
> -}
> -
> -void mg_send_response_line(struct mg_connection *nc, int status_code,
> -                           const char *extra_headers) {
> -  mg_send_response_line_s(nc, status_code, mg_mk_str(extra_headers));
> -}
> -
> -void mg_http_send_redirect(struct mg_connection *nc, int status_code,
> -                           const struct mg_str location,
> -                           const struct mg_str extra_headers) {
> -  char bbody[100], *pbody = bbody;
> -  int bl = mg_asprintf(&pbody, sizeof(bbody),
> -                       "<p>Moved <a href='%.*s'>here</a>.\r\n",
> -                       (int) location.len, location.p);
> -  char bhead[150], *phead = bhead;
> -  mg_asprintf(&phead, sizeof(bhead),
> -              "Location: %.*s\r\n"
> -              "Content-Type: text/html\r\n"
> -              "Content-Length: %d\r\n"
> -              "Cache-Control: no-cache\r\n"
> -              "%.*s%s",
> -              (int) location.len, location.p, bl, (int) extra_headers.len,
> -              extra_headers.p, (extra_headers.len > 0 ? "\r\n" : ""));
> -  mg_send_response_line(nc, status_code, phead);
> -  if (phead != bhead) MG_FREE(phead);
> -  mg_send(nc, pbody, bl);
> -  if (pbody != bbody) MG_FREE(pbody);
> -}
> -
> -void mg_send_head(struct mg_connection *c, int status_code,
> -                  int64_t content_length, const char *extra_headers) {
> -  mg_send_response_line(c, status_code, extra_headers);
> -  if (content_length < 0) {
> -    mg_printf(c, "%s", "Transfer-Encoding: chunked\r\n");
> -  } else {
> -    mg_printf(c, "Content-Length: %" INT64_FMT "\r\n", content_length);
> -  }
> -  mg_send(c, "\r\n", 2);
> -}
> -
> -void mg_http_send_error(struct mg_connection *nc, int code,
> -                        const char *reason) {
> -  if (!reason) reason = mg_status_message(code);
> -  LOG(LL_DEBUG, ("%p %d %s", nc, code, reason));
> -  mg_send_head(nc, code, strlen(reason),
> -               "Content-Type: text/plain\r\nConnection: close");
> -  mg_send(nc, reason, strlen(reason));
> -  nc->flags |= MG_F_SEND_AND_CLOSE;
> -}
> -
> -#if MG_ENABLE_FILESYSTEM
> -static void mg_http_construct_etag(char *buf, size_t buf_len,
> -                                   const cs_stat_t *st) {
> -  snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"", (unsigned long) st->st_mtime,
> -           (int64_t) st->st_size);
> -}
> -
> -#ifndef WINCE
> -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t) {
> -  strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(t));
> -}
> -#else
> -/* Look wince_lib.c for WindowsCE implementation */
> -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t);
> -#endif
> -
> -static int mg_http_parse_range_header(const struct mg_str *header, int64_t *a,
> -                                      int64_t *b) {
> -  /*
> -   * There is no snscanf. Headers are not guaranteed to be NUL-terminated,
> -   * so we have this. Ugh.
> -   */
> -  int result;
> -  char *p = (char *) MG_MALLOC(header->len + 1);
> -  if (p == NULL) return 0;
> -  memcpy(p, header->p, header->len);
> -  p[header->len] = '\0';
> -  result = sscanf(p, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b);
> -  MG_FREE(p);
> -  return result;
> -}
> -
> -static void mg_http_serve_file_internal(struct mg_connection *nc,
> -                                 struct http_message *hm, const char *path,
> -                                 struct mg_str mime_type,
> -                                 struct mg_str encoding,
> -                                 struct mg_str extra_headers) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  cs_stat_t st;
> -  LOG(LL_DEBUG, ("%p [%s] %.*s %.*s", nc, path, (int) mime_type.len,
> -                 mime_type.p, (int) encoding.len, encoding.p));
> -  if (mg_stat(path, &st) != 0 || (pd->file.fp = mg_fopen(path, "rb")) == NULL) {
> -    int code, err = mg_get_errno();
> -    switch (err) {
> -      case EACCES:
> -        code = 403;
> -        break;
> -      case ENOENT:
> -        code = 404;
> -        break;
> -      default:
> -        code = 500;
> -    };
> -    mg_http_send_error(nc, code, "Open failed");
> -  } else {
> -    char etag[50], current_time[50], last_modified[50], range[70];
> -    time_t t = (time_t) mg_time();
> -    int64_t r1 = 0, r2 = 0, cl = st.st_size;
> -    struct mg_str *range_hdr = mg_get_http_header(hm, "Range");
> -    int n, status_code = 200;
> -
> -    /* Handle Range header */
> -    range[0] = '\0';
> -    if (range_hdr != NULL &&
> -        (n = mg_http_parse_range_header(range_hdr, &r1, &r2)) > 0 && r1 >= 0 &&
> -        r2 >= 0) {
> -      /* If range is specified like "400-", set second limit to content len */
> -      if (n == 1) {
> -        r2 = cl - 1;
> -      }
> -      if (r1 > r2 || r2 >= cl) {
> -        status_code = 416;
> -        cl = 0;
> -        snprintf(range, sizeof(range),
> -                 "Content-Range: bytes */%" INT64_FMT "\r\n",
> -                 (int64_t) st.st_size);
> -      } else {
> -        status_code = 206;
> -        cl = r2 - r1 + 1;
> -        snprintf(range, sizeof(range),
> -                 "Content-Range: bytes %" INT64_FMT "-%" INT64_FMT
> -                 "/%" INT64_FMT "\r\n",
> -                 r1, r1 + cl - 1, (int64_t) st.st_size);
> -#if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \
> -    _XOPEN_SOURCE >= 600
> -        fseeko(pd->file.fp, r1, SEEK_SET);
> -#else
> -        fseek(pd->file.fp, (long) r1, SEEK_SET);
> -#endif
> -      }
> -    }
> -
> -#if !MG_DISABLE_HTTP_KEEP_ALIVE
> -    {
> -      struct mg_str *conn_hdr = mg_get_http_header(hm, "Connection");
> -      if (conn_hdr != NULL) {
> -        pd->file.keepalive = (mg_vcasecmp(conn_hdr, "keep-alive") == 0);
> -      } else {
> -        pd->file.keepalive = (mg_vcmp(&hm->proto, "HTTP/1.1") == 0);
> -      }
> -    }
> -#endif
> -
> -    mg_http_construct_etag(etag, sizeof(etag), &st);
> -    mg_gmt_time_string(current_time, sizeof(current_time), &t);
> -    mg_gmt_time_string(last_modified, sizeof(last_modified), &st.st_mtime);
> -    mg_send_response_line_s(nc, status_code, extra_headers);
> -    mg_printf(nc,
> -              "Date: %s\r\n"
> -              "Last-Modified: %s\r\n"
> -              "Accept-Ranges: bytes\r\n"
> -              "Content-Type: %.*s\r\n"
> -              "Connection: %s\r\n"
> -              "Content-Length: %" SIZE_T_FMT
> -              "\r\n"
> -              "%s"
> -              "Etag: %s\r\n",
> -              current_time, last_modified, (int) mime_type.len, mime_type.p,
> -              (pd->file.keepalive ? "keep-alive" : "close"), (size_t) cl, range,
> -              etag);
> -    if (encoding.len > 0) {
> -      mg_printf(nc, "Content-Encoding: %.*s\r\n", (int) encoding.len,
> -                encoding.p);
> -    }
> -    mg_send(nc, "\r\n", 2);
> -    pd->file.cl = cl;
> -    pd->file.type = DATA_FILE;
> -    mg_http_transfer_file_data(nc);
> -  }
> -}
> -
> -void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm,
> -                        const char *path, const struct mg_str mime_type,
> -                        const struct mg_str extra_headers) {
> -  mg_http_serve_file_internal(nc, hm, path, mime_type, mg_mk_str(NULL),
> -                              extra_headers);
> -}
> -
> -static void mg_http_serve_file2(struct mg_connection *nc, const char *path,
> -                                struct http_message *hm,
> -                                struct mg_serve_http_opts *opts) {
> -#if MG_ENABLE_HTTP_SSI
> -  if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) > 0) {
> -    mg_handle_ssi_request(nc, hm, path, opts);
> -    return;
> -  }
> -#endif
> -  struct mg_str type = MG_NULL_STR, encoding = MG_NULL_STR;
> -  if (!mg_get_mime_type_encoding(mg_mk_str(path), &type, &encoding, opts)) {
> -    type = mg_mk_str("text/plain");
> -  }
> -  mg_http_serve_file_internal(nc, hm, path, type, encoding,
> -                              mg_mk_str(opts->extra_headers));
> -}
> -
> -#endif
> -
> -int mg_url_decode(const char *src, int src_len, char *dst, int dst_len,
> -                  int is_form_url_encoded) {
> -  int i, j, a, b;
> -#define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W')
> -
> -  for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++) {
> -    if (src[i] == '%') {
> -      if (i < src_len - 2 && isxdigit(*(const unsigned char *) (src + i + 1)) &&
> -          isxdigit(*(const unsigned char *) (src + i + 2))) {
> -        a = tolower(*(const unsigned char *) (src + i + 1));
> -        b = tolower(*(const unsigned char *) (src + i + 2));
> -        dst[j] = (char) ((HEXTOI(a) << 4) | HEXTOI(b));
> -        i += 2;
> -      } else {
> -        return -1;
> -      }
> -    } else if (is_form_url_encoded && src[i] == '+') {
> -      dst[j] = ' ';
> -    } else {
> -      dst[j] = src[i];
> -    }
> -  }
> -
> -  dst[j] = '\0'; /* Null-terminate the destination */
> -
> -  return i >= src_len ? j : -1;
> -}
> -
> -int mg_get_http_var(const struct mg_str *buf, const char *name, char *dst,
> -                    size_t dst_len) {
> -  const char *p, *e, *s;
> -  size_t name_len;
> -  int len;
> -
> -  /*
> -   * According to the documentation function returns negative
> -   * value in case of error. For debug purposes it returns:
> -   * -1 - src is wrong (NUUL)
> -   * -2 - dst is wrong (NULL)
> -   * -3 - failed to decode url or dst is to small
> -   * -4 - name does not exist
> -   */
> -  if (dst == NULL || dst_len == 0) {
> -    len = -2;
> -  } else if (buf->p == NULL || name == NULL || buf->len == 0) {
> -    len = -1;
> -    dst[0] = '\0';
> -  } else {
> -    name_len = strlen(name);
> -    e = buf->p + buf->len;
> -    len = -4;
> -    dst[0] = '\0';
> -
> -    for (p = buf->p; p + name_len < e; p++) {
> -      if ((p == buf->p || p[-1] == '&') && p[name_len] == '=' &&
> -          !mg_ncasecmp(name, p, name_len)) {
> -        p += name_len + 1;
> -        s = (const char *) memchr(p, '&', (size_t)(e - p));
> -        if (s == NULL) {
> -          s = e;
> -        }
> -        len = mg_url_decode(p, (size_t)(s - p), dst, dst_len, 1);
> -        /* -1 means: failed to decode or dst is too small */
> -        if (len == -1) {
> -          len = -3;
> -        }
> -        break;
> -      }
> -    }
> -  }
> -
> -  return len;
> -}
> -
> -void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len) {
> -  char chunk_size[50];
> -  int n;
> -
> -  n = snprintf(chunk_size, sizeof(chunk_size), "%lX\r\n", (unsigned long) len);
> -  mg_send(nc, chunk_size, n);
> -  mg_send(nc, buf, len);
> -  mg_send(nc, "\r\n", 2);
> -}
> -
> -void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...) {
> -  char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
> -  int len;
> -  va_list ap;
> -
> -  va_start(ap, fmt);
> -  len = mg_avprintf(&buf, sizeof(mem), fmt, ap);
> -  va_end(ap);
> -
> -  if (len >= 0) {
> -    mg_send_http_chunk(nc, buf, len);
> -  }
> -
> -  /* LCOV_EXCL_START */
> -  if (buf != mem && buf != NULL) {
> -    MG_FREE(buf);
> -  }
> -  /* LCOV_EXCL_STOP */
> -}
> -
> -void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...) {
> -  char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
> -  int i, j, len;
> -  va_list ap;
> -
> -  va_start(ap, fmt);
> -  len = mg_avprintf(&buf, sizeof(mem), fmt, ap);
> -  va_end(ap);
> -
> -  if (len >= 0) {
> -    for (i = j = 0; i < len; i++) {
> -      if (buf[i] == '<' || buf[i] == '>') {
> -        mg_send(nc, buf + j, i - j);
> -        mg_send(nc, buf[i] == '<' ? "&lt;" : "&gt;", 4);
> -        j = i + 1;
> -      }
> -    }
> -    mg_send(nc, buf + j, i - j);
> -  }
> -
> -  /* LCOV_EXCL_START */
> -  if (buf != mem && buf != NULL) {
> -    MG_FREE(buf);
> -  }
> -  /* LCOV_EXCL_STOP */
> -}
> -
> -static void mg_http_parse_header_internal(struct mg_str *hdr,
> -                                          const char *var_name,
> -                                          struct altbuf *ab) {
> -  int ch = ' ', ch1 = ',', ch2 = ';', n = strlen(var_name);
> -  const char *p, *end = hdr ? hdr->p + hdr->len : NULL, *s = NULL;
> -
> -  /* Find where variable starts */
> -  for (s = hdr->p; s != NULL && s + n < end; s++) {
> -    if ((s == hdr->p || s[-1] == ch || s[-1] == ch1 || s[-1] == ';') &&
> -        s[n] == '=' && !strncmp(s, var_name, n))
> -      break;
> -  }
> -
> -  if (s != NULL && &s[n + 1] < end) {
> -    s += n + 1;
> -    if (*s == '"' || *s == '\'') {
> -      ch = ch1 = ch2 = *s++;
> -    }
> -    p = s;
> -    while (p < end && p[0] != ch && p[0] != ch1 && p[0] != ch2) {
> -      if (ch != ' ' && p[0] == '\\' && p[1] == ch) p++;
> -      altbuf_append(ab, *p++);
> -    }
> -
> -    if (ch != ' ' && *p != ch) {
> -      altbuf_reset(ab);
> -    }
> -  }
> -
> -  /* If there is some data, append a NUL. */
> -  if (ab->len > 0) {
> -    altbuf_append(ab, '\0');
> -  }
> -}
> -
> -int mg_http_parse_header2(struct mg_str *hdr, const char *var_name, char **buf,
> -                          size_t buf_size) {
> -  struct altbuf ab;
> -  altbuf_init(&ab, *buf, buf_size);
> -  if (hdr == NULL) return 0;
> -  if (*buf != NULL && buf_size > 0) *buf[0] = '\0';
> -
> -  mg_http_parse_header_internal(hdr, var_name, &ab);
> -
> -  /*
> -   * Get a (trimmed) buffer, and return a len without a NUL byte which might
> -   * have been added.
> -   */
> -  *buf = altbuf_get_buf(&ab, 1 /* trim */);
> -  return ab.len > 0 ? ab.len - 1 : 0;
> -}
> -
> -int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf,
> -                         size_t buf_size) {
> -  char *buf2 = buf;
> -
> -  int len = mg_http_parse_header2(hdr, var_name, &buf2, buf_size);
> -
> -  if (buf2 != buf) {
> -    /* Buffer was not enough and was reallocated: free it and just return 0 */
> -    MG_FREE(buf2);
> -    return 0;
> -  }
> -
> -  return len;
> -}
> -
> -int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len,
> -                           char *pass, size_t pass_len) {
> -  struct mg_str *hdr = mg_get_http_header(hm, "Authorization");
> -  if (hdr == NULL) return -1;
> -  return mg_parse_http_basic_auth(hdr, user, user_len, pass, pass_len);
> -}
> -
> -int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len,
> -                             char *pass, size_t pass_len) {
> -  char *buf = NULL;
> -  char fmt[64];
> -  int res = 0;
> -
> -  if (mg_strncmp(*hdr, mg_mk_str("Basic "), 6) != 0) return -1;
> -
> -  buf = (char *) MG_MALLOC(hdr->len);
> -  cs_base64_decode((unsigned char *) hdr->p + 6, hdr->len, buf, NULL);
> -
> -  /* e.g. "%123[^:]:%321[^\n]" */
> -  snprintf(fmt, sizeof(fmt), "%%%" SIZE_T_FMT "[^:]:%%%" SIZE_T_FMT "[^\n]",
> -           user_len - 1, pass_len - 1);
> -  if (sscanf(buf, fmt, user, pass) == 0) {
> -    res = -1;
> -  }
> -
> -  MG_FREE(buf);
> -  return res;
> -}
> -
> -#if MG_ENABLE_FILESYSTEM
> -static int mg_is_file_hidden(const char *path,
> -                             const struct mg_serve_http_opts *opts,
> -                             int exclude_specials) {
> -  const char *p1 = opts->per_directory_auth_file;
> -  const char *p2 = opts->hidden_file_pattern;
> -
> -  /* Strip directory path from the file name */
> -  const char *pdir = strrchr(path, DIRSEP);
> -  if (pdir != NULL) {
> -    path = pdir + 1;
> -  }
> -
> -  return (exclude_specials && (!strcmp(path, ".") || !strcmp(path, ".."))) ||
> -         (p1 != NULL && mg_match_prefix(p1, strlen(p1), path) == strlen(p1)) ||
> -         (p2 != NULL && mg_match_prefix(p2, strlen(p2), path) > 0);
> -}
> -
> -#if !MG_DISABLE_HTTP_DIGEST_AUTH
> -
> -#ifndef MG_EXT_MD5
> -void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[],
> -                   const size_t *msg_lens, uint8_t *digest) {
> -  size_t i;
> -  cs_md5_ctx md5_ctx;
> -  cs_md5_init(&md5_ctx);
> -  for (i = 0; i < num_msgs; i++) {
> -    cs_md5_update(&md5_ctx, msgs[i], msg_lens[i]);
> -  }
> -  cs_md5_final(digest, &md5_ctx);
> -}
> -#else
> -extern void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[],
> -                          const size_t *msg_lens, uint8_t *digest);
> -#endif
> -
> -static void cs_md5(char buf[33], ...) {
> -  unsigned char hash[16];
> -  const uint8_t *msgs[20], *p;
> -  size_t msg_lens[20];
> -  size_t num_msgs = 0;
> -  va_list ap;
> -
> -  va_start(ap, buf);
> -  while ((p = va_arg(ap, const unsigned char *)) != NULL) {
> -    msgs[num_msgs] = p;
> -    msg_lens[num_msgs] = va_arg(ap, size_t);
> -    num_msgs++;
> -  }
> -  va_end(ap);
> -
> -  mg_hash_md5_v(num_msgs, msgs, msg_lens, hash);
> -  cs_to_hex(buf, hash, sizeof(hash));
> -}
> -
> -static void mg_mkmd5resp(const char *method, size_t method_len, const char *uri,
> -                         size_t uri_len, const char *ha1, size_t ha1_len,
> -                         const char *nonce, size_t nonce_len, const char *nc,
> -                         size_t nc_len, const char *cnonce, size_t cnonce_len,
> -                         const char *qop, size_t qop_len, char *resp) {
> -  static const char colon[] = ":";
> -  static const size_t one = 1;
> -  char ha2[33];
> -  cs_md5(ha2, method, method_len, colon, one, uri, uri_len, NULL);
> -  cs_md5(resp, ha1, ha1_len, colon, one, nonce, nonce_len, colon, one, nc,
> -         nc_len, colon, one, cnonce, cnonce_len, colon, one, qop, qop_len,
> -         colon, one, ha2, sizeof(ha2) - 1, NULL);
> -}
> -
> -int mg_http_create_digest_auth_header(char *buf, size_t buf_len,
> -                                      const char *method, const char *uri,
> -                                      const char *auth_domain, const char *user,
> -                                      const char *passwd, const char *nonce) {
> -  static const char colon[] = ":", qop[] = "auth";
> -  static const size_t one = 1;
> -  char ha1[33], resp[33], cnonce[40];
> -
> -  snprintf(cnonce, sizeof(cnonce), "%lx", (unsigned long) mg_time());
> -  cs_md5(ha1, user, (size_t) strlen(user), colon, one, auth_domain,
> -         (size_t) strlen(auth_domain), colon, one, passwd,
> -         (size_t) strlen(passwd), NULL);
> -  mg_mkmd5resp(method, strlen(method), uri, strlen(uri), ha1, sizeof(ha1) - 1,
> -               nonce, strlen(nonce), "1", one, cnonce, strlen(cnonce), qop,
> -               sizeof(qop) - 1, resp);
> -  return snprintf(buf, buf_len,
> -                  "Authorization: Digest username=\"%s\","
> -                  "realm=\"%s\",uri=\"%s\",qop=%s,nc=1,cnonce=%s,"
> -                  "nonce=%s,response=%s\r\n",
> -                  user, auth_domain, uri, qop, cnonce, nonce, resp);
> -}
> -
> -/*
> - * Check for authentication timeout.
> - * Clients send time stamp encoded in nonce. Make sure it is not too old,
> - * to prevent replay attacks.
> - * Assumption: nonce is a hexadecimal number of seconds since 1970.
> - */
> -static int mg_check_nonce(const char *nonce) {
> -  unsigned long now = (unsigned long) mg_time();
> -  unsigned long val = (unsigned long) strtoul(nonce, NULL, 16);
> -  return (now >= val) && (now - val < 60 * 60);
> -}
> -
> -int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain,
> -                              FILE *fp) {
> -  int ret = 0;
> -  struct mg_str *hdr;
> -  char username_buf[50], cnonce_buf[64], response_buf[40], uri_buf[200],
> -      qop_buf[20], nc_buf[20], nonce_buf[16];
> -
> -  char *username = username_buf, *cnonce = cnonce_buf, *response = response_buf,
> -       *uri = uri_buf, *qop = qop_buf, *nc = nc_buf, *nonce = nonce_buf;
> -
> -  /* Parse "Authorization:" header, fail fast on parse error */
> -  if (hm == NULL || fp == NULL ||
> -      (hdr = mg_get_http_header(hm, "Authorization")) == NULL ||
> -      mg_http_parse_header2(hdr, "username", &username, sizeof(username_buf)) ==
> -          0 ||
> -      mg_http_parse_header2(hdr, "cnonce", &cnonce, sizeof(cnonce_buf)) == 0 ||
> -      mg_http_parse_header2(hdr, "response", &response, sizeof(response_buf)) ==
> -          0 ||
> -      mg_http_parse_header2(hdr, "uri", &uri, sizeof(uri_buf)) == 0 ||
> -      mg_http_parse_header2(hdr, "qop", &qop, sizeof(qop_buf)) == 0 ||
> -      mg_http_parse_header2(hdr, "nc", &nc, sizeof(nc_buf)) == 0 ||
> -      mg_http_parse_header2(hdr, "nonce", &nonce, sizeof(nonce_buf)) == 0 ||
> -      mg_check_nonce(nonce) == 0) {
> -    ret = 0;
> -    goto clean;
> -  }
> -
> -  /* NOTE(lsm): due to a bug in MSIE, we do not compare URIs */
> -
> -  ret = mg_check_digest_auth(
> -      hm->method,
> -      mg_mk_str_n(
> -          hm->uri.p,
> -          hm->uri.len + (hm->query_string.len ? hm->query_string.len + 1 : 0)),
> -      mg_mk_str(username), mg_mk_str(cnonce), mg_mk_str(response),
> -      mg_mk_str(qop), mg_mk_str(nc), mg_mk_str(nonce), mg_mk_str(auth_domain),
> -      fp);
> -
> -clean:
> -  if (username != username_buf) MG_FREE(username);
> -  if (cnonce != cnonce_buf) MG_FREE(cnonce);
> -  if (response != response_buf) MG_FREE(response);
> -  if (uri != uri_buf) MG_FREE(uri);
> -  if (qop != qop_buf) MG_FREE(qop);
> -  if (nc != nc_buf) MG_FREE(nc);
> -  if (nonce != nonce_buf) MG_FREE(nonce);
> -
> -  return ret;
> -}
> -
> -int mg_check_digest_auth(struct mg_str method, struct mg_str uri,
> -                         struct mg_str username, struct mg_str cnonce,
> -                         struct mg_str response, struct mg_str qop,
> -                         struct mg_str nc, struct mg_str nonce,
> -                         struct mg_str auth_domain, FILE *fp) {
> -  char buf[128], f_user[sizeof(buf)], f_ha1[sizeof(buf)], f_domain[sizeof(buf)];
> -  char exp_resp[33];
> -
> -  /*
> -   * Read passwords file line by line. If should have htdigest format,
> -   * i.e. each line should be a colon-separated sequence:
> -   * USER_NAME:DOMAIN_NAME:HA1_HASH_OF_USER_DOMAIN_AND_PASSWORD
> -   */
> -  while (fgets(buf, sizeof(buf), fp) != NULL) {
> -    if (sscanf(buf, "%[^:]:%[^:]:%s", f_user, f_domain, f_ha1) == 3 &&
> -        mg_vcmp(&username, f_user) == 0 &&
> -        mg_vcmp(&auth_domain, f_domain) == 0) {
> -      /* Username and domain matched, check the password */
> -      mg_mkmd5resp(method.p, method.len, uri.p, uri.len, f_ha1, strlen(f_ha1),
> -                   nonce.p, nonce.len, nc.p, nc.len, cnonce.p, cnonce.len,
> -                   qop.p, qop.len, exp_resp);
> -      LOG(LL_DEBUG, ("%.*s %s %.*s %s", (int) username.len, username.p,
> -                     f_domain, (int) response.len, response.p, exp_resp));
> -      return mg_ncasecmp(response.p, exp_resp, strlen(exp_resp)) == 0;
> -    }
> -  }
> -
> -  /* None of the entries in the passwords file matched - return failure */
> -  return 0;
> -}
> -
> -int mg_http_is_authorized(struct http_message *hm, struct mg_str path,
> -                          const char *domain, const char *passwords_file,
> -                          int flags) {
> -  char buf[MG_MAX_PATH];
> -  const char *p;
> -  FILE *fp;
> -  int authorized = 1;
> -
> -  if (domain != NULL && passwords_file != NULL) {
> -    if (flags & MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE) {
> -      fp = mg_fopen(passwords_file, "r");
> -    } else if (flags & MG_AUTH_FLAG_IS_DIRECTORY) {
> -      snprintf(buf, sizeof(buf), "%.*s%c%s", (int) path.len, path.p, DIRSEP,
> -               passwords_file);
> -      fp = mg_fopen(buf, "r");
> -    } else {
> -      p = strrchr(path.p, DIRSEP);
> -      if (p == NULL) p = path.p;
> -      snprintf(buf, sizeof(buf), "%.*s%c%s", (int) (p - path.p), path.p, DIRSEP,
> -               passwords_file);
> -      fp = mg_fopen(buf, "r");
> -    }
> -
> -    if (fp != NULL) {
> -      authorized = mg_http_check_digest_auth(hm, domain, fp);
> -      fclose(fp);
> -    } else if (!(flags & MG_AUTH_FLAG_ALLOW_MISSING_FILE)) {
> -      authorized = 0;
> -    }
> -  }
> -
> -  LOG(LL_DEBUG, ("%.*s %s %x %d", (int) path.len, path.p,
> -                 passwords_file ? passwords_file : "", flags, authorized));
> -  return authorized;
> -}
> -#else
> -int mg_http_is_authorized(struct http_message *hm, const struct mg_str path,
> -                          const char *domain, const char *passwords_file,
> -                          int flags) {
> -  (void) hm;
> -  (void) path;
> -  (void) domain;
> -  (void) passwords_file;
> -  (void) flags;
> -  return 1;
> -}
> -#endif
> -
> -#if MG_ENABLE_DIRECTORY_LISTING
> -static void mg_escape(const char *src, char *dst, size_t dst_len) {
> -  size_t n = 0;
> -  while (*src != '\0' && n + 5 < dst_len) {
> -    unsigned char ch = *(unsigned char *) src++;
> -    if (ch == '<') {
> -      n += snprintf(dst + n, dst_len - n, "%s", "&lt;");
> -    } else {
> -      dst[n++] = ch;
> -    }
> -  }
> -  dst[n] = '\0';
> -}
> -
> -static void mg_print_dir_entry(struct mg_connection *nc, const char *file_name,
> -                               cs_stat_t *stp) {
> -  char size[64], mod[64], path[MG_MAX_PATH];
> -  int64_t fsize = stp->st_size;
> -  int is_dir = S_ISDIR(stp->st_mode);
> -  const char *slash = is_dir ? "/" : "";
> -  struct mg_str href;
> -
> -  if (is_dir) {
> -    snprintf(size, sizeof(size), "%s", "[DIRECTORY]");
> -  } else {
> -    /*
> -     * We use (double) cast below because MSVC 6 compiler cannot
> -     * convert unsigned __int64 to double.
> -     */
> -    if (fsize < 1024) {
> -      snprintf(size, sizeof(size), "%d", (int) fsize);
> -    } else if (fsize < 0x100000) {
> -      snprintf(size, sizeof(size), "%.1fk", (double) fsize / 1024.0);
> -    } else if (fsize < 0x40000000) {
> -      snprintf(size, sizeof(size), "%.1fM", (double) fsize / 1048576);
> -    } else {
> -      snprintf(size, sizeof(size), "%.1fG", (double) fsize / 1073741824);
> -    }
> -  }
> -  strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&stp->st_mtime));
> -  mg_escape(file_name, path, sizeof(path));
> -  href = mg_url_encode(mg_mk_str(file_name));
> -  mg_printf_http_chunk(nc,
> -                       "<tr><td><a href=\"%s%s\">%s%s</a></td>"
> -                       "<td>%s</td><td name=\"%" INT64_FMT "\">%s</td></tr>",
> -                       href.p, slash, path, slash, mod, is_dir ? -1 : fsize,
> -                       size);
> -  free((void *) href.p);
> -}
> -
> -static void mg_scan_directory(struct mg_connection *nc, const char *dir,
> -                              const struct mg_serve_http_opts *opts,
> -                              void (*func)(struct mg_connection *, const char *,
> -                                           cs_stat_t *)) {
> -  char path[MG_MAX_PATH + 1];
> -  cs_stat_t st;
> -  struct dirent *dp;
> -  DIR *dirp;
> -
> -  LOG(LL_DEBUG, ("%p [%s]", nc, dir));
> -  if ((dirp = (opendir(dir))) != NULL) {
> -    while ((dp = readdir(dirp)) != NULL) {
> -      /* Do not show current dir and hidden files */
> -      if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) {
> -        continue;
> -      }
> -      snprintf(path, sizeof(path), "%s/%s", dir, dp->d_name);
> -      if (mg_stat(path, &st) == 0) {
> -        func(nc, (const char *) dp->d_name, &st);
> -      }
> -    }
> -    closedir(dirp);
> -  } else {
> -    LOG(LL_DEBUG, ("%p opendir(%s) -> %d", nc, dir, mg_get_errno()));
> -  }
> -}
> -
> -static void mg_send_directory_listing(struct mg_connection *nc, const char *dir,
> -                                      struct http_message *hm,
> -                                      struct mg_serve_http_opts *opts) {
> -  static const char *sort_js_code =
> -      "<script>function srt(tb, sc, so, d) {"
> -      "var tr = Array.prototype.slice.call(tb.rows, 0),"
> -      "tr = tr.sort(function (a, b) { var c1 = a.cells[sc], c2 = b.cells[sc],"
> -      "n1 = c1.getAttribute('name'), n2 = c2.getAttribute('name'), "
> -      "t1 = a.cells[2].getAttribute('name'), "
> -      "t2 = b.cells[2].getAttribute('name'); "
> -      "return so * (t1 < 0 && t2 >= 0 ? -1 : t2 < 0 && t1 >= 0 ? 1 : "
> -      "n1 ? parseInt(n2) - parseInt(n1) : "
> -      "c1.textContent.trim().localeCompare(c2.textContent.trim())); });";
> -  static const char *sort_js_code2 =
> -      "for (var i = 0; i < tr.length; i++) tb.appendChild(tr[i]); "
> -      "if (!d) window.location.hash = ('sc=' + sc + '&so=' + so); "
> -      "};"
> -      "window.onload = function() {"
> -      "var tb = document.getElementById('tb');"
> -      "var m = /sc=([012]).so=(1|-1)/.exec(window.location.hash) || [0, 2, 1];"
> -      "var sc = m[1], so = m[2]; document.onclick = function(ev) { "
> -      "var c = ev.target.rel; if (c) {if (c == sc) so *= -1; srt(tb, c, so); "
> -      "sc = c; ev.preventDefault();}};"
> -      "srt(tb, sc, so, true);"
> -      "}"
> -      "</script>";
> -
> -  mg_send_response_line(nc, 200, opts->extra_headers);
> -  mg_printf(nc, "%s: %s\r\n%s: %s\r\n\r\n", "Transfer-Encoding", "chunked",
> -            "Content-Type", "text/html; charset=utf-8");
> -
> -  mg_printf_http_chunk(
> -      nc,
> -      "<!DOCTYPE html><html><head><title>Index of %.*s</title>%s%s"
> -      "<style>th,td {text-align: left; padding-right: 1em; "
> -      "font-family: monospace; }</style></head>"
> -      "<body><h1>Index of %.*s</h1><table cellpadding=\"0\"><thead>"
> -      "<tr><th><a href=\"#\" rel=\"0\">Name</a></th><th>"
> -      "<a href=\"#\" rel=\"1\">Modified</a></th>"
> -      "<th><a href=\"#\" rel=\"2\">Size</a></th></tr>"
> -      "<tr><td colspan=\"3\"><hr></td></tr>"
> -      "</thead>"
> -      "<tbody id=\"tb\">",
> -      (int) hm->uri.len, hm->uri.p, sort_js_code, sort_js_code2,
> -      (int) hm->uri.len, hm->uri.p);
> -  mg_scan_directory(nc, dir, opts, mg_print_dir_entry);
> -  mg_printf_http_chunk(nc,
> -                       "</tbody>"
> -                       "<tfoot><tr><td colspan=\"3\"><hr></td></tr></tfoot>"
> -                       "</table>"
> -                       "<address>%s</address>"
> -                       "</body></html>",
> -                       mg_version_header);
> -  mg_send_http_chunk(nc, "", 0);
> -  /* TODO(rojer): Remove when cesanta/dev/issues/197 is fixed. */
> -  nc->flags |= MG_F_SEND_AND_CLOSE;
> -}
> -#endif /* MG_ENABLE_DIRECTORY_LISTING */
> -
> -/*
> - * Given a directory path, find one of the files specified in the
> - * comma-separated list of index files `list`.
> - * First found index file wins. If an index file is found, then gets
> - * appended to the `path`, stat-ed, and result of `stat()` passed to `stp`.
> - * If index file is not found, then `path` and `stp` remain unchanged.
> - */
> -MG_INTERNAL void mg_find_index_file(const char *path, const char *list,
> -                                    char **index_file, cs_stat_t *stp) {
> -  struct mg_str vec;
> -  size_t path_len = strlen(path);
> -  int found = 0;
> -  *index_file = NULL;
> -
> -  /* Traverse index files list. For each entry, append it to the given */
> -  /* path and see if the file exists. If it exists, break the loop */
> -  while ((list = mg_next_comma_list_entry(list, &vec, NULL)) != NULL) {
> -    cs_stat_t st;
> -    size_t len = path_len + 1 + vec.len + 1;
> -    *index_file = (char *) MG_REALLOC(*index_file, len);
> -    if (*index_file == NULL) break;
> -    snprintf(*index_file, len, "%s%c%.*s", path, DIRSEP, (int) vec.len, vec.p);
> -
> -    /* Does it exist? Is it a file? */
> -    if (mg_stat(*index_file, &st) == 0 && S_ISREG(st.st_mode)) {
> -      /* Yes it does, break the loop */
> -      *stp = st;
> -      found = 1;
> -      break;
> -    }
> -  }
> -  if (!found) {
> -    MG_FREE(*index_file);
> -    *index_file = NULL;
> -  }
> -  LOG(LL_DEBUG, ("[%s] [%s]", path, (*index_file ? *index_file : "")));
> -}
> -
> -#if MG_ENABLE_HTTP_URL_REWRITES
> -static int mg_http_send_port_based_redirect(
> -    struct mg_connection *c, struct http_message *hm,
> -    const struct mg_serve_http_opts *opts) {
> -  const char *rewrites = opts->url_rewrites;
> -  struct mg_str a, b;
> -  char local_port[20] = {'%'};
> -
> -  mg_conn_addr_to_str(c, local_port + 1, sizeof(local_port) - 1,
> -                      MG_SOCK_STRINGIFY_PORT);
> -
> -  while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) {
> -    if (mg_vcmp(&a, local_port) == 0) {
> -      mg_send_response_line(c, 301, NULL);
> -      mg_printf(c, "Content-Length: 0\r\nLocation: %.*s%.*s\r\n\r\n",
> -                (int) b.len, b.p, (int) (hm->proto.p - hm->uri.p - 1),
> -                hm->uri.p);
> -      return 1;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -static void mg_reverse_proxy_handler(struct mg_connection *nc, int ev,
> -                                     void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct http_message *hm = (struct http_message *) ev_data;
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -
> -  if (pd == NULL || pd->reverse_proxy_data.linked_conn == NULL) {
> -    DBG(("%p: upstream closed", nc));
> -    return;
> -  }
> -
> -  switch (ev) {
> -    case MG_EV_CONNECT:
> -      if (*(int *) ev_data != 0) {
> -        mg_http_send_error(pd->reverse_proxy_data.linked_conn, 502, NULL);
> -      }
> -      break;
> -    /* TODO(mkm): handle streaming */
> -    case MG_EV_HTTP_REPLY:
> -      mg_send(pd->reverse_proxy_data.linked_conn, hm->message.p,
> -              hm->message.len);
> -      pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE;
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      break;
> -    case MG_EV_CLOSE:
> -      pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE;
> -      break;
> -  }
> -
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  (void) user_data;
> -#endif
> -}
> -
> -void mg_http_reverse_proxy(struct mg_connection *nc,
> -                           const struct http_message *hm, struct mg_str mount,
> -                           struct mg_str upstream) {
> -  struct mg_connection *be;
> -  char burl[256], *purl = burl;
> -  int i;
> -  const char *error;
> -  struct mg_connect_opts opts;
> -  struct mg_str path = MG_NULL_STR, user_info = MG_NULL_STR, host = MG_NULL_STR;
> -  memset(&opts, 0, sizeof(opts));
> -  opts.error_string = &error;
> -
> -  mg_asprintf(&purl, sizeof(burl), "%.*s%.*s", (int) upstream.len, upstream.p,
> -              (int) (hm->uri.len - mount.len), hm->uri.p + mount.len);
> -
> -  be = mg_connect_http_base(nc->mgr, MG_CB(mg_reverse_proxy_handler, NULL),
> -                            opts, "http", NULL, "https", NULL, purl, &path,
> -                            &user_info, &host);
> -  LOG(LL_DEBUG, ("Proxying %.*s to %s (rule: %.*s)", (int) hm->uri.len,
> -                 hm->uri.p, purl, (int) mount.len, mount.p));
> -
> -  if (be == NULL) {
> -    LOG(LL_ERROR, ("Error connecting to %s: %s", purl, error));
> -    mg_http_send_error(nc, 502, NULL);
> -    goto cleanup;
> -  }
> -
> -  /* link connections to each other, they must live and die together */
> -  mg_http_get_proto_data(be)->reverse_proxy_data.linked_conn = nc;
> -  mg_http_get_proto_data(nc)->reverse_proxy_data.linked_conn = be;
> -
> -  /* send request upstream */
> -  mg_printf(be, "%.*s %.*s HTTP/1.1\r\n", (int) hm->method.len, hm->method.p,
> -            (int) path.len, path.p);
> -
> -  mg_printf(be, "Host: %.*s\r\n", (int) host.len, host.p);
> -  for (i = 0; i < MG_MAX_HTTP_HEADERS && hm->header_names[i].len > 0; i++) {
> -    struct mg_str hn = hm->header_names[i];
> -    struct mg_str hv = hm->header_values[i];
> -
> -    /* we rewrite the host header */
> -    if (mg_vcasecmp(&hn, "Host") == 0) continue;
> -    /*
> -     * Don't pass chunked transfer encoding to the client because hm->body is
> -     * already dechunked when we arrive here.
> -     */
> -    if (mg_vcasecmp(&hn, "Transfer-encoding") == 0 &&
> -        mg_vcasecmp(&hv, "chunked") == 0) {
> -      mg_printf(be, "Content-Length: %" SIZE_T_FMT "\r\n", hm->body.len);
> -      continue;
> -    }
> -    /* We don't support proxying Expect: 100-continue. */
> -    if (mg_vcasecmp(&hn, "Expect") == 0 &&
> -        mg_vcasecmp(&hv, "100-continue") == 0) {
> -      continue;
> -    }
> -
> -    mg_printf(be, "%.*s: %.*s\r\n", (int) hn.len, hn.p, (int) hv.len, hv.p);
> -  }
> -
> -  mg_send(be, "\r\n", 2);
> -  mg_send(be, hm->body.p, hm->body.len);
> -
> -cleanup:
> -  if (purl != burl) MG_FREE(purl);
> -}
> -
> -static int mg_http_handle_forwarding(struct mg_connection *nc,
> -                                     struct http_message *hm,
> -                                     const struct mg_serve_http_opts *opts) {
> -  const char *rewrites = opts->url_rewrites;
> -  struct mg_str a, b;
> -  struct mg_str p1 = MG_MK_STR("http://"), p2 = MG_MK_STR("https://");
> -
> -  while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) {
> -    if (mg_strncmp(a, hm->uri, a.len) == 0) {
> -      if (mg_strncmp(b, p1, p1.len) == 0 || mg_strncmp(b, p2, p2.len) == 0) {
> -        mg_http_reverse_proxy(nc, hm, a, b);
> -        return 1;
> -      }
> -    }
> -  }
> -
> -  return 0;
> -}
> -#endif /* MG_ENABLE_FILESYSTEM */
> -
> -MG_INTERNAL int mg_uri_to_local_path(struct http_message *hm,
> -                                     const struct mg_serve_http_opts *opts,
> -                                     char **local_path,
> -                                     struct mg_str *remainder) {
> -  int ok = 1;
> -  const char *cp = hm->uri.p, *cp_end = hm->uri.p + hm->uri.len;
> -  struct mg_str root = {NULL, 0};
> -  const char *file_uri_start = cp;
> -  *local_path = NULL;
> -  remainder->p = NULL;
> -  remainder->len = 0;
> -
> -  { /* 1. Determine which root to use. */
> -
> -#if MG_ENABLE_HTTP_URL_REWRITES
> -    const char *rewrites = opts->url_rewrites;
> -#else
> -    const char *rewrites = "";
> -#endif
> -    struct mg_str *hh = mg_get_http_header(hm, "Host");
> -    struct mg_str a, b;
> -    /* Check rewrites first. */
> -    while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) {
> -      if (a.len > 1 && a.p[0] == '@') {
> -        /* Host rewrite. */
> -        if (hh != NULL && hh->len == a.len - 1 &&
> -            mg_ncasecmp(a.p + 1, hh->p, a.len - 1) == 0) {
> -          root = b;
> -          break;
> -        }
> -      } else {
> -        /* Regular rewrite, URI=directory */
> -        size_t match_len = mg_match_prefix_n(a, hm->uri);
> -        if (match_len > 0) {
> -          file_uri_start = hm->uri.p + match_len;
> -          if (*file_uri_start == '/' || file_uri_start == cp_end) {
> -            /* Match ended at component boundary, ok. */
> -          } else if (*(file_uri_start - 1) == '/') {
> -            /* Pattern ends with '/', backtrack. */
> -            file_uri_start--;
> -          } else {
> -            /* No match: must fall on the component boundary. */
> -            continue;
> -          }
> -          root = b;
> -          break;
> -        }
> -      }
> -    }
> -    /* If no rewrite rules matched, use DAV or regular document root. */
> -    if (root.p == NULL) {
> -#if MG_ENABLE_HTTP_WEBDAV
> -      if (opts->dav_document_root != NULL && mg_is_dav_request(&hm->method)) {
> -        root.p = opts->dav_document_root;
> -        root.len = strlen(opts->dav_document_root);
> -      } else
> -#endif
> -      {
> -        root.p = opts->document_root;
> -        root.len = strlen(opts->document_root);
> -      }
> -    }
> -    assert(root.p != NULL && root.len > 0);
> -  }
> -
> -  { /* 2. Find where in the canonical URI path the local path ends. */
> -    const char *u = file_uri_start + 1;
> -    char *lp = (char *) MG_MALLOC(root.len + hm->uri.len + 1);
> -    char *lp_end = lp + root.len + hm->uri.len + 1;
> -    char *p = lp, *ps;
> -    int exists = 1;
> -    if (lp == NULL) {
> -      ok = 0;
> -      goto out;
> -    }
> -    memcpy(p, root.p, root.len);
> -    p += root.len;
> -    if (*(p - 1) == DIRSEP) p--;
> -    *p = '\0';
> -    ps = p;
> -
> -    /* Chop off URI path components one by one and build local path. */
> -    while (u <= cp_end) {
> -      const char *next = u;
> -      struct mg_str component;
> -      if (exists) {
> -        cs_stat_t st;
> -        exists = (mg_stat(lp, &st) == 0);
> -        if (exists && S_ISREG(st.st_mode)) {
> -          /* We found the terminal, the rest of the URI (if any) is path_info.
> -           */
> -          if (*(u - 1) == '/') u--;
> -          break;
> -        }
> -      }
> -      if (u >= cp_end) break;
> -      parse_uri_component((const char **) &next, cp_end, "/", &component);
> -      if (component.len > 0) {
> -        int len;
> -        memmove(p + 1, component.p, component.len);
> -        len = mg_url_decode(p + 1, component.len, p + 1, lp_end - p - 1, 0);
> -        if (len <= 0) {
> -          ok = 0;
> -          break;
> -        }
> -        component.p = p + 1;
> -        component.len = len;
> -        if (mg_vcmp(&component, ".") == 0) {
> -          /* Yum. */
> -        } else if (mg_vcmp(&component, "..") == 0) {
> -          while (p > ps && *p != DIRSEP) p--;
> -          *p = '\0';
> -        } else {
> -          size_t i;
> -#ifdef _WIN32
> -          /* On Windows, make sure it's valid Unicode (no funny stuff). */
> -          wchar_t buf[MG_MAX_PATH * 2];
> -          if (to_wchar(component.p, buf, MG_MAX_PATH) == 0) {
> -            DBG(("[%.*s] smells funny", (int) component.len, component.p));
> -            ok = 0;
> -            break;
> -          }
> -#endif
> -          *p++ = DIRSEP;
> -          /* No NULs and DIRSEPs in the component (percent-encoded). */
> -          for (i = 0; i < component.len; i++, p++) {
> -            if (*p == '\0' ||
> -                *p == DIRSEP
> -#ifdef _WIN32
> -                /* On Windows, "/" is also accepted, so check for that too. */
> -                || *p == '/'
> -#endif
> -            ) {
> -              ok = 0;
> -              break;
> -            }
> -          }
> -        }
> -      }
> -      u = next;
> -    }
> -    if (ok) {
> -      *local_path = lp;
> -      if (u > cp_end) u = cp_end;
> -      remainder->p = u;
> -      remainder->len = cp_end - u;
> -    } else {
> -      MG_FREE(lp);
> -    }
> -  }
> -
> -out:
> -  LOG(LL_DEBUG,
> -      ("'%.*s' -> '%s' + '%.*s'", (int) hm->uri.len, hm->uri.p,
> -       *local_path ? *local_path : "", (int) remainder->len, remainder->p));
> -  return ok;
> -}
> -
> -static int mg_get_month_index(const char *s) {
> -  static const char *month_names[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
> -                                      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
> -  size_t i;
> -
> -  for (i = 0; i < ARRAY_SIZE(month_names); i++)
> -    if (!strcmp(s, month_names[i])) return (int) i;
> -
> -  return -1;
> -}
> -
> -static int mg_num_leap_years(int year) {
> -  return year / 4 - year / 100 + year / 400;
> -}
> -
> -/* Parse UTC date-time string, and return the corresponding time_t value. */
> -MG_INTERNAL time_t mg_parse_date_string(const char *datetime) {
> -  static const unsigned short days_before_month[] = {
> -      0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
> -  char month_str[32];
> -  int second, minute, hour, day, month, year, leap_days, days;
> -  time_t result = (time_t) 0;
> -
> -  if (((sscanf(datetime, "%d/%3s/%d %d:%d:%d", &day, month_str, &year, &hour,
> -               &minute, &second) == 6) ||
> -       (sscanf(datetime, "%d %3s %d %d:%d:%d", &day, month_str, &year, &hour,
> -               &minute, &second) == 6) ||
> -       (sscanf(datetime, "%*3s, %d %3s %d %d:%d:%d", &day, month_str, &year,
> -               &hour, &minute, &second) == 6) ||
> -       (sscanf(datetime, "%d-%3s-%d %d:%d:%d", &day, month_str, &year, &hour,
> -               &minute, &second) == 6)) &&
> -      year > 1970 && (month = mg_get_month_index(month_str)) != -1) {
> -    leap_days = mg_num_leap_years(year) - mg_num_leap_years(1970);
> -    year -= 1970;
> -    days = year * 365 + days_before_month[month] + (day - 1) + leap_days;
> -    result = days * 24 * 3600 + hour * 3600 + minute * 60 + second;
> -  }
> -
> -  return result;
> -}
> -
> -MG_INTERNAL int mg_is_not_modified(struct http_message *hm, cs_stat_t *st) {
> -  struct mg_str *hdr;
> -  if ((hdr = mg_get_http_header(hm, "If-None-Match")) != NULL) {
> -    char etag[64];
> -    mg_http_construct_etag(etag, sizeof(etag), st);
> -    return mg_vcasecmp(hdr, etag) == 0;
> -  } else if ((hdr = mg_get_http_header(hm, "If-Modified-Since")) != NULL) {
> -    return st->st_mtime <= mg_parse_date_string(hdr->p);
> -  } else {
> -    return 0;
> -  }
> -}
> -
> -void mg_http_send_digest_auth_request(struct mg_connection *c,
> -                                      const char *domain) {
> -  mg_printf(c,
> -            "HTTP/1.1 401 Unauthorized\r\n"
> -            "WWW-Authenticate: Digest qop=\"auth\", "
> -            "realm=\"%s\", nonce=\"%lx\"\r\n"
> -            "Content-Length: 0\r\n\r\n",
> -            domain, (unsigned long) mg_time());
> -}
> -
> -static void mg_http_send_options(struct mg_connection *nc,
> -                                 struct mg_serve_http_opts *opts) {
> -  mg_send_response_line(nc, 200, opts->extra_headers);
> -  mg_printf(nc, "%s",
> -            "Allow: GET, POST, HEAD, CONNECT, OPTIONS"
> -#if MG_ENABLE_HTTP_WEBDAV
> -            ", MKCOL, PUT, DELETE, PROPFIND, MOVE\r\nDAV: 1,2"
> -#endif
> -            "\r\n\r\n");
> -  nc->flags |= MG_F_SEND_AND_CLOSE;
> -}
> -
> -static int mg_is_creation_request(const struct http_message *hm) {
> -  return mg_vcmp(&hm->method, "MKCOL") == 0 || mg_vcmp(&hm->method, "PUT") == 0;
> -}
> -
> -MG_INTERNAL void mg_send_http_file(struct mg_connection *nc, char *path,
> -                                   const struct mg_str *path_info,
> -                                   struct http_message *hm,
> -                                   struct mg_serve_http_opts *opts) {
> -  int exists, is_directory, is_cgi;
> -#if MG_ENABLE_HTTP_WEBDAV
> -  int is_dav = mg_is_dav_request(&hm->method);
> -#else
> -  int is_dav = 0;
> -#endif
> -  char *index_file = NULL;
> -  cs_stat_t st;
> -
> -  exists = (mg_stat(path, &st) == 0);
> -  is_directory = exists && S_ISDIR(st.st_mode);
> -
> -  if (is_directory)
> -    mg_find_index_file(path, opts->index_files, &index_file, &st);
> -
> -  is_cgi =
> -      (mg_match_prefix(opts->cgi_file_pattern, strlen(opts->cgi_file_pattern),
> -                       index_file ? index_file : path) > 0);
> -
> -  LOG(LL_DEBUG,
> -      ("%p %.*s [%s] exists=%d is_dir=%d is_dav=%d is_cgi=%d index=%s", nc,
> -       (int) hm->method.len, hm->method.p, path, exists, is_directory, is_dav,
> -       is_cgi, index_file ? index_file : ""));
> -
> -  if (is_directory && hm->uri.p[hm->uri.len - 1] != '/' && !is_dav) {
> -    mg_printf(nc,
> -              "HTTP/1.1 301 Moved\r\nLocation: %.*s/\r\n"
> -              "Content-Length: 0\r\n\r\n",
> -              (int) hm->uri.len, hm->uri.p);
> -    MG_FREE(index_file);
> -    return;
> -  }
> -
> -  /* If we have path_info, the only way to handle it is CGI. */
> -  if (path_info->len > 0 && !is_cgi) {
> -    mg_http_send_error(nc, 501, NULL);
> -    MG_FREE(index_file);
> -    return;
> -  }
> -
> -  if (is_dav && opts->dav_document_root == NULL) {
> -    mg_http_send_error(nc, 501, NULL);
> -  } else if (!mg_http_is_authorized(
> -                 hm, mg_mk_str(path), opts->auth_domain, opts->global_auth_file,
> -                 ((is_directory ? MG_AUTH_FLAG_IS_DIRECTORY : 0) |
> -                  MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE |
> -                  MG_AUTH_FLAG_ALLOW_MISSING_FILE)) ||
> -             !mg_http_is_authorized(
> -                 hm, mg_mk_str(path), opts->auth_domain,
> -                 opts->per_directory_auth_file,
> -                 ((is_directory ? MG_AUTH_FLAG_IS_DIRECTORY : 0) |
> -                  MG_AUTH_FLAG_ALLOW_MISSING_FILE))) {
> -    mg_http_send_digest_auth_request(nc, opts->auth_domain);
> -  } else if (is_cgi) {
> -#if MG_ENABLE_HTTP_CGI
> -    mg_handle_cgi(nc, index_file ? index_file : path, path_info, hm, opts);
> -#else
> -    mg_http_send_error(nc, 501, NULL);
> -#endif /* MG_ENABLE_HTTP_CGI */
> -  } else if ((!exists ||
> -              mg_is_file_hidden(path, opts, 0 /* specials are ok */)) &&
> -             !mg_is_creation_request(hm)) {
> -    mg_http_send_error(nc, 404, NULL);
> -#if MG_ENABLE_HTTP_WEBDAV
> -  } else if (!mg_vcmp(&hm->method, "PROPFIND")) {
> -    mg_handle_propfind(nc, path, &st, hm, opts);
> -#if !MG_DISABLE_DAV_AUTH
> -  } else if (is_dav &&
> -             (opts->dav_auth_file == NULL ||
> -              (strcmp(opts->dav_auth_file, "-") != 0 &&
> -               !mg_http_is_authorized(
> -                   hm, mg_mk_str(path), opts->auth_domain, opts->dav_auth_file,
> -                   ((is_directory ? MG_AUTH_FLAG_IS_DIRECTORY : 0) |
> -                    MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE |
> -                    MG_AUTH_FLAG_ALLOW_MISSING_FILE))))) {
> -    mg_http_send_digest_auth_request(nc, opts->auth_domain);
> -#endif
> -  } else if (!mg_vcmp(&hm->method, "MKCOL")) {
> -    mg_handle_mkcol(nc, path, hm);
> -  } else if (!mg_vcmp(&hm->method, "DELETE")) {
> -    mg_handle_delete(nc, opts, path);
> -  } else if (!mg_vcmp(&hm->method, "PUT")) {
> -    mg_handle_put(nc, path, hm);
> -  } else if (!mg_vcmp(&hm->method, "MOVE")) {
> -    mg_handle_move(nc, opts, path, hm);
> -#if MG_ENABLE_FAKE_DAVLOCK
> -  } else if (!mg_vcmp(&hm->method, "LOCK")) {
> -    mg_handle_lock(nc, path);
> -#endif
> -#endif /* MG_ENABLE_HTTP_WEBDAV */
> -  } else if (!mg_vcmp(&hm->method, "OPTIONS")) {
> -    mg_http_send_options(nc, opts);
> -  } else if (is_directory && index_file == NULL) {
> -#if MG_ENABLE_DIRECTORY_LISTING
> -    if (strcmp(opts->enable_directory_listing, "yes") == 0) {
> -      mg_send_directory_listing(nc, path, hm, opts);
> -    } else {
> -      mg_http_send_error(nc, 403, NULL);
> -    }
> -#else
> -    mg_http_send_error(nc, 501, NULL);
> -#endif
> -  } else if (mg_is_not_modified(hm, &st)) {
> -    /* Note: not using mg_http_send_error in order to keep connection alive */
> -    /* Note: passing extra headers allow users to control session cookies */
> -    mg_send_head(nc, 304, 0, opts->extra_headers);
> -  } else {
> -    mg_http_serve_file2(nc, index_file ? index_file : path, hm, opts);
> -  }
> -  MG_FREE(index_file);
> -}
> -
> -void mg_serve_http(struct mg_connection *nc, struct http_message *hm,
> -                   struct mg_serve_http_opts opts) {
> -  char *path = NULL;
> -  struct mg_str *hdr, path_info;
> -  uint32_t remote_ip = ntohl(*(uint32_t *) &nc->sa.sin.sin_addr);
> -
> -  if (mg_check_ip_acl(opts.ip_acl, remote_ip) != 1) {
> -    /* Not allowed to connect */
> -    mg_http_send_error(nc, 403, NULL);
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -    return;
> -  }
> -
> -#if MG_ENABLE_HTTP_URL_REWRITES
> -  if (mg_http_handle_forwarding(nc, hm, &opts)) {
> -    return;
> -  }
> -
> -  if (mg_http_send_port_based_redirect(nc, hm, &opts)) {
> -    return;
> -  }
> -#endif
> -
> -  if (opts.document_root == NULL) {
> -    opts.document_root = ".";
> -  }
> -  if (opts.per_directory_auth_file == NULL) {
> -    opts.per_directory_auth_file = ".htpasswd";
> -  }
> -  if (opts.enable_directory_listing == NULL) {
> -    opts.enable_directory_listing = "yes";
> -  }
> -  if (opts.cgi_file_pattern == NULL) {
> -    opts.cgi_file_pattern = "**.cgi$|**.php$";
> -  }
> -  if (opts.ssi_pattern == NULL) {
> -    opts.ssi_pattern = "**.shtml$|**.shtm$";
> -  }
> -  if (opts.index_files == NULL) {
> -    opts.index_files = "index.html,index.htm,index.shtml,index.cgi,index.php";
> -  }
> -  /* Normalize path - resolve "." and ".." (in-place). */
> -  if (!mg_normalize_uri_path(&hm->uri, &hm->uri)) {
> -    mg_http_send_error(nc, 400, NULL);
> -    return;
> -  }
> -  if (mg_uri_to_local_path(hm, &opts, &path, &path_info) == 0) {
> -    mg_http_send_error(nc, 404, NULL);
> -    return;
> -  }
> -  mg_send_http_file(nc, path, &path_info, hm, &opts);
> -
> -  MG_FREE(path);
> -  path = NULL;
> -
> -  /* Close connection for non-keep-alive requests */
> -  if (mg_vcmp(&hm->proto, "HTTP/1.1") != 0 ||
> -      ((hdr = mg_get_http_header(hm, "Connection")) != NULL &&
> -       mg_vcmp(hdr, "keep-alive") != 0)) {
> -#if 0
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -#endif
> -  }
> -}
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -void mg_file_upload_handler(struct mg_connection *nc, int ev, void *ev_data,
> -                            mg_fu_fname_fn local_name_fn
> -                                MG_UD_ARG(void *user_data)) {
> -  switch (ev) {
> -    case MG_EV_HTTP_PART_BEGIN: {
> -      struct mg_http_multipart_part *mp =
> -          (struct mg_http_multipart_part *) ev_data;
> -      struct file_upload_state *fus;
> -      struct mg_str lfn = local_name_fn(nc, mg_mk_str(mp->file_name));
> -      mp->user_data = NULL;
> -      if (lfn.p == NULL || lfn.len == 0) {
> -        LOG(LL_ERROR, ("%p Not allowed to upload %s", nc, mp->file_name));
> -        mg_printf(nc,
> -                  "HTTP/1.1 403 Not Allowed\r\n"
> -                  "Content-Type: text/plain\r\n"
> -                  "Connection: close\r\n\r\n"
> -                  "Not allowed to upload %s\r\n",
> -                  mp->file_name);
> -        nc->flags |= MG_F_SEND_AND_CLOSE;
> -        return;
> -      }
> -      fus = (struct file_upload_state *) MG_CALLOC(1, sizeof(*fus));
> -      if (fus == NULL) {
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        return;
> -      }
> -      fus->lfn = (char *) MG_MALLOC(lfn.len + 1);
> -      memcpy(fus->lfn, lfn.p, lfn.len);
> -      fus->lfn[lfn.len] = '\0';
> -      if (lfn.p != mp->file_name) MG_FREE((char *) lfn.p);
> -      LOG(LL_DEBUG,
> -          ("%p Receiving file %s -> %s", nc, mp->file_name, fus->lfn));
> -      fus->fp = mg_fopen(fus->lfn, "wb");
> -      if (fus->fp == NULL) {
> -        mg_printf(nc,
> -                  "HTTP/1.1 500 Internal Server Error\r\n"
> -                  "Content-Type: text/plain\r\n"
> -                  "Connection: close\r\n\r\n");
> -        LOG(LL_ERROR, ("Failed to open %s: %d\n", fus->lfn, mg_get_errno()));
> -        mg_printf(nc, "Failed to open %s: %d\n", fus->lfn, mg_get_errno());
> -        /* Do not close the connection just yet, discard remainder of the data.
> -         * This is because at the time of writing some browsers (Chrome) fail to
> -         * render response before all the data is sent. */
> -      }
> -      mp->user_data = (void *) fus;
> -      break;
> -    }
> -    case MG_EV_HTTP_PART_DATA: {
> -      struct mg_http_multipart_part *mp =
> -          (struct mg_http_multipart_part *) ev_data;
> -      struct file_upload_state *fus =
> -          (struct file_upload_state *) mp->user_data;
> -      if (fus == NULL || fus->fp == NULL) break;
> -      if (mg_fwrite(mp->data.p, 1, mp->data.len, fus->fp) != mp->data.len) {
> -        LOG(LL_ERROR, ("Failed to write to %s: %d, wrote %d", fus->lfn,
> -                       mg_get_errno(), (int) fus->num_recd));
> -        if (mg_get_errno() == ENOSPC
> -#ifdef SPIFFS_ERR_FULL
> -            || mg_get_errno() == SPIFFS_ERR_FULL
> -#endif
> -        ) {
> -          mg_printf(nc,
> -                    "HTTP/1.1 413 Payload Too Large\r\n"
> -                    "Content-Type: text/plain\r\n"
> -                    "Connection: close\r\n\r\n");
> -          mg_printf(nc, "Failed to write to %s: no space left; wrote %d\r\n",
> -                    fus->lfn, (int) fus->num_recd);
> -        } else {
> -          mg_printf(nc,
> -                    "HTTP/1.1 500 Internal Server Error\r\n"
> -                    "Content-Type: text/plain\r\n"
> -                    "Connection: close\r\n\r\n");
> -          mg_printf(nc, "Failed to write to %s: %d, wrote %d", mp->file_name,
> -                    mg_get_errno(), (int) fus->num_recd);
> -        }
> -        fclose(fus->fp);
> -        remove(fus->lfn);
> -        fus->fp = NULL;
> -        /* Do not close the connection just yet, discard remainder of the data.
> -         * This is because at the time of writing some browsers (Chrome) fail to
> -         * render response before all the data is sent. */
> -        return;
> -      }
> -      fus->num_recd += mp->data.len;
> -      LOG(LL_DEBUG, ("%p rec'd %d bytes, %d total", nc, (int) mp->data.len,
> -                     (int) fus->num_recd));
> -      break;
> -    }
> -    case MG_EV_HTTP_PART_END: {
> -      struct mg_http_multipart_part *mp =
> -          (struct mg_http_multipart_part *) ev_data;
> -      struct file_upload_state *fus =
> -          (struct file_upload_state *) mp->user_data;
> -      if (fus == NULL) break;
> -      if (mp->status >= 0 && fus->fp != NULL) {
> -        LOG(LL_DEBUG, ("%p Uploaded %s (%s), %d bytes", nc, mp->file_name,
> -                       fus->lfn, (int) fus->num_recd));
> -      } else {
> -        LOG(LL_ERROR, ("Failed to store %s (%s)", mp->file_name, fus->lfn));
> -        /*
> -         * mp->status < 0 means connection was terminated, so no reason to send
> -         * HTTP reply
> -         */
> -      }
> -      if (fus->fp != NULL) fclose(fus->fp);
> -      MG_FREE(fus->lfn);
> -      MG_FREE(fus);
> -      mp->user_data = NULL;
> -      /* Don't close the connection yet, there may be more files to come. */
> -      break;
> -    }
> -    case MG_EV_HTTP_MULTIPART_REQUEST_END: {
> -      mg_printf(nc,
> -                "HTTP/1.1 200 OK\r\n"
> -                "Content-Type: text/plain\r\n"
> -                "Connection: close\r\n\r\n"
> -                "Ok.\r\n");
> -      nc->flags |= MG_F_SEND_AND_CLOSE;
> -      break;
> -    }
> -  }
> -
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  (void) user_data;
> -#endif
> -}
> -
> -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */
> -#endif /* MG_ENABLE_FILESYSTEM */
> -
> -struct mg_connection *mg_connect_http_base(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *scheme1, const char *scheme2,
> -    const char *scheme_ssl1, const char *scheme_ssl2, const char *url,
> -    struct mg_str *path, struct mg_str *user_info, struct mg_str *host) {
> -  struct mg_connection *nc = NULL;
> -  unsigned int port_i = 0;
> -  int use_ssl = 0;
> -  struct mg_str scheme, query, fragment;
> -  char conn_addr_buf[2];
> -  char *conn_addr = conn_addr_buf;
> -
> -  if (mg_parse_uri(mg_mk_str(url), &scheme, user_info, host, &port_i, path,
> -                   &query, &fragment) != 0) {
> -    MG_SET_PTRPTR(opts.error_string, "cannot parse url");
> -    goto out;
> -  }
> -
> -  /* If query is present, do not strip it. Pass to the caller. */
> -  if (query.len > 0) path->len += query.len + 1;
> -
> -  if (scheme.len == 0 || mg_vcmp(&scheme, scheme1) == 0 ||
> -      (scheme2 != NULL && mg_vcmp(&scheme, scheme2) == 0)) {
> -    use_ssl = 0;
> -    if (port_i == 0) port_i = 80;
> -  } else if (mg_vcmp(&scheme, scheme_ssl1) == 0 ||
> -             (scheme2 != NULL && mg_vcmp(&scheme, scheme_ssl2) == 0)) {
> -    use_ssl = 1;
> -    if (port_i == 0) port_i = 443;
> -  } else {
> -    goto out;
> -  }
> -
> -  mg_asprintf(&conn_addr, sizeof(conn_addr_buf), "tcp://%.*s:%u",
> -              (int) host->len, host->p, port_i);
> -  if (conn_addr == NULL) goto out;
> -
> -  LOG(LL_DEBUG, ("%s use_ssl? %d %s", url, use_ssl, conn_addr));
> -  if (use_ssl) {
> -#if MG_ENABLE_SSL
> -    /*
> -     * Schema requires SSL, but no SSL parameters were provided in opts.
> -     * In order to maintain backward compatibility, use a faux-SSL with no
> -     * verification.
> -     */
> -    if (opts.ssl_ca_cert == NULL) {
> -      opts.ssl_ca_cert = "*";
> -    }
> -#else
> -    MG_SET_PTRPTR(opts.error_string, "ssl is disabled");
> -    goto out;
> -#endif
> -  }
> -
> -  if ((nc = mg_connect_opt(mgr, conn_addr, MG_CB(ev_handler, user_data),
> -                           opts)) != NULL) {
> -    mg_set_protocol_http_websocket(nc);
> -  }
> -
> -out:
> -  if (conn_addr != NULL && conn_addr != conn_addr_buf) MG_FREE(conn_addr);
> -  return nc;
> -}
> -
> -struct mg_connection *mg_connect_http_opt(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *url, const char *extra_headers,
> -    const char *post_data) {
> -  struct mg_str user = MG_NULL_STR, null_str = MG_NULL_STR;
> -  struct mg_str host = MG_NULL_STR, path = MG_NULL_STR;
> -  struct mbuf auth;
> -  struct mg_connection *nc =
> -      mg_connect_http_base(mgr, MG_CB(ev_handler, user_data), opts, "http",
> -                           NULL, "https", NULL, url, &path, &user, &host);
> -
> -  if (nc == NULL) {
> -    return NULL;
> -  }
> -
> -  mbuf_init(&auth, 0);
> -  if (user.len > 0) {
> -    mg_basic_auth_header(user, null_str, &auth);
> -  }
> -
> -  if (post_data == NULL) post_data = "";
> -  if (extra_headers == NULL) extra_headers = "";
> -  if (path.len == 0) path = mg_mk_str("/");
> -  if (host.len == 0) host = mg_mk_str("");
> -
> -  mg_printf(nc,
> -            "%s %.*s HTTP/1.1\r\nHost: %.*s\r\nContent-Length: %" SIZE_T_FMT
> -            "\r\n%.*s%s\r\n%s",
> -            (post_data[0] == '\0' ? "GET" : "POST"), (int) path.len, path.p,
> -            (int) (path.p - host.p), host.p, strlen(post_data), (int) auth.len,
> -            (auth.buf == NULL ? "" : auth.buf), extra_headers, post_data);
> -
> -  mbuf_free(&auth);
> -  return nc;
> -}
> -
> -struct mg_connection *mg_connect_http(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    const char *url, const char *extra_headers, const char *post_data) {
> -  struct mg_connect_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_connect_http_opt(mgr, MG_CB(ev_handler, user_data), opts, url,
> -                             extra_headers, post_data);
> -}
> -
> -size_t mg_parse_multipart(const char *buf, size_t buf_len, char *var_name,
> -                          size_t var_name_len, char *file_name,
> -                          size_t file_name_len, const char **data,
> -                          size_t *data_len) {
> -  static const char cd[] = "Content-Disposition: ";
> -  size_t hl, bl, n, ll, pos, cdl = sizeof(cd) - 1;
> -  int shl;
> -
> -  if (buf == NULL || buf_len <= 0) return 0;
> -  if ((shl = mg_http_get_request_len(buf, buf_len)) <= 0) return 0;
> -  hl = shl;
> -  if (buf[0] != '-' || buf[1] != '-' || buf[2] == '\n') return 0;
> -
> -  /* Get boundary length */
> -  bl = mg_get_line_len(buf, buf_len);
> -
> -  /* Loop through headers, fetch variable name and file name */
> -  var_name[0] = file_name[0] = '\0';
> -  for (n = bl; (ll = mg_get_line_len(buf + n, hl - n)) > 0; n += ll) {
> -    if (mg_ncasecmp(cd, buf + n, cdl) == 0) {
> -      struct mg_str header;
> -      header.p = buf + n + cdl;
> -      header.len = ll - (cdl + 2);
> -      {
> -        char *var_name2 = var_name;
> -        mg_http_parse_header2(&header, "name", &var_name2, var_name_len);
> -        /* TODO: handle reallocated buffer correctly */
> -        if (var_name2 != var_name) {
> -          MG_FREE(var_name2);
> -          var_name[0] = '\0';
> -        }
> -      }
> -      {
> -        char *file_name2 = file_name;
> -        mg_http_parse_header2(&header, "filename", &file_name2, file_name_len);
> -        /* TODO: handle reallocated buffer correctly */
> -        if (file_name2 != file_name) {
> -          MG_FREE(file_name2);
> -          file_name[0] = '\0';
> -        }
> -      }
> -    }
> -  }
> -
> -  /* Scan through the body, search for terminating boundary */
> -  for (pos = hl; pos + (bl - 2) < buf_len; pos++) {
> -    if (buf[pos] == '-' && !strncmp(buf, &buf[pos], bl - 2)) {
> -      if (data_len != NULL) *data_len = (pos - 2) - hl;
> -      if (data != NULL) *data = buf + hl;
> -      return pos;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -void mg_register_http_endpoint_opt(struct mg_connection *nc,
> -                                   const char *uri_path,
> -                                   mg_event_handler_t handler,
> -                                   struct mg_http_endpoint_opts opts) {
> -  struct mg_http_proto_data *pd = NULL;
> -  struct mg_http_endpoint *new_ep = NULL;
> -
> -  if (nc == NULL) return;
> -  new_ep = (struct mg_http_endpoint *) MG_CALLOC(1, sizeof(*new_ep));
> -  if (new_ep == NULL) return;
> -
> -  pd = mg_http_get_proto_data(nc);
> -  if (pd == NULL) pd = mg_http_create_proto_data(nc);
> -  new_ep->uri_pattern = mg_strdup(mg_mk_str(uri_path));
> -  if (opts.auth_domain != NULL && opts.auth_file != NULL) {
> -    new_ep->auth_domain = strdup(opts.auth_domain);
> -    new_ep->auth_file = strdup(opts.auth_file);
> -  }
> -  new_ep->handler = handler;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  new_ep->user_data = opts.user_data;
> -#endif
> -  new_ep->next = pd->endpoints;
> -  pd->endpoints = new_ep;
> -}
> -
> -static void mg_http_call_endpoint_handler(struct mg_connection *nc, int ev,
> -                                          struct http_message *hm) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  void *user_data = nc->user_data;
> -
> -  if (ev == MG_EV_HTTP_REQUEST
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -      || ev == MG_EV_HTTP_MULTIPART_REQUEST
> -#endif
> -  ) {
> -    struct mg_http_endpoint *ep =
> -        mg_http_get_endpoint_handler(nc->listener, &hm->uri);
> -    if (ep != NULL) {
> -#if MG_ENABLE_FILESYSTEM && !MG_DISABLE_HTTP_DIGEST_AUTH
> -      if (!mg_http_is_authorized(hm, hm->uri, ep->auth_domain, ep->auth_file,
> -                                 MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE)) {
> -        mg_http_send_digest_auth_request(nc, ep->auth_domain);
> -        return;
> -      }
> -#endif
> -      pd->endpoint_handler = ep->handler;
> -#if MG_ENABLE_CALLBACK_USERDATA
> -      user_data = ep->user_data;
> -#endif
> -    }
> -  }
> -  mg_call(nc, pd->endpoint_handler ? pd->endpoint_handler : nc->handler,
> -          user_data, ev, hm);
> -}
> -
> -void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path,
> -                               MG_CB(mg_event_handler_t handler,
> -                                     void *user_data)) {
> -  struct mg_http_endpoint_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  opts.user_data = user_data;
> -#endif
> -  mg_register_http_endpoint_opt(nc, uri_path, handler, opts);
> -}
> -
> -#endif /* MG_ENABLE_HTTP */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_cgi.c"
> -#endif
> -
> -#ifndef _WIN32
> -#include <signal.h>
> -#endif
> -
> -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI
> -
> -#ifndef MG_MAX_CGI_ENVIR_VARS
> -#define MG_MAX_CGI_ENVIR_VARS 64
> -#endif
> -
> -#ifndef MG_ENV_EXPORT_TO_CGI
> -#define MG_ENV_EXPORT_TO_CGI "MONGOOSE_CGI"
> -#endif
> -
> -#define MG_F_HTTP_CGI_PARSE_HEADERS MG_F_USER_1
> -
> -/*
> - * This structure helps to create an environment for the spawned CGI program.
> - * Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings,
> - * last element must be NULL.
> - * However, on Windows there is a requirement that all these VARIABLE=VALUE\0
> - * strings must reside in a contiguous buffer. The end of the buffer is
> - * marked by two '\0' characters.
> - * We satisfy both worlds: we create an envp array (which is vars), all
> - * entries are actually pointers inside buf.
> - */
> -struct mg_cgi_env_block {
> -  struct mg_connection *nc;
> -  char buf[MG_CGI_ENVIRONMENT_SIZE];       /* Environment buffer */
> -  const char *vars[MG_MAX_CGI_ENVIR_VARS]; /* char *envp[] */
> -  int len;                                 /* Space taken */
> -  int nvars;                               /* Number of variables in envp[] */
> -};
> -
> -#ifdef _WIN32
> -struct mg_threadparam {
> -  sock_t s;
> -  HANDLE hPipe;
> -};
> -
> -static int mg_wait_until_ready(sock_t sock, int for_read) {
> -  fd_set set;
> -  FD_ZERO(&set);
> -  FD_SET(sock, &set);
> -  return select(sock + 1, for_read ? &set : 0, for_read ? 0 : &set, 0, 0) == 1;
> -}
> -
> -static void *mg_push_to_stdin(void *arg) {
> -  struct mg_threadparam *tp = (struct mg_threadparam *) arg;
> -  int n, sent, stop = 0;
> -  DWORD k;
> -  char buf[BUFSIZ];
> -
> -  while (!stop && mg_wait_until_ready(tp->s, 1) &&
> -         (n = recv(tp->s, buf, sizeof(buf), 0)) > 0) {
> -    if (n == -1 && GetLastError() == WSAEWOULDBLOCK) continue;
> -    for (sent = 0; !stop && sent < n; sent += k) {
> -      if (!WriteFile(tp->hPipe, buf + sent, n - sent, &k, 0)) stop = 1;
> -    }
> -  }
> -  DBG(("%s", "FORWARED EVERYTHING TO CGI"));
> -  CloseHandle(tp->hPipe);
> -  MG_FREE(tp);
> -  return NULL;
> -}
> -
> -static void *mg_pull_from_stdout(void *arg) {
> -  struct mg_threadparam *tp = (struct mg_threadparam *) arg;
> -  int k = 0, stop = 0;
> -  DWORD n, sent;
> -  char buf[BUFSIZ];
> -
> -  while (!stop && ReadFile(tp->hPipe, buf, sizeof(buf), &n, NULL)) {
> -    for (sent = 0; !stop && sent < n; sent += k) {
> -      if (mg_wait_until_ready(tp->s, 0) &&
> -          (k = send(tp->s, buf + sent, n - sent, 0)) <= 0)
> -        stop = 1;
> -    }
> -  }
> -  DBG(("%s", "EOF FROM CGI"));
> -  CloseHandle(tp->hPipe);
> -  shutdown(tp->s, 2);  // Without this, IO thread may get truncated data
> -  closesocket(tp->s);
> -  MG_FREE(tp);
> -  return NULL;
> -}
> -
> -static void mg_spawn_stdio_thread(sock_t sock, HANDLE hPipe,
> -                                  void *(*func)(void *)) {
> -  struct mg_threadparam *tp = (struct mg_threadparam *) MG_MALLOC(sizeof(*tp));
> -  if (tp != NULL) {
> -    tp->s = sock;
> -    tp->hPipe = hPipe;
> -    mg_start_thread(func, tp);
> -  }
> -}
> -
> -static void mg_abs_path(const char *utf8_path, char *abs_path, size_t len) {
> -  wchar_t buf[MG_MAX_PATH], buf2[MG_MAX_PATH];
> -  to_wchar(utf8_path, buf, ARRAY_SIZE(buf));
> -  GetFullPathNameW(buf, ARRAY_SIZE(buf2), buf2, NULL);
> -  WideCharToMultiByte(CP_UTF8, 0, buf2, wcslen(buf2) + 1, abs_path, len, 0, 0);
> -}
> -
> -static int mg_start_process(const char *interp, const char *cmd,
> -                            const char *env, const char *envp[],
> -                            const char *dir, sock_t sock) {
> -  STARTUPINFOW si;
> -  PROCESS_INFORMATION pi;
> -  HANDLE a[2], b[2], me = GetCurrentProcess();
> -  wchar_t wcmd[MG_MAX_PATH], full_dir[MG_MAX_PATH];
> -  char buf[MG_MAX_PATH], buf2[MG_MAX_PATH], buf5[MG_MAX_PATH],
> -      buf4[MG_MAX_PATH], cmdline[MG_MAX_PATH];
> -  DWORD flags = DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS;
> -  FILE *fp;
> -
> -  memset(&si, 0, sizeof(si));
> -  memset(&pi, 0, sizeof(pi));
> -
> -  si.cb = sizeof(si);
> -  si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
> -  si.wShowWindow = SW_HIDE;
> -  si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
> -
> -  CreatePipe(&a[0], &a[1], NULL, 0);
> -  CreatePipe(&b[0], &b[1], NULL, 0);
> -  DuplicateHandle(me, a[0], me, &si.hStdInput, 0, TRUE, flags);
> -  DuplicateHandle(me, b[1], me, &si.hStdOutput, 0, TRUE, flags);
> -
> -  if (interp == NULL && (fp = mg_fopen(cmd, "r")) != NULL) {
> -    buf[0] = buf[1] = '\0';
> -    fgets(buf, sizeof(buf), fp);
> -    buf[sizeof(buf) - 1] = '\0';
> -    if (buf[0] == '#' && buf[1] == '!') {
> -      interp = buf + 2;
> -      /* Trim leading spaces: https://github.com/cesanta/mongoose/issues/489 */
> -      while (*interp != '\0' && isspace(*(unsigned char *) interp)) {
> -        interp++;
> -      }
> -    }
> -    fclose(fp);
> -  }
> -
> -  snprintf(buf, sizeof(buf), "%s/%s", dir, cmd);
> -  mg_abs_path(buf, buf2, ARRAY_SIZE(buf2));
> -
> -  mg_abs_path(dir, buf5, ARRAY_SIZE(buf5));
> -  to_wchar(dir, full_dir, ARRAY_SIZE(full_dir));
> -
> -  if (interp != NULL) {
> -    mg_abs_path(interp, buf4, ARRAY_SIZE(buf4));
> -    snprintf(cmdline, sizeof(cmdline), "%s \"%s\"", buf4, buf2);
> -  } else {
> -    snprintf(cmdline, sizeof(cmdline), "\"%s\"", buf2);
> -  }
> -  to_wchar(cmdline, wcmd, ARRAY_SIZE(wcmd));
> -
> -  if (CreateProcessW(NULL, wcmd, NULL, NULL, TRUE, CREATE_NEW_PROCESS_GROUP,
> -                     (void *) env, full_dir, &si, &pi) != 0) {
> -    mg_spawn_stdio_thread(sock, a[1], mg_push_to_stdin);
> -    mg_spawn_stdio_thread(sock, b[0], mg_pull_from_stdout);
> -
> -    CloseHandle(si.hStdOutput);
> -    CloseHandle(si.hStdInput);
> -
> -    CloseHandle(pi.hThread);
> -    CloseHandle(pi.hProcess);
> -  } else {
> -    CloseHandle(a[1]);
> -    CloseHandle(b[0]);
> -    closesocket(sock);
> -  }
> -  DBG(("CGI command: [%ls] -> %p", wcmd, pi.hProcess));
> -
> -  /* Not closing a[0] and b[1] because we've used DUPLICATE_CLOSE_SOURCE */
> -  (void) envp;
> -  return (pi.hProcess != NULL);
> -}
> -#else
> -static int mg_start_process(const char *interp, const char *cmd,
> -                            const char *env, const char *envp[],
> -                            const char *dir, sock_t sock) {
> -  char buf[500];
> -  pid_t pid = fork();
> -  (void) env;
> -
> -  if (pid == 0) {
> -    /*
> -     * In Linux `chdir` declared with `warn_unused_result` attribute
> -     * To shutup compiler we have yo use result in some way
> -     */
> -    int tmp = chdir(dir);
> -    (void) tmp;
> -    (void) dup2(sock, 0);
> -    (void) dup2(sock, 1);
> -    closesocket(sock);
> -
> -    /*
> -     * 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.
> -     */
> -    signal(SIGCHLD, SIG_DFL);
> -
> -    if (interp == NULL) {
> -      execle(cmd, cmd, (char *) 0, envp); /* (char *) 0 to squash warning */
> -    } else {
> -      execle(interp, interp, cmd, (char *) 0, envp);
> -    }
> -    snprintf(buf, sizeof(buf),
> -             "Status: 500\r\n\r\n"
> -             "500 Server Error: %s%s%s: %s",
> -             interp == NULL ? "" : interp, interp == NULL ? "" : " ", cmd,
> -             strerror(errno));
> -    send(1, buf, strlen(buf), 0);
> -    _exit(EXIT_FAILURE); /* exec call failed */
> -  }
> -
> -  return (pid != 0);
> -}
> -#endif /* _WIN32 */
> -
> -/*
> - * Append VARIABLE=VALUE\0 string to the buffer, and add a respective
> - * pointer into the vars array.
> - */
> -static char *mg_addenv(struct mg_cgi_env_block *block, const char *fmt, ...) {
> -  int n, space;
> -  char *added = block->buf + block->len;
> -  va_list ap;
> -
> -  /* Calculate how much space is left in the buffer */
> -  space = sizeof(block->buf) - (block->len + 2);
> -  if (space > 0) {
> -    /* Copy VARIABLE=VALUE\0 string into the free space */
> -    va_start(ap, fmt);
> -    n = vsnprintf(added, (size_t) space, fmt, ap);
> -    va_end(ap);
> -
> -    /* Make sure we do not overflow buffer and the envp array */
> -    if (n > 0 && n + 1 < space &&
> -        block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
> -      /* Append a pointer to the added string into the envp array */
> -      block->vars[block->nvars++] = added;
> -      /* Bump up used length counter. Include \0 terminator */
> -      block->len += n + 1;
> -    }
> -  }
> -
> -  return added;
> -}
> -
> -static void mg_addenv2(struct mg_cgi_env_block *blk, const char *name) {
> -  const char *s;
> -  if ((s = getenv(name)) != NULL) mg_addenv(blk, "%s=%s", name, s);
> -}
> -
> -static void mg_prepare_cgi_environment(struct mg_connection *nc,
> -                                       const char *prog,
> -                                       const struct mg_str *path_info,
> -                                       const struct http_message *hm,
> -                                       const struct mg_serve_http_opts *opts,
> -                                       struct mg_cgi_env_block *blk) {
> -  const char *s;
> -  struct mg_str *h;
> -  char *p;
> -  size_t i;
> -  char buf[100];
> -  size_t path_info_len = path_info != NULL ? path_info->len : 0;
> -
> -  blk->len = blk->nvars = 0;
> -  blk->nc = nc;
> -
> -  if ((s = getenv("SERVER_NAME")) != NULL) {
> -    mg_addenv(blk, "SERVER_NAME=%s", s);
> -  } else {
> -    mg_sock_to_str(nc->sock, buf, sizeof(buf), 3);
> -    mg_addenv(blk, "SERVER_NAME=%s", buf);
> -  }
> -  mg_addenv(blk, "SERVER_ROOT=%s", opts->document_root);
> -  mg_addenv(blk, "DOCUMENT_ROOT=%s", opts->document_root);
> -  mg_addenv(blk, "SERVER_SOFTWARE=%s/%s", "Mongoose", MG_VERSION);
> -
> -  /* Prepare the environment block */
> -  mg_addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1");
> -  mg_addenv(blk, "%s", "SERVER_PROTOCOL=HTTP/1.1");
> -  mg_addenv(blk, "%s", "REDIRECT_STATUS=200"); /* For PHP */
> -
> -  mg_addenv(blk, "REQUEST_METHOD=%.*s", (int) hm->method.len, hm->method.p);
> -
> -  mg_addenv(blk, "REQUEST_URI=%.*s%s%.*s", (int) hm->uri.len, hm->uri.p,
> -            hm->query_string.len == 0 ? "" : "?", (int) hm->query_string.len,
> -            hm->query_string.p);
> -
> -  mg_conn_addr_to_str(nc, buf, sizeof(buf),
> -                      MG_SOCK_STRINGIFY_REMOTE | MG_SOCK_STRINGIFY_IP);
> -  mg_addenv(blk, "REMOTE_ADDR=%s", buf);
> -  mg_conn_addr_to_str(nc, buf, sizeof(buf), MG_SOCK_STRINGIFY_PORT);
> -  mg_addenv(blk, "SERVER_PORT=%s", buf);
> -
> -  s = hm->uri.p + hm->uri.len - path_info_len - 1;
> -  if (*s == '/') {
> -    const char *base_name = strrchr(prog, DIRSEP);
> -    mg_addenv(blk, "SCRIPT_NAME=%.*s/%s", (int) (s - hm->uri.p), hm->uri.p,
> -              (base_name != NULL ? base_name + 1 : prog));
> -  } else {
> -    mg_addenv(blk, "SCRIPT_NAME=%.*s", (int) (s - hm->uri.p + 1), hm->uri.p);
> -  }
> -  mg_addenv(blk, "SCRIPT_FILENAME=%s", prog);
> -
> -  if (path_info != NULL && path_info->len > 0) {
> -    mg_addenv(blk, "PATH_INFO=%.*s", (int) path_info->len, path_info->p);
> -    /* Not really translated... */
> -    mg_addenv(blk, "PATH_TRANSLATED=%.*s", (int) path_info->len, path_info->p);
> -  }
> -
> -#if MG_ENABLE_SSL
> -  mg_addenv(blk, "HTTPS=%s", (nc->flags & MG_F_SSL ? "on" : "off"));
> -#else
> -  mg_addenv(blk, "HTTPS=off");
> -#endif
> -
> -  if ((h = mg_get_http_header((struct http_message *) hm, "Content-Type")) !=
> -      NULL) {
> -    mg_addenv(blk, "CONTENT_TYPE=%.*s", (int) h->len, h->p);
> -  }
> -
> -  if (hm->query_string.len > 0) {
> -    mg_addenv(blk, "QUERY_STRING=%.*s", (int) hm->query_string.len,
> -              hm->query_string.p);
> -  }
> -
> -  if ((h = mg_get_http_header((struct http_message *) hm, "Content-Length")) !=
> -      NULL) {
> -    mg_addenv(blk, "CONTENT_LENGTH=%.*s", (int) h->len, h->p);
> -  }
> -
> -  mg_addenv2(blk, "PATH");
> -  mg_addenv2(blk, "TMP");
> -  mg_addenv2(blk, "TEMP");
> -  mg_addenv2(blk, "TMPDIR");
> -  mg_addenv2(blk, "PERLLIB");
> -  mg_addenv2(blk, MG_ENV_EXPORT_TO_CGI);
> -
> -#ifdef _WIN32
> -  mg_addenv2(blk, "COMSPEC");
> -  mg_addenv2(blk, "SYSTEMROOT");
> -  mg_addenv2(blk, "SystemDrive");
> -  mg_addenv2(blk, "ProgramFiles");
> -  mg_addenv2(blk, "ProgramFiles(x86)");
> -  mg_addenv2(blk, "CommonProgramFiles(x86)");
> -#else
> -  mg_addenv2(blk, "LD_LIBRARY_PATH");
> -#endif /* _WIN32 */
> -
> -  /* Add all headers as HTTP_* variables */
> -  for (i = 0; hm->header_names[i].len > 0; i++) {
> -    p = mg_addenv(blk, "HTTP_%.*s=%.*s", (int) hm->header_names[i].len,
> -                  hm->header_names[i].p, (int) hm->header_values[i].len,
> -                  hm->header_values[i].p);
> -
> -    /* Convert variable name into uppercase, and change - to _ */
> -    for (; *p != '=' && *p != '\0'; p++) {
> -      if (*p == '-') *p = '_';
> -      *p = (char) toupper(*(unsigned char *) p);
> -    }
> -  }
> -
> -  blk->vars[blk->nvars++] = NULL;
> -  blk->buf[blk->len++] = '\0';
> -}
> -
> -static void mg_cgi_ev_handler(struct mg_connection *cgi_nc, int ev,
> -                              void *ev_data MG_UD_ARG(void *user_data)) {
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -  void *user_data = cgi_nc->user_data;
> -#endif
> -  struct mg_connection *nc = (struct mg_connection *) user_data;
> -  (void) ev_data;
> -
> -  if (nc == NULL) {
> -    /* The corresponding network connection was closed. */
> -    cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    return;
> -  }
> -
> -  switch (ev) {
> -    case MG_EV_RECV:
> -      /*
> -       * CGI script does not output reply line, like "HTTP/1.1 CODE XXXXX\n"
> -       * It outputs headers, then body. Headers might include "Status"
> -       * header, which changes CODE, and it might include "Location" header
> -       * which changes CODE to 302.
> -       *
> -       * Therefore we do not send the output from the CGI script to the user
> -       * until all CGI headers are received.
> -       *
> -       * Here we parse the output from the CGI script, and if all headers has
> -       * been received, send appropriate reply line, and forward all
> -       * received headers to the client.
> -       */
> -      if (nc->flags & MG_F_HTTP_CGI_PARSE_HEADERS) {
> -        struct mbuf *io = &cgi_nc->recv_mbuf;
> -        int len = mg_http_get_request_len(io->buf, io->len);
> -
> -        if (len == 0) break;
> -        if (len < 0 || io->len > MG_MAX_HTTP_REQUEST_SIZE) {
> -          cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -          mg_http_send_error(nc, 500, "Bad headers");
> -        } else {
> -          struct http_message hm;
> -          struct mg_str *h;
> -          mg_http_parse_headers(io->buf, io->buf + io->len, io->len, &hm);
> -          if (mg_get_http_header(&hm, "Location") != NULL) {
> -            mg_printf(nc, "%s", "HTTP/1.1 302 Moved\r\n");
> -          } else if ((h = mg_get_http_header(&hm, "Status")) != NULL) {
> -            mg_printf(nc, "HTTP/1.1 %.*s\r\n", (int) h->len, h->p);
> -          } else {
> -            mg_printf(nc, "%s", "HTTP/1.1 200 OK\r\n");
> -          }
> -        }
> -        nc->flags &= ~MG_F_HTTP_CGI_PARSE_HEADERS;
> -      }
> -      if (!(nc->flags & MG_F_HTTP_CGI_PARSE_HEADERS)) {
> -        mg_forward(cgi_nc, nc);
> -      }
> -      break;
> -    case MG_EV_CLOSE:
> -      DBG(("%p CLOSE", cgi_nc));
> -      mg_http_free_proto_data_cgi(&mg_http_get_proto_data(nc)->cgi);
> -      nc->flags |= MG_F_SEND_AND_CLOSE;
> -      break;
> -  }
> -}
> -
> -MG_INTERNAL void mg_handle_cgi(struct mg_connection *nc, const char *prog,
> -                               const struct mg_str *path_info,
> -                               const struct http_message *hm,
> -                               const struct mg_serve_http_opts *opts) {
> -  struct mg_cgi_env_block blk;
> -  char dir[MG_MAX_PATH];
> -  const char *p;
> -  sock_t fds[2];
> -
> -  DBG(("%p [%s]", nc, prog));
> -  mg_prepare_cgi_environment(nc, prog, path_info, hm, opts, &blk);
> -  /*
> -   * CGI must be executed in its own directory. 'dir' must point to the
> -   * directory containing executable program, 'p' must point to the
> -   * executable program name relative to 'dir'.
> -   */
> -  if ((p = strrchr(prog, DIRSEP)) == NULL) {
> -    snprintf(dir, sizeof(dir), "%s", ".");
> -  } else {
> -    snprintf(dir, sizeof(dir), "%.*s", (int) (p - prog), prog);
> -    prog = p + 1;
> -  }
> -
> -  if (!mg_socketpair(fds, SOCK_STREAM)) {
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    return;
> -  }
> -
> -#ifndef _WIN32
> -  struct sigaction sa;
> -
> -  sigemptyset(&sa.sa_mask);
> -  sa.sa_handler = SIG_IGN;
> -  sa.sa_flags = 0;
> -  sigaction(SIGCHLD, &sa, NULL);
> -#endif
> -
> -  if (mg_start_process(opts->cgi_interpreter, prog, blk.buf, blk.vars, dir,
> -                       fds[1]) != 0) {
> -    struct mg_connection *cgi_nc =
> -        mg_add_sock(nc->mgr, fds[0], mg_cgi_ev_handler MG_UD_ARG(nc));
> -    struct mg_http_proto_data *cgi_pd = mg_http_get_proto_data(nc);
> -    cgi_pd->cgi.cgi_nc = cgi_nc;
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -    cgi_pd->cgi.cgi_nc->user_data = nc;
> -#endif
> -    nc->flags |= MG_F_HTTP_CGI_PARSE_HEADERS;
> -    /* Push POST data to the CGI */
> -    if (hm->body.len > 0) {
> -      mg_send(cgi_pd->cgi.cgi_nc, hm->body.p, hm->body.len);
> -    }
> -    mbuf_remove(&nc->recv_mbuf, nc->recv_mbuf.len);
> -  } else {
> -    closesocket(fds[0]);
> -    mg_http_send_error(nc, 500, "CGI failure");
> -  }
> -
> -#ifndef _WIN32
> -  closesocket(fds[1]); /* On Windows, CGI stdio thread closes that socket */
> -#endif
> -}
> -
> -MG_INTERNAL void mg_http_free_proto_data_cgi(struct mg_http_proto_data_cgi *d) {
> -  if (d == NULL) return;
> -  if (d->cgi_nc != NULL) {
> -    d->cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -    d->cgi_nc->user_data = NULL;
> -  }
> -  memset(d, 0, sizeof(*d));
> -}
> -
> -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_ssi.c"
> -#endif
> -
> -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_SSI && MG_ENABLE_FILESYSTEM
> -
> -static void mg_send_ssi_file(struct mg_connection *nc, struct http_message *hm,
> -                             const char *path, FILE *fp, int include_level,
> -                             const struct mg_serve_http_opts *opts);
> -
> -static void mg_send_file_data(struct mg_connection *nc, FILE *fp) {
> -  char buf[BUFSIZ];
> -  size_t n;
> -  while ((n = mg_fread(buf, 1, sizeof(buf), fp)) > 0) {
> -    mg_send(nc, buf, n);
> -  }
> -}
> -
> -static void mg_do_ssi_include(struct mg_connection *nc, struct http_message *hm,
> -                              const char *ssi, char *tag, int include_level,
> -                              const struct mg_serve_http_opts *opts) {
> -  char file_name[MG_MAX_PATH], path[MG_MAX_PATH], *p;
> -  FILE *fp;
> -
> -  /*
> -   * sscanf() is safe here, since send_ssi_file() also uses buffer
> -   * of size MG_BUF_LEN to get the tag. So strlen(tag) is always < MG_BUF_LEN.
> -   */
> -  if (sscanf(tag, " virtual=\"%[^\"]\"", file_name) == 1) {
> -    /* File name is relative to the webserver root */
> -    snprintf(path, sizeof(path), "%s/%s", opts->document_root, file_name);
> -  } else if (sscanf(tag, " abspath=\"%[^\"]\"", file_name) == 1) {
> -    /*
> -     * File name is relative to the webserver working directory
> -     * or it is absolute system path
> -     */
> -    snprintf(path, sizeof(path), "%s", file_name);
> -  } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1 ||
> -             sscanf(tag, " \"%[^\"]\"", file_name) == 1) {
> -    /* File name is relative to the currect document */
> -    snprintf(path, sizeof(path), "%s", ssi);
> -    if ((p = strrchr(path, DIRSEP)) != NULL) {
> -      p[1] = '\0';
> -    }
> -    snprintf(path + strlen(path), sizeof(path) - strlen(path), "%s", file_name);
> -  } else {
> -    mg_printf(nc, "Bad SSI #include: [%s]", tag);
> -    return;
> -  }
> -
> -  if ((fp = mg_fopen(path, "rb")) == NULL) {
> -    mg_printf(nc, "SSI include error: mg_fopen(%s): %s", path,
> -              strerror(mg_get_errno()));
> -  } else {
> -    mg_set_close_on_exec((sock_t) fileno(fp));
> -    if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) >
> -        0) {
> -      mg_send_ssi_file(nc, hm, path, fp, include_level + 1, opts);
> -    } else {
> -      mg_send_file_data(nc, fp);
> -    }
> -    fclose(fp);
> -  }
> -}
> -
> -#if MG_ENABLE_HTTP_SSI_EXEC
> -static void do_ssi_exec(struct mg_connection *nc, char *tag) {
> -  char cmd[BUFSIZ];
> -  FILE *fp;
> -
> -  if (sscanf(tag, " \"%[^\"]\"", cmd) != 1) {
> -    mg_printf(nc, "Bad SSI #exec: [%s]", tag);
> -  } else if ((fp = popen(cmd, "r")) == NULL) {
> -    mg_printf(nc, "Cannot SSI #exec: [%s]: %s", cmd, strerror(mg_get_errno()));
> -  } else {
> -    mg_send_file_data(nc, fp);
> -    pclose(fp);
> -  }
> -}
> -#endif /* MG_ENABLE_HTTP_SSI_EXEC */
> -
> -/*
> - * SSI directive has the following format:
> - * <!--#directive parameter=value parameter=value -->
> - */
> -static void mg_send_ssi_file(struct mg_connection *nc, struct http_message *hm,
> -                             const char *path, FILE *fp, int include_level,
> -                             const struct mg_serve_http_opts *opts) {
> -  static const struct mg_str btag = MG_MK_STR("<!--#");
> -  static const struct mg_str d_include = MG_MK_STR("include");
> -  static const struct mg_str d_call = MG_MK_STR("call");
> -#if MG_ENABLE_HTTP_SSI_EXEC
> -  static const struct mg_str d_exec = MG_MK_STR("exec");
> -#endif
> -  char buf[BUFSIZ], *p = buf + btag.len; /* p points to SSI directive */
> -  int ch, len, in_ssi_tag;
> -
> -  if (include_level > 10) {
> -    mg_printf(nc, "SSI #include level is too deep (%s)", path);
> -    return;
> -  }
> -
> -  in_ssi_tag = len = 0;
> -  while ((ch = fgetc(fp)) != EOF) {
> -    if (in_ssi_tag && ch == '>' && buf[len - 1] == '-' && buf[len - 2] == '-') {
> -      size_t i = len - 2;
> -      in_ssi_tag = 0;
> -
> -      /* Trim closing --> */
> -      buf[i--] = '\0';
> -      while (i > 0 && buf[i] == ' ') {
> -        buf[i--] = '\0';
> -      }
> -
> -      /* Handle known SSI directives */
> -      if (strncmp(p, d_include.p, d_include.len) == 0) {
> -        mg_do_ssi_include(nc, hm, path, p + d_include.len + 1, include_level,
> -                          opts);
> -      } else if (strncmp(p, d_call.p, d_call.len) == 0) {
> -        struct mg_ssi_call_ctx cctx;
> -        memset(&cctx, 0, sizeof(cctx));
> -        cctx.req = hm;
> -        cctx.file = mg_mk_str(path);
> -        cctx.arg = mg_mk_str(p + d_call.len + 1);
> -        mg_call(nc, NULL, nc->user_data, MG_EV_SSI_CALL,
> -                (void *) cctx.arg.p); /* NUL added above */
> -        mg_call(nc, NULL, nc->user_data, MG_EV_SSI_CALL_CTX, &cctx);
> -#if MG_ENABLE_HTTP_SSI_EXEC
> -      } else if (strncmp(p, d_exec.p, d_exec.len) == 0) {
> -        do_ssi_exec(nc, p + d_exec.len + 1);
> -#endif
> -      } else {
> -        /* Silently ignore unknown SSI directive. */
> -      }
> -      len = 0;
> -    } else if (ch == '<') {
> -      in_ssi_tag = 1;
> -      if (len > 0) {
> -        mg_send(nc, buf, (size_t) len);
> -      }
> -      len = 0;
> -      buf[len++] = ch & 0xff;
> -    } else if (in_ssi_tag) {
> -      if (len == (int) btag.len && strncmp(buf, btag.p, btag.len) != 0) {
> -        /* Not an SSI tag */
> -        in_ssi_tag = 0;
> -      } else if (len == (int) sizeof(buf) - 2) {
> -        mg_printf(nc, "%s: SSI tag is too large", path);
> -        len = 0;
> -      }
> -      buf[len++] = ch & 0xff;
> -    } else {
> -      buf[len++] = ch & 0xff;
> -      if (len == (int) sizeof(buf)) {
> -        mg_send(nc, buf, (size_t) len);
> -        len = 0;
> -      }
> -    }
> -  }
> -
> -  /* Send the rest of buffered data */
> -  if (len > 0) {
> -    mg_send(nc, buf, (size_t) len);
> -  }
> -}
> -
> -MG_INTERNAL void mg_handle_ssi_request(struct mg_connection *nc,
> -                                       struct http_message *hm,
> -                                       const char *path,
> -                                       const struct mg_serve_http_opts *opts) {
> -  FILE *fp;
> -  struct mg_str mime_type = MG_NULL_STR, encoding = MG_NULL_STR;
> -  DBG(("%p %s", nc, path));
> -
> -  if ((fp = mg_fopen(path, "rb")) == NULL) {
> -    mg_http_send_error(nc, 404, NULL);
> -  } else {
> -    mg_set_close_on_exec((sock_t) fileno(fp));
> -
> -    if (!mg_get_mime_type_encoding(mg_mk_str(path), &mime_type, &encoding,
> -                                   opts)) {
> -      mime_type = mg_mk_str("text/plain");
> -    }
> -    mg_send_response_line(nc, 200, opts->extra_headers);
> -    mg_printf(nc,
> -              "Content-Type: %.*s\r\n"
> -              "Connection: close\r\n",
> -              (int) mime_type.len, mime_type.p);
> -    if (encoding.len > 0) {
> -      mg_printf(nc, "Content-Encoding: %.*s\r\n", (int) encoding.len,
> -                encoding.p);
> -    }
> -    mg_send(nc, "\r\n", 2);
> -    mg_send_ssi_file(nc, hm, path, fp, 0, opts);
> -    fclose(fp);
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  }
> -}
> -
> -#endif /* MG_ENABLE_HTTP_SSI && MG_ENABLE_HTTP && MG_ENABLE_FILESYSTEM */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_webdav.c"
> -#endif
> -
> -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBDAV
> -
> -MG_INTERNAL int mg_is_dav_request(const struct mg_str *s) {
> -  static const char *methods[] = {
> -    "PUT",
> -    "DELETE",
> -    "MKCOL",
> -    "PROPFIND",
> -    "MOVE"
> -#if MG_ENABLE_FAKE_DAVLOCK
> -    ,
> -    "LOCK",
> -    "UNLOCK"
> -#endif
> -  };
> -  size_t i;
> -
> -  for (i = 0; i < ARRAY_SIZE(methods); i++) {
> -    if (mg_vcmp(s, methods[i]) == 0) {
> -      return 1;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -static int mg_mkdir(const char *path, uint32_t mode) {
> -#ifndef _WIN32
> -  return mkdir(path, mode);
> -#else
> -  (void) mode;
> -  return _mkdir(path);
> -#endif
> -}
> -
> -static void mg_print_props(struct mg_connection *nc, const char *name,
> -                           cs_stat_t *stp) {
> -  char mtime[64];
> -  time_t t = stp->st_mtime; /* store in local variable for NDK compile */
> -  struct mg_str name_esc = mg_url_encode(mg_mk_str(name));
> -  mg_gmt_time_string(mtime, sizeof(mtime), &t);
> -  mg_printf(nc,
> -            "<d:response>"
> -            "<d:href>%s</d:href>"
> -            "<d:propstat>"
> -            "<d:prop>"
> -            "<d:resourcetype>%s</d:resourcetype>"
> -            "<d:getcontentlength>%" INT64_FMT
> -            "</d:getcontentlength>"
> -            "<d:getlastmodified>%s</d:getlastmodified>"
> -            "</d:prop>"
> -            "<d:status>HTTP/1.1 200 OK</d:status>"
> -            "</d:propstat>"
> -            "</d:response>\n",
> -            name_esc.p, S_ISDIR(stp->st_mode) ? "<d:collection/>" : "",
> -            (int64_t) stp->st_size, mtime);
> -  free((void *) name_esc.p);
> -}
> -
> -MG_INTERNAL void mg_handle_propfind(struct mg_connection *nc, const char *path,
> -                                    cs_stat_t *stp, struct http_message *hm,
> -                                    struct mg_serve_http_opts *opts) {
> -  static const char header[] =
> -      "HTTP/1.1 207 Multi-Status\r\n"
> -      "Connection: close\r\n"
> -      "Content-Type: text/xml; charset=utf-8\r\n\r\n"
> -      "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
> -      "<d:multistatus xmlns:d='DAV:'>\n";
> -  static const char footer[] = "</d:multistatus>\n";
> -  const struct mg_str *depth = mg_get_http_header(hm, "Depth");
> -
> -  /* Print properties for the requested resource itself */
> -  if (S_ISDIR(stp->st_mode) &&
> -      strcmp(opts->enable_directory_listing, "yes") != 0) {
> -    mg_printf(nc, "%s", "HTTP/1.1 403 Directory Listing Denied\r\n\r\n");
> -  } else {
> -    char uri[MG_MAX_PATH];
> -    mg_send(nc, header, sizeof(header) - 1);
> -    snprintf(uri, sizeof(uri), "%.*s", (int) hm->uri.len, hm->uri.p);
> -    mg_print_props(nc, uri, stp);
> -    if (S_ISDIR(stp->st_mode) && (depth == NULL || mg_vcmp(depth, "0") != 0)) {
> -      mg_scan_directory(nc, path, opts, mg_print_props);
> -    }
> -    mg_send(nc, footer, sizeof(footer) - 1);
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  }
> -}
> -
> -#if MG_ENABLE_FAKE_DAVLOCK
> -/*
> - * Windows explorer (probably there are another WebDav clients like it)
> - * requires LOCK support in webdav. W/out this, it still works, but fails
> - * to save file: shows error message and offers "Save As".
> - * "Save as" works, but this message is very annoying.
> - * This is fake lock, which doesn't lock something, just returns LOCK token,
> - * UNLOCK always answers "OK".
> - * With this fake LOCK Windows Explorer looks happy and saves file.
> - * NOTE: that is not DAV LOCK imlementation, it is just a way to shut up
> - * Windows native DAV client. This is why FAKE LOCK is not enabed by default
> - */
> -MG_INTERNAL void mg_handle_lock(struct mg_connection *nc, const char *path) {
> -  static const char *reply =
> -      "HTTP/1.1 207 Multi-Status\r\n"
> -      "Connection: close\r\n"
> -      "Content-Type: text/xml; charset=utf-8\r\n\r\n"
> -      "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
> -      "<d:multistatus xmlns:d='DAV:'>\n"
> -      "<D:lockdiscovery>\n"
> -      "<D:activelock>\n"
> -      "<D:locktoken>\n"
> -      "<D:href>\n"
> -      "opaquelocktoken:%s%u"
> -      "</D:href>"
> -      "</D:locktoken>"
> -      "</D:activelock>\n"
> -      "</D:lockdiscovery>"
> -      "</d:multistatus>\n";
> -  mg_printf(nc, reply, path, (unsigned int) mg_time());
> -  nc->flags |= MG_F_SEND_AND_CLOSE;
> -}
> -#endif
> -
> -MG_INTERNAL void mg_handle_mkcol(struct mg_connection *nc, const char *path,
> -                                 struct http_message *hm) {
> -  int status_code = 500;
> -  if (hm->body.len != (size_t) ~0 && hm->body.len > 0) {
> -    status_code = 415;
> -  } else if (!mg_mkdir(path, 0755)) {
> -    status_code = 201;
> -  } else if (errno == EEXIST) {
> -    status_code = 405;
> -  } else if (errno == EACCES) {
> -    status_code = 403;
> -  } else if (errno == ENOENT) {
> -    status_code = 409;
> -  } else {
> -    status_code = 500;
> -  }
> -  mg_http_send_error(nc, status_code, NULL);
> -}
> -
> -static int mg_remove_directory(const struct mg_serve_http_opts *opts,
> -                               const char *dir) {
> -  char path[MG_MAX_PATH];
> -  struct dirent *dp;
> -  cs_stat_t st;
> -  DIR *dirp;
> -
> -  if ((dirp = opendir(dir)) == NULL) return 0;
> -
> -  while ((dp = readdir(dirp)) != NULL) {
> -    if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) {
> -      continue;
> -    }
> -    snprintf(path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
> -    mg_stat(path, &st);
> -    if (S_ISDIR(st.st_mode)) {
> -      mg_remove_directory(opts, path);
> -    } else {
> -      remove(path);
> -    }
> -  }
> -  closedir(dirp);
> -  rmdir(dir);
> -
> -  return 1;
> -}
> -
> -MG_INTERNAL void mg_handle_move(struct mg_connection *c,
> -                                const struct mg_serve_http_opts *opts,
> -                                const char *path, struct http_message *hm) {
> -  const struct mg_str *dest = mg_get_http_header(hm, "Destination");
> -  if (dest == NULL) {
> -    mg_http_send_error(c, 411, NULL);
> -  } else {
> -    const char *p = (char *) memchr(dest->p, '/', dest->len);
> -    if (p != NULL && p[1] == '/' &&
> -        (p = (char *) memchr(p + 2, '/', dest->p + dest->len - p)) != NULL) {
> -      char buf[MG_MAX_PATH];
> -      snprintf(buf, sizeof(buf), "%s%.*s", opts->dav_document_root,
> -               (int) (dest->p + dest->len - p), p);
> -      if (rename(path, buf) == 0) {
> -        mg_http_send_error(c, 200, NULL);
> -      } else {
> -        mg_http_send_error(c, 418, NULL);
> -      }
> -    } else {
> -      mg_http_send_error(c, 500, NULL);
> -    }
> -  }
> -}
> -
> -MG_INTERNAL void mg_handle_delete(struct mg_connection *nc,
> -                                  const struct mg_serve_http_opts *opts,
> -                                  const char *path) {
> -  cs_stat_t st;
> -  if (mg_stat(path, &st) != 0) {
> -    mg_http_send_error(nc, 404, NULL);
> -  } else if (S_ISDIR(st.st_mode)) {
> -    mg_remove_directory(opts, path);
> -    mg_http_send_error(nc, 204, NULL);
> -  } else if (remove(path) == 0) {
> -    mg_http_send_error(nc, 204, NULL);
> -  } else {
> -    mg_http_send_error(nc, 423, NULL);
> -  }
> -}
> -
> -/* Return -1 on error, 1 on success. */
> -static int mg_create_itermediate_directories(const char *path) {
> -  const char *s;
> -
> -  /* Create intermediate directories if they do not exist */
> -  for (s = path + 1; *s != '\0'; s++) {
> -    if (*s == '/') {
> -      char buf[MG_MAX_PATH];
> -      cs_stat_t st;
> -      snprintf(buf, sizeof(buf), "%.*s", (int) (s - path), path);
> -      buf[sizeof(buf) - 1] = '\0';
> -      if (mg_stat(buf, &st) != 0 && mg_mkdir(buf, 0755) != 0) {
> -        return -1;
> -      }
> -    }
> -  }
> -
> -  return 1;
> -}
> -
> -MG_INTERNAL void mg_handle_put(struct mg_connection *nc, const char *path,
> -                               struct http_message *hm) {
> -  struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
> -  cs_stat_t st;
> -  const struct mg_str *cl_hdr = mg_get_http_header(hm, "Content-Length");
> -  int rc, status_code = mg_stat(path, &st) == 0 ? 200 : 201;
> -
> -  mg_http_free_proto_data_file(&pd->file);
> -  if ((rc = mg_create_itermediate_directories(path)) == 0) {
> -    mg_printf(nc, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n", status_code);
> -  } else if (rc == -1) {
> -    mg_http_send_error(nc, 500, NULL);
> -  } else if (cl_hdr == NULL) {
> -    mg_http_send_error(nc, 411, NULL);
> -  } else if ((pd->file.fp = mg_fopen(path, "w+b")) == NULL) {
> -    mg_http_send_error(nc, 500, NULL);
> -  } else {
> -    const struct mg_str *range_hdr = mg_get_http_header(hm, "Content-Range");
> -    int64_t r1 = 0, r2 = 0;
> -    pd->file.type = DATA_PUT;
> -    mg_set_close_on_exec((sock_t) fileno(pd->file.fp));
> -    pd->file.cl = to64(cl_hdr->p);
> -    if (range_hdr != NULL &&
> -        mg_http_parse_range_header(range_hdr, &r1, &r2) > 0) {
> -      status_code = 206;
> -      fseeko(pd->file.fp, r1, SEEK_SET);
> -      pd->file.cl = r2 > r1 ? r2 - r1 + 1 : pd->file.cl - r1;
> -    }
> -    mg_printf(nc, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n", status_code);
> -    /* Remove HTTP request from the mbuf, leave only payload */
> -    mbuf_remove(&nc->recv_mbuf, hm->message.len - hm->body.len);
> -    mg_http_transfer_file_data(nc);
> -  }
> -}
> -
> -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBDAV */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_websocket.c"
> -#endif
> -
> -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBSOCKET
> -
> -/* Amalgamated: #include "common/cs_sha1.h" */
> -
> -#ifndef MG_WEBSOCKET_PING_INTERVAL_SECONDS
> -#define MG_WEBSOCKET_PING_INTERVAL_SECONDS 5
> -#endif
> -
> -#define FLAGS_MASK_FIN (1 << 7)
> -#define FLAGS_MASK_OP 0x0f
> -
> -static int mg_is_ws_fragment(unsigned char flags) {
> -  return (flags & FLAGS_MASK_FIN) == 0 ||
> -         (flags & FLAGS_MASK_OP) == WEBSOCKET_OP_CONTINUE;
> -}
> -
> -static int mg_is_ws_first_fragment(unsigned char flags) {
> -  return (flags & FLAGS_MASK_FIN) == 0 &&
> -         (flags & FLAGS_MASK_OP) != WEBSOCKET_OP_CONTINUE;
> -}
> -
> -static int mg_is_ws_control_frame(unsigned char flags) {
> -  unsigned char op = (flags & FLAGS_MASK_OP);
> -  return op == WEBSOCKET_OP_CLOSE || op == WEBSOCKET_OP_PING ||
> -         op == WEBSOCKET_OP_PONG;
> -}
> -
> -static void mg_handle_incoming_websocket_frame(struct mg_connection *nc,
> -                                               struct websocket_message *wsm) {
> -  if (wsm->flags & 0x8) {
> -    mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_CONTROL_FRAME, wsm);
> -  } else {
> -    mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_FRAME, wsm);
> -  }
> -}
> -
> -static struct mg_ws_proto_data *mg_ws_get_proto_data(struct mg_connection *nc) {
> -  struct mg_http_proto_data *htd = mg_http_get_proto_data(nc);
> -  return (htd != NULL ? &htd->ws_data : NULL);
> -}
> -
> -/*
> - * Sends a Close websocket frame with the given data, and closes the underlying
> - * connection. If `len` is ~0, strlen(data) is used.
> - */
> -static void mg_ws_close(struct mg_connection *nc, const void *data,
> -                        size_t len) {
> -  if ((int) len == ~0) {
> -    len = strlen((const char *) data);
> -  }
> -  mg_send_websocket_frame(nc, WEBSOCKET_OP_CLOSE, data, len);
> -  nc->flags |= MG_F_SEND_AND_CLOSE;
> -}
> -
> -static int mg_deliver_websocket_data(struct mg_connection *nc) {
> -  /* Using unsigned char *, cause of integer arithmetic below */
> -  uint64_t i, data_len = 0, frame_len = 0, new_data_len = nc->recv_mbuf.len,
> -              len, mask_len = 0, header_len = 0;
> -  struct mg_ws_proto_data *wsd = mg_ws_get_proto_data(nc);
> -  unsigned char *new_data = (unsigned char *) nc->recv_mbuf.buf,
> -                *e = (unsigned char *) nc->recv_mbuf.buf + nc->recv_mbuf.len;
> -  uint8_t flags;
> -  int ok, reass;
> -
> -  if (wsd->reass_len > 0) {
> -    /*
> -     * We already have some previously received data which we need to
> -     * reassemble and deliver to the client code when we get the final
> -     * fragment.
> -     *
> -     * NOTE: it doesn't mean that the current message must be a continuation:
> -     * it might be a control frame (Close, Ping or Pong), which should be
> -     * handled without breaking the fragmented message.
> -     */
> -
> -    size_t existing_len = wsd->reass_len;
> -    assert(new_data_len >= existing_len);
> -
> -    new_data += existing_len;
> -    new_data_len -= existing_len;
> -  }
> -
> -  flags = new_data[0];
> -
> -  reass = new_data_len > 0 && mg_is_ws_fragment(flags) &&
> -          !(nc->flags & MG_F_WEBSOCKET_NO_DEFRAG);
> -
> -  if (reass && mg_is_ws_control_frame(flags)) {
> -    /*
> -     * Control frames can't be fragmented, so if we encounter fragmented
> -     * control frame, close connection immediately.
> -     */
> -    mg_ws_close(nc, "fragmented control frames are illegal", ~0);
> -    return 0;
> -  } else if (new_data_len > 0 && !reass && !mg_is_ws_control_frame(flags) &&
> -             wsd->reass_len > 0) {
> -    /*
> -     * When in the middle of a fragmented message, only the continuations
> -     * and control frames are allowed.
> -     */
> -    mg_ws_close(nc, "non-continuation in the middle of a fragmented message",
> -                ~0);
> -    return 0;
> -  }
> -
> -  if (new_data_len >= 2) {
> -    len = new_data[1] & 0x7f;
> -    mask_len = new_data[1] & FLAGS_MASK_FIN ? 4 : 0;
> -    if (len < 126 && new_data_len >= mask_len) {
> -      data_len = len;
> -      header_len = 2 + mask_len;
> -    } else if (len == 126 && new_data_len >= 4 + mask_len) {
> -      header_len = 4 + mask_len;
> -      data_len = ntohs(*(uint16_t *) &new_data[2]);
> -    } else if (new_data_len >= 10 + mask_len) {
> -      header_len = 10 + mask_len;
> -      data_len = (((uint64_t) ntohl(*(uint32_t *) &new_data[2])) << 32) +
> -                 ntohl(*(uint32_t *) &new_data[6]);
> -    }
> -  }
> -
> -  frame_len = header_len + data_len;
> -  ok = (frame_len > 0 && frame_len <= new_data_len);
> -
> -  /* Check for overflow */
> -  if (frame_len < header_len || frame_len < data_len) {
> -    ok = 0;
> -    mg_ws_close(nc, "overflowed message", ~0);
> -  }
> -
> -  if (ok) {
> -    size_t cleanup_len = 0;
> -    struct websocket_message wsm;
> -
> -    wsm.size = (size_t) data_len;
> -    wsm.data = new_data + header_len;
> -    wsm.flags = flags;
> -
> -    /* Apply mask if necessary */
> -    if (mask_len > 0) {
> -      for (i = 0; i < data_len; i++) {
> -        new_data[i + header_len] ^= (new_data + header_len - mask_len)[i % 4];
> -      }
> -    }
> -
> -    if (reass) {
> -      /* This is a message fragment */
> -
> -      if (mg_is_ws_first_fragment(flags)) {
> -        /*
> -         * On the first fragmented frame, skip the first byte (op) and also
> -         * reset size to 1 (op), it'll be incremented with the data len below.
> -         */
> -        new_data += 1;
> -        wsd->reass_len = 1 /* op */;
> -      }
> -
> -      /* Append this frame to the reassembled buffer */
> -      memmove(new_data, wsm.data, e - wsm.data);
> -      wsd->reass_len += wsm.size;
> -      nc->recv_mbuf.len -= wsm.data - new_data;
> -
> -      if (flags & FLAGS_MASK_FIN) {
> -        /* On last fragmented frame - call user handler and remove data */
> -        wsm.flags = FLAGS_MASK_FIN | nc->recv_mbuf.buf[0];
> -        wsm.data = (unsigned char *) nc->recv_mbuf.buf + 1 /* op */;
> -        wsm.size = wsd->reass_len - 1 /* op */;
> -        cleanup_len = wsd->reass_len;
> -        wsd->reass_len = 0;
> -
> -        /* Pass reassembled message to the client code. */
> -        mg_handle_incoming_websocket_frame(nc, &wsm);
> -        mbuf_remove(&nc->recv_mbuf, cleanup_len); /* Cleanup frame */
> -      }
> -    } else {
> -      /*
> -       * This is a complete message, not a fragment. It might happen in between
> -       * of a fragmented message (in this case, WebSocket protocol requires
> -       * current message to be a control frame).
> -       */
> -      cleanup_len = (size_t) frame_len;
> -
> -      /* First of all, check if we need to react on a control frame. */
> -      switch (flags & FLAGS_MASK_OP) {
> -        case WEBSOCKET_OP_PING:
> -          mg_send_websocket_frame(nc, WEBSOCKET_OP_PONG, wsm.data, wsm.size);
> -          break;
> -
> -        case WEBSOCKET_OP_CLOSE:
> -          mg_ws_close(nc, wsm.data, wsm.size);
> -          break;
> -      }
> -
> -      /* Pass received message to the client code. */
> -      mg_handle_incoming_websocket_frame(nc, &wsm);
> -
> -      /* Cleanup frame */
> -      memmove(nc->recv_mbuf.buf + wsd->reass_len,
> -              nc->recv_mbuf.buf + wsd->reass_len + cleanup_len,
> -              nc->recv_mbuf.len - wsd->reass_len - cleanup_len);
> -      nc->recv_mbuf.len -= cleanup_len;
> -    }
> -  }
> -
> -  return ok;
> -}
> -
> -struct ws_mask_ctx {
> -  size_t pos; /* zero means unmasked */
> -  uint32_t mask;
> -};
> -
> -static uint32_t mg_ws_random_mask(void) {
> -  uint32_t mask;
> -/*
> - * The spec requires WS client to generate hard to
> - * guess mask keys. From RFC6455, Section 5.3:
> - *
> - * The unpredictability of the masking key is essential to prevent
> - * authors of malicious applications from selecting the bytes that appear on
> - * the wire.
> - *
> - * Hence this feature is essential when the actual end user of this API
> - * is untrusted code that wouldn't have access to a lower level net API
> - * anyway (e.g. web browsers). Hence this feature is low prio for most
> - * mongoose use cases and thus can be disabled, e.g. when porting to a platform
> - * that lacks rand().
> - */
> -#if MG_DISABLE_WS_RANDOM_MASK
> -  mask = 0xefbeadde; /* generated with a random number generator, I swear */
> -#else
> -  if (sizeof(long) >= 4) {
> -    mask = (uint32_t) rand();
> -  } else if (sizeof(long) == 2) {
> -    mask = (uint32_t) rand() << 16 | (uint32_t) rand();
> -  }
> -#endif
> -  return mask;
> -}
> -
> -static void mg_send_ws_header(struct mg_connection *nc, int op, size_t len,
> -                              struct ws_mask_ctx *ctx) {
> -  int header_len;
> -  unsigned char header[10];
> -
> -  header[0] =
> -      (op & WEBSOCKET_DONT_FIN ? 0x0 : FLAGS_MASK_FIN) | (op & FLAGS_MASK_OP);
> -  if (len < 126) {
> -    header[1] = (unsigned char) len;
> -    header_len = 2;
> -  } else if (len < 65535) {
> -    uint16_t tmp = htons((uint16_t) len);
> -    header[1] = 126;
> -    memcpy(&header[2], &tmp, sizeof(tmp));
> -    header_len = 4;
> -  } else {
> -    uint32_t tmp;
> -    header[1] = 127;
> -    tmp = htonl((uint32_t)((uint64_t) len >> 32));
> -    memcpy(&header[2], &tmp, sizeof(tmp));
> -    tmp = htonl((uint32_t)(len & 0xffffffff));
> -    memcpy(&header[6], &tmp, sizeof(tmp));
> -    header_len = 10;
> -  }
> -
> -  /* client connections enable masking */
> -  if (nc->listener == NULL) {
> -    header[1] |= 1 << 7; /* set masking flag */
> -    mg_send(nc, header, header_len);
> -    ctx->mask = mg_ws_random_mask();
> -    mg_send(nc, &ctx->mask, sizeof(ctx->mask));
> -    ctx->pos = nc->send_mbuf.len;
> -  } else {
> -    mg_send(nc, header, header_len);
> -    ctx->pos = 0;
> -  }
> -}
> -
> -static void mg_ws_mask_frame(struct mbuf *mbuf, struct ws_mask_ctx *ctx) {
> -  size_t i;
> -  if (ctx->pos == 0) return;
> -  for (i = 0; i < (mbuf->len - ctx->pos); i++) {
> -    mbuf->buf[ctx->pos + i] ^= ((char *) &ctx->mask)[i % 4];
> -  }
> -}
> -
> -void mg_send_websocket_frame(struct mg_connection *nc, int op, const void *data,
> -                             size_t len) {
> -  struct ws_mask_ctx ctx;
> -  DBG(("%p %d %d", nc, op, (int) len));
> -  mg_send_ws_header(nc, op, len, &ctx);
> -  mg_send(nc, data, len);
> -
> -  mg_ws_mask_frame(&nc->send_mbuf, &ctx);
> -
> -  if (op == WEBSOCKET_OP_CLOSE) {
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  }
> -}
> -
> -void mg_send_websocket_framev(struct mg_connection *nc, int op,
> -                              const struct mg_str *strv, int strvcnt) {
> -  struct ws_mask_ctx ctx;
> -  int i;
> -  int len = 0;
> -  for (i = 0; i < strvcnt; i++) {
> -    len += strv[i].len;
> -  }
> -
> -  mg_send_ws_header(nc, op, len, &ctx);
> -
> -  for (i = 0; i < strvcnt; i++) {
> -    mg_send(nc, strv[i].p, strv[i].len);
> -  }
> -
> -  mg_ws_mask_frame(&nc->send_mbuf, &ctx);
> -
> -  if (op == WEBSOCKET_OP_CLOSE) {
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  }
> -}
> -
> -void mg_printf_websocket_frame(struct mg_connection *nc, int op,
> -                               const char *fmt, ...) {
> -  char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
> -  va_list ap;
> -  int len;
> -
> -  va_start(ap, fmt);
> -  if ((len = mg_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
> -    mg_send_websocket_frame(nc, op, buf, len);
> -  }
> -  va_end(ap);
> -
> -  if (buf != mem && buf != NULL) {
> -    MG_FREE(buf);
> -  }
> -}
> -
> -MG_INTERNAL void mg_ws_handler(struct mg_connection *nc, int ev,
> -                               void *ev_data MG_UD_ARG(void *user_data)) {
> -  mg_call(nc, nc->handler, nc->user_data, ev, ev_data);
> -
> -  switch (ev) {
> -    case MG_EV_RECV:
> -      do {
> -      } while (mg_deliver_websocket_data(nc));
> -      break;
> -    case MG_EV_POLL:
> -      /* Ping idle websocket connections */
> -      {
> -        time_t now = *(time_t *) ev_data;
> -        if (nc->flags & MG_F_IS_WEBSOCKET &&
> -            now > nc->last_io_time + MG_WEBSOCKET_PING_INTERVAL_SECONDS) {
> -          mg_send_websocket_frame(nc, WEBSOCKET_OP_PING, "", 0);
> -        }
> -      }
> -      break;
> -    default:
> -      break;
> -  }
> -#if MG_ENABLE_CALLBACK_USERDATA
> -  (void) user_data;
> -#endif
> -}
> -
> -#ifndef MG_EXT_SHA1
> -void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[],
> -                    const size_t *msg_lens, uint8_t *digest) {
> -  size_t i;
> -  cs_sha1_ctx sha_ctx;
> -  cs_sha1_init(&sha_ctx);
> -  for (i = 0; i < num_msgs; i++) {
> -    cs_sha1_update(&sha_ctx, msgs[i], msg_lens[i]);
> -  }
> -  cs_sha1_final(digest, &sha_ctx);
> -}
> -#else
> -extern void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[],
> -                           const size_t *msg_lens, uint8_t *digest);
> -#endif
> -
> -MG_INTERNAL void mg_ws_handshake(struct mg_connection *nc,
> -                                 const struct mg_str *key,
> -                                 struct http_message *hm) {
> -  static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
> -  const uint8_t *msgs[2] = {(const uint8_t *) key->p, (const uint8_t *) magic};
> -  const size_t msg_lens[2] = {key->len, 36};
> -  unsigned char sha[20];
> -  char b64_sha[30];
> -  struct mg_str *s;
> -
> -  mg_hash_sha1_v(2, msgs, msg_lens, sha);
> -  mg_base64_encode(sha, sizeof(sha), b64_sha);
> -  mg_printf(nc, "%s",
> -            "HTTP/1.1 101 Switching Protocols\r\n"
> -            "Upgrade: websocket\r\n"
> -            "Connection: Upgrade\r\n");
> -
> -  s = mg_get_http_header(hm, "Sec-WebSocket-Protocol");
> -  if (s != NULL) {
> -    mg_printf(nc, "Sec-WebSocket-Protocol: %.*s\r\n", (int) s->len, s->p);
> -  }
> -  mg_printf(nc, "Sec-WebSocket-Accept: %s%s", b64_sha, "\r\n\r\n");
> -
> -  DBG(("%p %.*s %s", nc, (int) key->len, key->p, b64_sha));
> -}
> -
> -void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path,
> -                                  const char *host, const char *protocol,
> -                                  const char *extra_headers) {
> -  mg_send_websocket_handshake3(nc, path, host, protocol, extra_headers, NULL,
> -                               NULL);
> -}
> -
> -void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path,
> -                                  const char *host, const char *protocol,
> -                                  const char *extra_headers, const char *user,
> -                                  const char *pass) {
> -  mg_send_websocket_handshake3v(nc, mg_mk_str(path), mg_mk_str(host),
> -                                mg_mk_str(protocol), mg_mk_str(extra_headers),
> -                                mg_mk_str(user), mg_mk_str(pass));
> -}
> -
> -void mg_send_websocket_handshake3v(struct mg_connection *nc,
> -                                   const struct mg_str path,
> -                                   const struct mg_str host,
> -                                   const struct mg_str protocol,
> -                                   const struct mg_str extra_headers,
> -                                   const struct mg_str user,
> -                                   const struct mg_str pass) {
> -  struct mbuf auth;
> -  char key[25];
> -  uint32_t nonce[4];
> -  nonce[0] = mg_ws_random_mask();
> -  nonce[1] = mg_ws_random_mask();
> -  nonce[2] = mg_ws_random_mask();
> -  nonce[3] = mg_ws_random_mask();
> -  mg_base64_encode((unsigned char *) &nonce, sizeof(nonce), key);
> -
> -  mbuf_init(&auth, 0);
> -  if (user.len > 0) {
> -    mg_basic_auth_header(user, pass, &auth);
> -  }
> -
> -  /*
> -   * NOTE: the  (auth.buf == NULL ? "" : auth.buf) is because cc3200 libc is
> -   * broken: it doesn't like zero length to be passed to %.*s
> -   * i.e. sprintf("f%.*so", (int)0, NULL), yields `f\0o`.
> -   * because it handles NULL specially (and incorrectly).
> -   */
> -  mg_printf(nc,
> -            "GET %.*s HTTP/1.1\r\n"
> -            "Upgrade: websocket\r\n"
> -            "Connection: Upgrade\r\n"
> -            "%.*s"
> -            "Sec-WebSocket-Version: 13\r\n"
> -            "Sec-WebSocket-Key: %s\r\n",
> -            (int) path.len, path.p, (int) auth.len,
> -            (auth.buf == NULL ? "" : auth.buf), key);
> -
> -  /* TODO(mkm): take default hostname from http proto data if host == NULL */
> -  if (host.len > 0) {
> -    int host_len = (int) (path.p - host.p); /* Account for possible :PORT */
> -    mg_printf(nc, "Host: %.*s\r\n", host_len, host.p);
> -  }
> -  if (protocol.len > 0) {
> -    mg_printf(nc, "Sec-WebSocket-Protocol: %.*s\r\n", (int) protocol.len,
> -              protocol.p);
> -  }
> -  if (extra_headers.len > 0) {
> -    mg_printf(nc, "%.*s", (int) extra_headers.len, extra_headers.p);
> -  }
> -  mg_printf(nc, "\r\n");
> -
> -  nc->flags |= MG_F_IS_WEBSOCKET;
> -
> -  mbuf_free(&auth);
> -}
> -
> -void mg_send_websocket_handshake(struct mg_connection *nc, const char *path,
> -                                 const char *extra_headers) {
> -  struct mg_str null_str = MG_NULL_STR;
> -  mg_send_websocket_handshake3v(
> -      nc, mg_mk_str(path), null_str /* host */, null_str /* protocol */,
> -      mg_mk_str(extra_headers), null_str /* user */, null_str /* pass */);
> -}
> -
> -struct mg_connection *mg_connect_ws_opt(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *url, const char *protocol,
> -    const char *extra_headers) {
> -  struct mg_str null_str = MG_NULL_STR;
> -  struct mg_str host = MG_NULL_STR, path = MG_NULL_STR, user_info = MG_NULL_STR;
> -  struct mg_connection *nc =
> -      mg_connect_http_base(mgr, MG_CB(ev_handler, user_data), opts, "http",
> -                           "ws", "https", "wss", url, &path, &user_info, &host);
> -  if (nc != NULL) {
> -    mg_send_websocket_handshake3v(nc, path, host, mg_mk_str(protocol),
> -                                  mg_mk_str(extra_headers), user_info,
> -                                  null_str);
> -  }
> -  return nc;
> -}
> -
> -struct mg_connection *mg_connect_ws(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    const char *url, const char *protocol, const char *extra_headers) {
> -  struct mg_connect_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_connect_ws_opt(mgr, MG_CB(ev_handler, user_data), opts, url,
> -                           protocol, extra_headers);
> -}
> -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBSOCKET */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_util.c"
> -#endif
> -
> -/* Amalgamated: #include "common/cs_base64.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_util.h" */
> -
> -/* For platforms with limited libc */
> -#ifndef MAX
> -#define MAX(a, b) ((a) > (b) ? (a) : (b))
> -#endif
> -
> -const char *mg_skip(const char *s, const char *end, const char *delims,
> -                    struct mg_str *v) {
> -  v->p = s;
> -  while (s < end && strchr(delims, *(unsigned char *) s) == NULL) s++;
> -  v->len = s - v->p;
> -  while (s < end && strchr(delims, *(unsigned char *) s) != NULL) s++;
> -  return s;
> -}
> -
> -#if MG_ENABLE_FILESYSTEM && !defined(MG_USER_FILE_FUNCTIONS)
> -int mg_stat(const char *path, cs_stat_t *st) {
> -#ifdef _WIN32
> -  wchar_t wpath[MG_MAX_PATH];
> -  to_wchar(path, wpath, ARRAY_SIZE(wpath));
> -  DBG(("[%ls] -> %d", wpath, _wstati64(wpath, st)));
> -  return _wstati64(wpath, st);
> -#else
> -  return stat(path, st);
> -#endif
> -}
> -
> -FILE *mg_fopen(const char *path, const char *mode) {
> -#ifdef _WIN32
> -  wchar_t wpath[MG_MAX_PATH], wmode[10];
> -  to_wchar(path, wpath, ARRAY_SIZE(wpath));
> -  to_wchar(mode, wmode, ARRAY_SIZE(wmode));
> -  return _wfopen(wpath, wmode);
> -#else
> -  return fopen(path, mode);
> -#endif
> -}
> -
> -int mg_open(const char *path, int flag, int mode) { /* LCOV_EXCL_LINE */
> -#if defined(_WIN32) && !defined(WINCE)
> -  wchar_t wpath[MG_MAX_PATH];
> -  to_wchar(path, wpath, ARRAY_SIZE(wpath));
> -  return _wopen(wpath, flag, mode);
> -#else
> -  return open(path, flag, mode); /* LCOV_EXCL_LINE */
> -#endif
> -}
> -
> -size_t mg_fread(void *ptr, size_t size, size_t count, FILE *f) {
> -  return fread(ptr, size, count, f);
> -}
> -
> -size_t mg_fwrite(const void *ptr, size_t size, size_t count, FILE *f) {
> -  return fwrite(ptr, size, count, f);
> -}
> -#endif
> -
> -void mg_base64_encode(const unsigned char *src, int src_len, char *dst) {
> -  cs_base64_encode(src, src_len, dst);
> -}
> -
> -int mg_base64_decode(const unsigned char *s, int len, char *dst) {
> -  return cs_base64_decode(s, len, dst, NULL);
> -}
> -
> -#if MG_ENABLE_THREADS
> -void *mg_start_thread(void *(*f)(void *), void *p) {
> -#ifdef WINCE
> -  return (void *) CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) f, p, 0, NULL);
> -#elif defined(_WIN32)
> -  return (void *) _beginthread((void(__cdecl *) (void *) ) f, 0, p);
> -#else
> -  pthread_t thread_id = (pthread_t) 0;
> -  pthread_attr_t attr;
> -
> -  (void) pthread_attr_init(&attr);
> -  (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
> -
> -#if defined(MG_STACK_SIZE) && MG_STACK_SIZE > 1
> -  (void) pthread_attr_setstacksize(&attr, MG_STACK_SIZE);
> -#endif
> -
> -  pthread_create(&thread_id, &attr, f, p);
> -  pthread_attr_destroy(&attr);
> -
> -  return (void *) thread_id;
> -#endif
> -}
> -#endif /* MG_ENABLE_THREADS */
> -
> -/* Set close-on-exec bit for a given socket. */
> -void mg_set_close_on_exec(sock_t sock) {
> -#if defined(_WIN32) && !defined(WINCE)
> -  (void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
> -#elif defined(__unix__)
> -  fcntl(sock, F_SETFD, FD_CLOEXEC);
> -#else
> -  (void) sock;
> -#endif
> -}
> -
> -int mg_sock_addr_to_str(const union socket_address *sa, char *buf, size_t len,
> -                        int flags) {
> -  int is_v6;
> -  if (buf == NULL || len <= 0) return 0;
> -  memset(buf, 0, len);
> -#if MG_ENABLE_IPV6
> -  is_v6 = sa->sa.sa_family == AF_INET6;
> -#else
> -  is_v6 = 0;
> -#endif
> -  if (flags & MG_SOCK_STRINGIFY_IP) {
> -#if MG_ENABLE_IPV6
> -    const void *addr = NULL;
> -    char *start = buf;
> -    socklen_t capacity = len;
> -    if (!is_v6) {
> -      addr = &sa->sin.sin_addr;
> -    } else {
> -      addr = (void *) &sa->sin6.sin6_addr;
> -      if (flags & MG_SOCK_STRINGIFY_PORT) {
> -        *buf = '[';
> -        start++;
> -        capacity--;
> -      }
> -    }
> -    if (inet_ntop(sa->sa.sa_family, addr, start, capacity) == NULL) {
> -      goto cleanup;
> -    }
> -#elif defined(_WIN32) || MG_LWIP || (MG_NET_IF == MG_NET_IF_PIC32)
> -    /* Only Windoze Vista (and newer) have inet_ntop() */
> -    char *addr_str = inet_ntoa(sa->sin.sin_addr);
> -    if (addr_str != NULL) {
> -      strncpy(buf, inet_ntoa(sa->sin.sin_addr), len - 1);
> -    } else {
> -      goto cleanup;
> -    }
> -#else
> -    if (inet_ntop(AF_INET, (void *) &sa->sin.sin_addr, buf, len) == NULL) {
> -      goto cleanup;
> -    }
> -#endif
> -  }
> -  if (flags & MG_SOCK_STRINGIFY_PORT) {
> -    int port = ntohs(sa->sin.sin_port);
> -    if (flags & MG_SOCK_STRINGIFY_IP) {
> -      int buf_len = strlen(buf);
> -      snprintf(buf + buf_len, len - (buf_len + 1), "%s:%d", (is_v6 ? "]" : ""),
> -               port);
> -    } else {
> -      snprintf(buf, len, "%d", port);
> -    }
> -  }
> -
> -  return strlen(buf);
> -
> -cleanup:
> -  *buf = '\0';
> -  return 0;
> -}
> -
> -int mg_conn_addr_to_str(struct mg_connection *nc, char *buf, size_t len,
> -                        int flags) {
> -  union socket_address sa;
> -  memset(&sa, 0, sizeof(sa));
> -  mg_if_get_conn_addr(nc, flags & MG_SOCK_STRINGIFY_REMOTE, &sa);
> -  return mg_sock_addr_to_str(&sa, buf, len, flags);
> -}
> -
> -#if MG_ENABLE_HEXDUMP
> -static int mg_hexdump_n(const void *buf, int len, char *dst, int dst_len,
> -                        int offset) {
> -  const unsigned char *p = (const unsigned char *) buf;
> -  char ascii[17] = "";
> -  int i, idx, n = 0;
> -
> -  for (i = 0; i < len; i++) {
> -    idx = i % 16;
> -    if (idx == 0) {
> -      if (i > 0) n += snprintf(dst + n, MAX(dst_len - n, 0), "  %s\n", ascii);
> -      n += snprintf(dst + n, MAX(dst_len - n, 0), "%04x ", i + offset);
> -    }
> -    if (dst_len - n < 0) {
> -      return n;
> -    }
> -    n += snprintf(dst + n, MAX(dst_len - n, 0), " %02x", p[i]);
> -    ascii[idx] = p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i];
> -    ascii[idx + 1] = '\0';
> -  }
> -
> -  while (i++ % 16) n += snprintf(dst + n, MAX(dst_len - n, 0), "%s", "   ");
> -  n += snprintf(dst + n, MAX(dst_len - n, 0), "  %s\n", ascii);
> -
> -  return n;
> -}
> -
> -int mg_hexdump(const void *buf, int len, char *dst, int dst_len) {
> -  return mg_hexdump_n(buf, len, dst, dst_len, 0);
> -}
> -
> -void mg_hexdumpf(FILE *fp, const void *buf, int len) {
> -  char tmp[80];
> -  int offset = 0, n;
> -  while (len > 0) {
> -    n = (len < 16 ? len : 16);
> -    mg_hexdump_n(((const char *) buf) + offset, n, tmp, sizeof(tmp), offset);
> -    fputs(tmp, fp);
> -    offset += n;
> -    len -= n;
> -  }
> -}
> -
> -void mg_hexdump_connection(struct mg_connection *nc, const char *path,
> -                           const void *buf, int num_bytes, int ev) {
> -  FILE *fp = NULL;
> -  char src[60], dst[60];
> -  const char *tag = NULL;
> -  switch (ev) {
> -    case MG_EV_RECV:
> -      tag = "<-";
> -      break;
> -    case MG_EV_SEND:
> -      tag = "->";
> -      break;
> -    case MG_EV_ACCEPT:
> -      tag = "<A";
> -      break;
> -    case MG_EV_CONNECT:
> -      tag = "C>";
> -      break;
> -    case MG_EV_CLOSE:
> -      tag = "XX";
> -      break;
> -  }
> -  if (tag == NULL) return; /* Don't log MG_EV_TIMER, etc */
> -
> -  if (strcmp(path, "-") == 0) {
> -    fp = stdout;
> -  } else if (strcmp(path, "--") == 0) {
> -    fp = stderr;
> -#if MG_ENABLE_FILESYSTEM
> -  } else {
> -    fp = mg_fopen(path, "a");
> -#endif
> -  }
> -  if (fp == NULL) return;
> -
> -  mg_conn_addr_to_str(nc, src, sizeof(src),
> -                      MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);
> -  mg_conn_addr_to_str(nc, dst, sizeof(dst), MG_SOCK_STRINGIFY_IP |
> -                                                MG_SOCK_STRINGIFY_PORT |
> -                                                MG_SOCK_STRINGIFY_REMOTE);
> -  fprintf(fp, "%lu %p %s %s %s %d\n", (unsigned long) mg_time(), (void *) nc,
> -          src, tag, dst, (int) num_bytes);
> -  if (num_bytes > 0) {
> -    mg_hexdumpf(fp, buf, num_bytes);
> -  }
> -  if (fp != stdout && fp != stderr) fclose(fp);
> -}
> -#endif
> -
> -int mg_is_big_endian(void) {
> -  static const int n = 1;
> -  /* TODO(mkm) use compiletime check with 4-byte char literal */
> -  return ((char *) &n)[0] == 0;
> -}
> -
> -DO_NOT_WARN_UNUSED MG_INTERNAL int mg_get_errno(void) {
> -#ifndef WINCE
> -  return errno;
> -#else
> -  /* TODO(alashkin): translate error codes? */
> -  return GetLastError();
> -#endif
> -}
> -
> -void mg_mbuf_append_base64_putc(char ch, void *user_data) {
> -  struct mbuf *mbuf = (struct mbuf *) user_data;
> -  mbuf_append(mbuf, &ch, sizeof(ch));
> -}
> -
> -void mg_mbuf_append_base64(struct mbuf *mbuf, const void *data, size_t len) {
> -  struct cs_base64_ctx ctx;
> -  cs_base64_init(&ctx, mg_mbuf_append_base64_putc, mbuf);
> -  cs_base64_update(&ctx, (const char *) data, len);
> -  cs_base64_finish(&ctx);
> -}
> -
> -void mg_basic_auth_header(const struct mg_str user, const struct mg_str pass,
> -                          struct mbuf *buf) {
> -  const char *header_prefix = "Authorization: Basic ";
> -  const char *header_suffix = "\r\n";
> -
> -  struct cs_base64_ctx ctx;
> -  cs_base64_init(&ctx, mg_mbuf_append_base64_putc, buf);
> -
> -  mbuf_append(buf, header_prefix, strlen(header_prefix));
> -
> -  cs_base64_update(&ctx, user.p, user.len);
> -  if (pass.len > 0) {
> -    cs_base64_update(&ctx, ":", 1);
> -    cs_base64_update(&ctx, pass.p, pass.len);
> -  }
> -  cs_base64_finish(&ctx);
> -  mbuf_append(buf, header_suffix, strlen(header_suffix));
> -}
> -
> -struct mg_str mg_url_encode_opt(const struct mg_str src,
> -                                const struct mg_str safe, unsigned int flags) {
> -  const char *hex =
> -      (flags & MG_URL_ENCODE_F_UPPERCASE_HEX ? "0123456789ABCDEF"
> -                                             : "0123456789abcdef");
> -  size_t i = 0;
> -  struct mbuf mb;
> -  mbuf_init(&mb, src.len);
> -
> -  for (i = 0; i < src.len; i++) {
> -    const unsigned char c = *((const unsigned char *) src.p + i);
> -    if (isalnum(c) || mg_strchr(safe, c) != NULL) {
> -      mbuf_append(&mb, &c, 1);
> -    } else if (c == ' ' && (flags & MG_URL_ENCODE_F_SPACE_AS_PLUS)) {
> -      mbuf_append(&mb, "+", 1);
> -    } else {
> -      mbuf_append(&mb, "%", 1);
> -      mbuf_append(&mb, &hex[c >> 4], 1);
> -      mbuf_append(&mb, &hex[c & 15], 1);
> -    }
> -  }
> -  mbuf_append(&mb, "", 1);
> -  mbuf_trim(&mb);
> -  return mg_mk_str_n(mb.buf, mb.len - 1);
> -}
> -
> -struct mg_str mg_url_encode(const struct mg_str src) {
> -  return mg_url_encode_opt(src, mg_mk_str("._-$,;~()/"), 0);
> -}
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_mqtt.c"
> -#endif
> -
> -#if MG_ENABLE_MQTT
> -
> -#include <string.h>
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_mqtt.h" */
> -
> -#define MG_F_MQTT_PING_PENDING MG_F_PROTO_1
> -
> -static uint16_t getu16(const char *p) {
> -  const uint8_t *up = (const uint8_t *) p;
> -  return (up[0] << 8) + up[1];
> -}
> -
> -static const char *scanto(const char *p, struct mg_str *s) {
> -  s->len = getu16(p);
> -  s->p = p + 2;
> -  return s->p + s->len;
> -}
> -
> -MG_INTERNAL int parse_mqtt(struct mbuf *io, struct mg_mqtt_message *mm) {
> -  uint8_t header;
> -  uint32_t len, len_len; /* must be 32-bit, see #1055 */
> -  const char *p, *end, *eop = &io->buf[io->len];
> -  unsigned char lc = 0;
> -  int cmd;
> -
> -  if (io->len < 2) return MG_MQTT_ERROR_INCOMPLETE_MSG;
> -  header = io->buf[0];
> -  cmd = header >> 4;
> -
> -  /* decode mqtt variable length */
> -  len = len_len = 0;
> -  p = io->buf + 1;
> -  while (p < eop) {
> -    lc = *((const unsigned char *) p++);
> -    len += (lc & 0x7f) << 7 * len_len;
> -    len_len++;
> -    if (!(lc & 0x80)) break;
> -    if (len_len > sizeof(len)) return MG_MQTT_ERROR_MALFORMED_MSG;
> -  }
> -
> -  end = p + len;
> -  if (lc & 0x80 || end > eop) return MG_MQTT_ERROR_INCOMPLETE_MSG;
> -
> -  mm->cmd = cmd;
> -  mm->qos = MG_MQTT_GET_QOS(header);
> -
> -  switch (cmd) {
> -    case MG_MQTT_CMD_CONNECT: {
> -      p = scanto(p, &mm->protocol_name);
> -      if (p > end - 4) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      mm->protocol_version = *(uint8_t *) p++;
> -      mm->connect_flags = *(uint8_t *) p++;
> -      mm->keep_alive_timer = getu16(p);
> -      p += 2;
> -      if (p >= end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      p = scanto(p, &mm->client_id);
> -      if (p > end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      if (mm->connect_flags & MG_MQTT_HAS_WILL) {
> -        if (p >= end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -        p = scanto(p, &mm->will_topic);
> -      }
> -      if (mm->connect_flags & MG_MQTT_HAS_WILL) {
> -        if (p >= end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -        p = scanto(p, &mm->will_message);
> -      }
> -      if (mm->connect_flags & MG_MQTT_HAS_USER_NAME) {
> -        if (p >= end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -        p = scanto(p, &mm->user_name);
> -      }
> -      if (mm->connect_flags & MG_MQTT_HAS_PASSWORD) {
> -        if (p >= end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -        p = scanto(p, &mm->password);
> -      }
> -      if (p != end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -
> -      LOG(LL_DEBUG,
> -          ("%d %2x %d proto [%.*s] client_id [%.*s] will_topic [%.*s] "
> -           "will_msg [%.*s] user_name [%.*s] password [%.*s]",
> -           (int) len, (int) mm->connect_flags, (int) mm->keep_alive_timer,
> -           (int) mm->protocol_name.len, mm->protocol_name.p,
> -           (int) mm->client_id.len, mm->client_id.p, (int) mm->will_topic.len,
> -           mm->will_topic.p, (int) mm->will_message.len, mm->will_message.p,
> -           (int) mm->user_name.len, mm->user_name.p, (int) mm->password.len,
> -           mm->password.p));
> -      break;
> -    }
> -    case MG_MQTT_CMD_CONNACK:
> -      if (end - p < 2) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      mm->connack_ret_code = p[1];
> -      break;
> -    case MG_MQTT_CMD_PUBACK:
> -    case MG_MQTT_CMD_PUBREC:
> -    case MG_MQTT_CMD_PUBREL:
> -    case MG_MQTT_CMD_PUBCOMP:
> -    case MG_MQTT_CMD_SUBACK:
> -      if (end - p < 2) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      mm->message_id = getu16(p);
> -      p += 2;
> -      break;
> -    case MG_MQTT_CMD_PUBLISH: {
> -      p = scanto(p, &mm->topic);
> -      if (p > end) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      if (mm->qos > 0) {
> -        if (end - p < 2) return MG_MQTT_ERROR_MALFORMED_MSG;
> -        mm->message_id = getu16(p);
> -        p += 2;
> -      }
> -      mm->payload.p = p;
> -      mm->payload.len = end - p;
> -      break;
> -    }
> -    case MG_MQTT_CMD_SUBSCRIBE:
> -      if (end - p < 2) return MG_MQTT_ERROR_MALFORMED_MSG;
> -      mm->message_id = getu16(p);
> -      p += 2;
> -      /*
> -       * topic expressions are left in the payload and can be parsed with
> -       * `mg_mqtt_next_subscribe_topic`
> -       */
> -      mm->payload.p = p;
> -      mm->payload.len = end - p;
> -      break;
> -    default:
> -      /* Unhandled command */
> -      break;
> -  }
> -
> -  mm->len = end - io->buf;
> -  return mm->len;
> -}
> -
> -static void mqtt_handler(struct mg_connection *nc, int ev,
> -                         void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct mbuf *io = &nc->recv_mbuf;
> -  struct mg_mqtt_message mm;
> -  memset(&mm, 0, sizeof(mm));
> -
> -  nc->handler(nc, ev, ev_data MG_UD_ARG(user_data));
> -
> -  switch (ev) {
> -    case MG_EV_ACCEPT:
> -      if (nc->proto_data == NULL) mg_set_protocol_mqtt(nc);
> -      break;
> -    case MG_EV_RECV: {
> -      /* There can be multiple messages in the buffer, process them all. */
> -      while (1) {
> -        int len = parse_mqtt(io, &mm);
> -        if (len < 0) {
> -          if (len == MG_MQTT_ERROR_MALFORMED_MSG) {
> -            /* Protocol error. */
> -            nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -          } else if (len == MG_MQTT_ERROR_INCOMPLETE_MSG) {
> -            /* Not fully buffered, let's check if we have a chance to get more
> -             * data later */
> -            if (nc->recv_mbuf_limit > 0 &&
> -                nc->recv_mbuf.len >= nc->recv_mbuf_limit) {
> -              LOG(LL_ERROR, ("%p recv buffer (%lu bytes) exceeds the limit "
> -                             "%lu bytes, and not drained, closing",
> -                             nc, (unsigned long) nc->recv_mbuf.len,
> -                             (unsigned long) nc->recv_mbuf_limit));
> -              nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -            }
> -          } else {
> -            /* Should never be here */
> -            LOG(LL_ERROR, ("%p invalid len: %d, closing", nc, len));
> -            nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -          }
> -          break;
> -        }
> -        if (mm.cmd == MG_MQTT_CMD_PINGRESP) {
> -          LOG(LL_DEBUG, ("Recv PINGRESP"));
> -          nc->flags &= ~MG_F_MQTT_PING_PENDING;
> -        }
> -
> -        nc->handler(nc, MG_MQTT_EVENT_BASE + mm.cmd, &mm MG_UD_ARG(user_data));
> -        mbuf_remove(io, len);
> -      }
> -      break;
> -    }
> -    case MG_EV_POLL: {
> -      struct mg_mqtt_proto_data *pd =
> -          (struct mg_mqtt_proto_data *) nc->proto_data;
> -      double now = mg_time();
> -      if (pd->keep_alive > 0 && pd->last_control_time > 0) {
> -        double diff = (now - pd->last_control_time);
> -        if (diff > pd->keep_alive) {
> -          if (diff < 1500000000) {
> -            if (!(nc->flags & MG_F_MQTT_PING_PENDING)) {
> -              LOG(LL_DEBUG, ("Send PINGREQ"));
> -              nc->flags |= MG_F_MQTT_PING_PENDING;
> -              mg_mqtt_ping(nc);
> -            } else {
> -              LOG(LL_DEBUG, ("Ping timeout"));
> -              nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -            }
> -          } else {
> -            /* Wall time has just been set. Avoid immediate ping,
> -             * more likely than not it is not needed. The standard allows for
> -             * 1.5X interval for ping requests, so even if were just about to
> -             * send one, we should be ok waiting 0.4X more. */
> -            pd->last_control_time = now - pd->keep_alive * 0.6;
> -          }
> -        }
> -      }
> -      break;
> -    }
> -  }
> -}
> -
> -static void mg_mqtt_proto_data_destructor(void *proto_data) {
> -  MG_FREE(proto_data);
> -}
> -
> -static struct mg_str mg_mqtt_next_topic_component(struct mg_str *topic) {
> -  struct mg_str res = *topic;
> -  const char *c = mg_strchr(*topic, '/');
> -  if (c != NULL) {
> -    res.len = (c - topic->p);
> -    topic->len -= (res.len + 1);
> -    topic->p += (res.len + 1);
> -  } else {
> -    topic->len = 0;
> -  }
> -  return res;
> -}
> -
> -/* Refernce: https://mosquitto.org/man/mqtt-7.html */
> -int mg_mqtt_match_topic_expression(struct mg_str exp, struct mg_str topic) {
> -  struct mg_str ec, tc;
> -  if (exp.len == 0) return 0;
> -  while (1) {
> -    ec = mg_mqtt_next_topic_component(&exp);
> -    tc = mg_mqtt_next_topic_component(&topic);
> -    if (ec.len == 0) {
> -      if (tc.len != 0) return 0;
> -      if (exp.len == 0) break;
> -      continue;
> -    }
> -    if (mg_vcmp(&ec, "+") == 0) {
> -      if (tc.len == 0 && topic.len == 0) return 0;
> -      continue;
> -    }
> -    if (mg_vcmp(&ec, "#") == 0) {
> -      /* Must be the last component in the expression or it's invalid. */
> -      return (exp.len == 0);
> -    }
> -    if (mg_strcmp(ec, tc) != 0) {
> -      return 0;
> -    }
> -  }
> -  return (tc.len == 0 && topic.len == 0);
> -}
> -
> -int mg_mqtt_vmatch_topic_expression(const char *exp, struct mg_str topic) {
> -  return mg_mqtt_match_topic_expression(mg_mk_str(exp), topic);
> -}
> -
> -void mg_set_protocol_mqtt(struct mg_connection *nc) {
> -  nc->proto_handler = mqtt_handler;
> -  nc->proto_data = MG_CALLOC(1, sizeof(struct mg_mqtt_proto_data));
> -  nc->proto_data_destructor = mg_mqtt_proto_data_destructor;
> -}
> -
> -static void mg_send_mqtt_header(struct mg_connection *nc, uint8_t cmd,
> -                                uint8_t flags, size_t len) {
> -  struct mg_mqtt_proto_data *pd = (struct mg_mqtt_proto_data *) nc->proto_data;
> -  uint8_t buf[1 + sizeof(size_t)];
> -  uint8_t *vlen = &buf[1];
> -
> -  buf[0] = (cmd << 4) | flags;
> -
> -  /* mqtt variable length encoding */
> -  do {
> -    *vlen = len % 0x80;
> -    len /= 0x80;
> -    if (len > 0) *vlen |= 0x80;
> -    vlen++;
> -  } while (len > 0);
> -
> -  mg_send(nc, buf, vlen - buf);
> -  pd->last_control_time = mg_time();
> -}
> -
> -void mg_send_mqtt_handshake(struct mg_connection *nc, const char *client_id) {
> -  static struct mg_send_mqtt_handshake_opts opts;
> -  mg_send_mqtt_handshake_opt(nc, client_id, opts);
> -}
> -
> -void mg_send_mqtt_handshake_opt(struct mg_connection *nc, const char *client_id,
> -                                struct mg_send_mqtt_handshake_opts opts) {
> -  struct mg_mqtt_proto_data *pd = (struct mg_mqtt_proto_data *) nc->proto_data;
> -  uint16_t id_len = 0, wt_len = 0, wm_len = 0, user_len = 0, pw_len = 0;
> -  uint16_t netbytes;
> -  size_t total_len;
> -
> -  if (client_id != NULL) {
> -    id_len = strlen(client_id);
> -  }
> -
> -  total_len = 7 + 1 + 2 + 2 + id_len;
> -
> -  if (opts.user_name != NULL) {
> -    opts.flags |= MG_MQTT_HAS_USER_NAME;
> -  }
> -  if (opts.password != NULL) {
> -    opts.flags |= MG_MQTT_HAS_PASSWORD;
> -  }
> -  if (opts.will_topic != NULL && opts.will_message != NULL) {
> -    wt_len = strlen(opts.will_topic);
> -    wm_len = strlen(opts.will_message);
> -    opts.flags |= MG_MQTT_HAS_WILL;
> -  }
> -  if (opts.keep_alive == 0) {
> -    opts.keep_alive = 60;
> -  }
> -
> -  if (opts.flags & MG_MQTT_HAS_WILL) {
> -    total_len += 2 + wt_len + 2 + wm_len;
> -  }
> -  if (opts.flags & MG_MQTT_HAS_USER_NAME) {
> -    user_len = strlen(opts.user_name);
> -    total_len += 2 + user_len;
> -  }
> -  if (opts.flags & MG_MQTT_HAS_PASSWORD) {
> -    pw_len = strlen(opts.password);
> -    total_len += 2 + pw_len;
> -  }
> -
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_CONNECT, 0, total_len);
> -  mg_send(nc, "\00\04MQTT\04", 7);
> -  mg_send(nc, &opts.flags, 1);
> -
> -  netbytes = htons(opts.keep_alive);
> -  mg_send(nc, &netbytes, 2);
> -
> -  netbytes = htons(id_len);
> -  mg_send(nc, &netbytes, 2);
> -  mg_send(nc, client_id, id_len);
> -
> -  if (opts.flags & MG_MQTT_HAS_WILL) {
> -    netbytes = htons(wt_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, opts.will_topic, wt_len);
> -
> -    netbytes = htons(wm_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, opts.will_message, wm_len);
> -  }
> -
> -  if (opts.flags & MG_MQTT_HAS_USER_NAME) {
> -    netbytes = htons(user_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, opts.user_name, user_len);
> -  }
> -  if (opts.flags & MG_MQTT_HAS_PASSWORD) {
> -    netbytes = htons(pw_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, opts.password, pw_len);
> -  }
> -
> -  if (pd != NULL) {
> -    pd->keep_alive = opts.keep_alive;
> -  }
> -}
> -
> -void mg_mqtt_publish(struct mg_connection *nc, const char *topic,
> -                     uint16_t message_id, int flags, const void *data,
> -                     size_t len) {
> -  uint16_t netbytes;
> -  uint16_t topic_len = strlen(topic);
> -
> -  size_t total_len = 2 + topic_len + len;
> -  if (MG_MQTT_GET_QOS(flags) > 0) {
> -    total_len += 2;
> -  }
> -
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_PUBLISH, flags, total_len);
> -
> -  netbytes = htons(topic_len);
> -  mg_send(nc, &netbytes, 2);
> -  mg_send(nc, topic, topic_len);
> -
> -  if (MG_MQTT_GET_QOS(flags) > 0) {
> -    netbytes = htons(message_id);
> -    mg_send(nc, &netbytes, 2);
> -  }
> -
> -  mg_send(nc, data, len);
> -}
> -
> -void mg_mqtt_subscribe(struct mg_connection *nc,
> -                       const struct mg_mqtt_topic_expression *topics,
> -                       size_t topics_len, uint16_t message_id) {
> -  uint16_t netbytes;
> -  size_t i;
> -  uint16_t topic_len;
> -  size_t total_len = 2;
> -
> -  for (i = 0; i < topics_len; i++) {
> -    total_len += 2 + strlen(topics[i].topic) + 1;
> -  }
> -
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_SUBSCRIBE, MG_MQTT_QOS(1), total_len);
> -
> -  netbytes = htons(message_id);
> -  mg_send(nc, (char *) &netbytes, 2);
> -
> -  for (i = 0; i < topics_len; i++) {
> -    topic_len = strlen(topics[i].topic);
> -    netbytes = htons(topic_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, topics[i].topic, topic_len);
> -    mg_send(nc, &topics[i].qos, 1);
> -  }
> -}
> -
> -int mg_mqtt_next_subscribe_topic(struct mg_mqtt_message *msg,
> -                                 struct mg_str *topic, uint8_t *qos, int pos) {
> -  unsigned char *buf = (unsigned char *) msg->payload.p + pos;
> -  int new_pos;
> -
> -  if ((size_t) pos >= msg->payload.len) return -1;
> -
> -  topic->len = buf[0] << 8 | buf[1];
> -  topic->p = (char *) buf + 2;
> -  new_pos = pos + 2 + topic->len + 1;
> -  if ((size_t) new_pos > msg->payload.len) return -1;
> -  *qos = buf[2 + topic->len];
> -  return new_pos;
> -}
> -
> -void mg_mqtt_unsubscribe(struct mg_connection *nc, char **topics,
> -                         size_t topics_len, uint16_t message_id) {
> -  uint16_t netbytes;
> -  size_t i;
> -  uint16_t topic_len;
> -  size_t total_len = 2;
> -
> -  for (i = 0; i < topics_len; i++) {
> -    total_len += 2 + strlen(topics[i]);
> -  }
> -
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_UNSUBSCRIBE, MG_MQTT_QOS(1), total_len);
> -
> -  netbytes = htons(message_id);
> -  mg_send(nc, (char *) &netbytes, 2);
> -
> -  for (i = 0; i < topics_len; i++) {
> -    topic_len = strlen(topics[i]);
> -    netbytes = htons(topic_len);
> -    mg_send(nc, &netbytes, 2);
> -    mg_send(nc, topics[i], topic_len);
> -  }
> -}
> -
> -void mg_mqtt_connack(struct mg_connection *nc, uint8_t return_code) {
> -  uint8_t unused = 0;
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_CONNACK, 0, 2);
> -  mg_send(nc, &unused, 1);
> -  mg_send(nc, &return_code, 1);
> -}
> -
> -/*
> - * Sends a command which contains only a `message_id` and a QoS level of 1.
> - *
> - * Helper function.
> - */
> -static void mg_send_mqtt_short_command(struct mg_connection *nc, uint8_t cmd,
> -                                       uint16_t message_id) {
> -  uint16_t netbytes;
> -  uint8_t flags = (cmd == MG_MQTT_CMD_PUBREL ? 2 : 0);
> -
> -  mg_send_mqtt_header(nc, cmd, flags, 2 /* len */);
> -
> -  netbytes = htons(message_id);
> -  mg_send(nc, &netbytes, 2);
> -}
> -
> -void mg_mqtt_puback(struct mg_connection *nc, uint16_t message_id) {
> -  mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBACK, message_id);
> -}
> -
> -void mg_mqtt_pubrec(struct mg_connection *nc, uint16_t message_id) {
> -  mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREC, message_id);
> -}
> -
> -void mg_mqtt_pubrel(struct mg_connection *nc, uint16_t message_id) {
> -  mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREL, message_id);
> -}
> -
> -void mg_mqtt_pubcomp(struct mg_connection *nc, uint16_t message_id) {
> -  mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBCOMP, message_id);
> -}
> -
> -void mg_mqtt_suback(struct mg_connection *nc, uint8_t *qoss, size_t qoss_len,
> -                    uint16_t message_id) {
> -  size_t i;
> -  uint16_t netbytes;
> -
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_SUBACK, MG_MQTT_QOS(1), 2 + qoss_len);
> -
> -  netbytes = htons(message_id);
> -  mg_send(nc, &netbytes, 2);
> -
> -  for (i = 0; i < qoss_len; i++) {
> -    mg_send(nc, &qoss[i], 1);
> -  }
> -}
> -
> -void mg_mqtt_unsuback(struct mg_connection *nc, uint16_t message_id) {
> -  mg_send_mqtt_short_command(nc, MG_MQTT_CMD_UNSUBACK, message_id);
> -}
> -
> -void mg_mqtt_ping(struct mg_connection *nc) {
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_PINGREQ, 0, 0);
> -}
> -
> -void mg_mqtt_pong(struct mg_connection *nc) {
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_PINGRESP, 0, 0);
> -}
> -
> -void mg_mqtt_disconnect(struct mg_connection *nc) {
> -  mg_send_mqtt_header(nc, MG_MQTT_CMD_DISCONNECT, 0, 0);
> -}
> -
> -#endif /* MG_ENABLE_MQTT */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_mqtt_server.c"
> -#endif
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_mqtt_server.h" */
> -
> -#if MG_ENABLE_MQTT_BROKER
> -
> -static void mg_mqtt_session_init(struct mg_mqtt_broker *brk,
> -                                 struct mg_mqtt_session *s,
> -                                 struct mg_connection *nc) {
> -  s->brk = brk;
> -  s->subscriptions = NULL;
> -  s->num_subscriptions = 0;
> -  s->nc = nc;
> -}
> -
> -static void mg_mqtt_add_session(struct mg_mqtt_session *s) {
> -  LIST_INSERT_HEAD(&s->brk->sessions, s, link);
> -}
> -
> -static void mg_mqtt_remove_session(struct mg_mqtt_session *s) {
> -  LIST_REMOVE(s, link);
> -}
> -
> -static void mg_mqtt_destroy_session(struct mg_mqtt_session *s) {
> -  size_t i;
> -  for (i = 0; i < s->num_subscriptions; i++) {
> -    MG_FREE((void *) s->subscriptions[i].topic);
> -  }
> -  MG_FREE(s->subscriptions);
> -  MG_FREE(s);
> -}
> -
> -static void mg_mqtt_close_session(struct mg_mqtt_session *s) {
> -  mg_mqtt_remove_session(s);
> -  mg_mqtt_destroy_session(s);
> -}
> -
> -void mg_mqtt_broker_init(struct mg_mqtt_broker *brk, void *user_data) {
> -  LIST_INIT(&brk->sessions);
> -  brk->user_data = user_data;
> -}
> -
> -static void mg_mqtt_broker_handle_connect(struct mg_mqtt_broker *brk,
> -                                          struct mg_connection *nc) {
> -  struct mg_mqtt_session *s =
> -      (struct mg_mqtt_session *) MG_CALLOC(1, sizeof *s);
> -  if (s == NULL) {
> -    /* LCOV_EXCL_START */
> -    mg_mqtt_connack(nc, MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE);
> -    return;
> -    /* LCOV_EXCL_STOP */
> -  }
> -
> -  /* TODO(mkm): check header (magic and version) */
> -
> -  mg_mqtt_session_init(brk, s, nc);
> -  nc->priv_2 = s;
> -  mg_mqtt_add_session(s);
> -
> -  mg_mqtt_connack(nc, MG_EV_MQTT_CONNACK_ACCEPTED);
> -}
> -
> -static void mg_mqtt_broker_handle_subscribe(struct mg_connection *nc,
> -                                            struct mg_mqtt_message *msg) {
> -  struct mg_mqtt_session *ss = (struct mg_mqtt_session *) nc->priv_2;
> -  uint8_t qoss[MG_MQTT_MAX_SESSION_SUBSCRIPTIONS];
> -  size_t num_subs = 0;
> -  struct mg_str topic;
> -  uint8_t qos;
> -  int pos;
> -  struct mg_mqtt_topic_expression *te;
> -
> -  for (pos = 0;
> -       (pos = mg_mqtt_next_subscribe_topic(msg, &topic, &qos, pos)) != -1;) {
> -    if (num_subs >= sizeof(MG_MQTT_MAX_SESSION_SUBSCRIPTIONS) ||
> -        (ss->num_subscriptions + num_subs >=
> -         MG_MQTT_MAX_SESSION_SUBSCRIPTIONS)) {
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      return;
> -    }
> -    qoss[num_subs++] = qos;
> -  }
> -
> -  if (num_subs > 0) {
> -    te = (struct mg_mqtt_topic_expression *) MG_REALLOC(
> -        ss->subscriptions,
> -        sizeof(*ss->subscriptions) * (ss->num_subscriptions + num_subs));
> -    if (te == NULL) {
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      return;
> -    }
> -    ss->subscriptions = te;
> -    for (pos = 0;
> -         pos < (int) msg->payload.len &&
> -             (pos = mg_mqtt_next_subscribe_topic(msg, &topic, &qos, pos)) != -1;
> -         ss->num_subscriptions++) {
> -      te = &ss->subscriptions[ss->num_subscriptions];
> -      te->topic = (char *) MG_MALLOC(topic.len + 1);
> -      te->qos = qos;
> -      memcpy((char *) te->topic, topic.p, topic.len);
> -      ((char *) te->topic)[topic.len] = '\0';
> -    }
> -  }
> -
> -  if (pos == (int) msg->payload.len) {
> -    mg_mqtt_suback(nc, qoss, num_subs, msg->message_id);
> -  } else {
> -    /* We did not fully parse the payload, something must be wrong. */
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  }
> -}
> -
> -static void mg_mqtt_broker_handle_publish(struct mg_mqtt_broker *brk,
> -                                          struct mg_mqtt_message *msg) {
> -  struct mg_mqtt_session *s;
> -  size_t i;
> -
> -  for (s = mg_mqtt_next(brk, NULL); s != NULL; s = mg_mqtt_next(brk, s)) {
> -    for (i = 0; i < s->num_subscriptions; i++) {
> -      if (mg_mqtt_vmatch_topic_expression(s->subscriptions[i].topic,
> -                                          msg->topic)) {
> -        char buf[100], *p = buf;
> -        mg_asprintf(&p, sizeof(buf), "%.*s", (int) msg->topic.len,
> -                    msg->topic.p);
> -        if (p == NULL) {
> -          return;
> -        }
> -        mg_mqtt_publish(s->nc, p, 0, 0, msg->payload.p, msg->payload.len);
> -        if (p != buf) {
> -          MG_FREE(p);
> -        }
> -        break;
> -      }
> -    }
> -  }
> -}
> -
> -void mg_mqtt_broker(struct mg_connection *nc, int ev, void *data) {
> -  struct mg_mqtt_message *msg = (struct mg_mqtt_message *) data;
> -  struct mg_mqtt_broker *brk;
> -
> -  if (nc->listener) {
> -    brk = (struct mg_mqtt_broker *) nc->listener->priv_2;
> -  } else {
> -    brk = (struct mg_mqtt_broker *) nc->priv_2;
> -  }
> -
> -  switch (ev) {
> -    case MG_EV_ACCEPT:
> -      if (nc->proto_data == NULL) mg_set_protocol_mqtt(nc);
> -      nc->priv_2 = NULL; /* Clear up the inherited pointer to broker */
> -      break;
> -    case MG_EV_MQTT_CONNECT:
> -      if (nc->priv_2 == NULL) {
> -        mg_mqtt_broker_handle_connect(brk, nc);
> -      } else {
> -        /* Repeated CONNECT */
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      }
> -      break;
> -    case MG_EV_MQTT_SUBSCRIBE:
> -      if (nc->priv_2 != NULL) {
> -        mg_mqtt_broker_handle_subscribe(nc, msg);
> -      } else {
> -        /* Subscribe before CONNECT */
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      }
> -      break;
> -    case MG_EV_MQTT_PUBLISH:
> -      if (nc->priv_2 != NULL) {
> -        mg_mqtt_broker_handle_publish(brk, msg);
> -      } else {
> -        /* Publish before CONNECT */
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      }
> -      break;
> -    case MG_EV_CLOSE:
> -      if (nc->listener && nc->priv_2 != NULL) {
> -        mg_mqtt_close_session((struct mg_mqtt_session *) nc->priv_2);
> -      }
> -      break;
> -  }
> -}
> -
> -struct mg_mqtt_session *mg_mqtt_next(struct mg_mqtt_broker *brk,
> -                                     struct mg_mqtt_session *s) {
> -  return s == NULL ? LIST_FIRST(&brk->sessions) : LIST_NEXT(s, link);
> -}
> -
> -#endif /* MG_ENABLE_MQTT_BROKER */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_dns.c"
> -#endif
> -
> -#if MG_ENABLE_DNS
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_dns.h" */
> -
> -static int mg_dns_tid = 0xa0;
> -
> -struct mg_dns_header {
> -  uint16_t transaction_id;
> -  uint16_t flags;
> -  uint16_t num_questions;
> -  uint16_t num_answers;
> -  uint16_t num_authority_prs;
> -  uint16_t num_other_prs;
> -};
> -
> -struct mg_dns_resource_record *mg_dns_next_record(
> -    struct mg_dns_message *msg, int query,
> -    struct mg_dns_resource_record *prev) {
> -  struct mg_dns_resource_record *rr;
> -
> -  for (rr = (prev == NULL ? msg->answers : prev + 1);
> -       rr - msg->answers < msg->num_answers; rr++) {
> -    if (rr->rtype == query) {
> -      return rr;
> -    }
> -  }
> -  return NULL;
> -}
> -
> -int mg_dns_parse_record_data(struct mg_dns_message *msg,
> -                             struct mg_dns_resource_record *rr, void *data,
> -                             size_t data_len) {
> -  switch (rr->rtype) {
> -    case MG_DNS_A_RECORD:
> -      if (data_len < sizeof(struct in_addr)) {
> -        return -1;
> -      }
> -      if (rr->rdata.p + data_len > msg->pkt.p + msg->pkt.len) {
> -        return -1;
> -      }
> -      memcpy(data, rr->rdata.p, data_len);
> -      return 0;
> -#if MG_ENABLE_IPV6
> -    case MG_DNS_AAAA_RECORD:
> -      if (data_len < sizeof(struct in6_addr)) {
> -        return -1; /* LCOV_EXCL_LINE */
> -      }
> -      memcpy(data, rr->rdata.p, data_len);
> -      return 0;
> -#endif
> -    case MG_DNS_CNAME_RECORD:
> -      mg_dns_uncompress_name(msg, &rr->rdata, (char *) data, data_len);
> -      return 0;
> -  }
> -
> -  return -1;
> -}
> -
> -int mg_dns_insert_header(struct mbuf *io, size_t pos,
> -                         struct mg_dns_message *msg) {
> -  struct mg_dns_header header;
> -
> -  memset(&header, 0, sizeof(header));
> -  header.transaction_id = msg->transaction_id;
> -  header.flags = htons(msg->flags);
> -  header.num_questions = htons(msg->num_questions);
> -  header.num_answers = htons(msg->num_answers);
> -
> -  return mbuf_insert(io, pos, &header, sizeof(header));
> -}
> -
> -int mg_dns_copy_questions(struct mbuf *io, struct mg_dns_message *msg) {
> -  unsigned char *begin, *end;
> -  struct mg_dns_resource_record *last_q;
> -  if (msg->num_questions <= 0) return 0;
> -  begin = (unsigned char *) msg->pkt.p + sizeof(struct mg_dns_header);
> -  last_q = &msg->questions[msg->num_questions - 1];
> -  end = (unsigned char *) last_q->name.p + last_q->name.len + 4;
> -  return mbuf_append(io, begin, end - begin);
> -}
> -
> -int mg_dns_encode_name_s(struct mbuf *io, struct mg_str name) {
> -  const char *s;
> -  unsigned char n;
> -  size_t pos = io->len;
> -
> -  do {
> -    if ((s = mg_strchr(name, '.')) == NULL) {
> -      s = name.p + name.len;
> -    }
> -
> -    if (s - name.p > 127) {
> -      return -1; /* TODO(mkm) cover */
> -    }
> -    n = s - name.p;         /* chunk length */
> -    mbuf_append(io, &n, 1); /* send length */
> -    mbuf_append(io, name.p, n);
> -
> -    if (n < name.len && *s == '.') {
> -      n++;
> -    }
> -
> -    name.p += n;
> -    name.len -= n;
> -  } while (name.len > 0);
> -  mbuf_append(io, "\0", 1); /* Mark end of host name */
> -
> -  return io->len - pos;
> -}
> -
> -int mg_dns_encode_name(struct mbuf *io, const char *name, size_t len) {
> -  return mg_dns_encode_name_s(io, mg_mk_str_n(name, len));
> -}
> -
> -int mg_dns_encode_record(struct mbuf *io, struct mg_dns_resource_record *rr,
> -                         const char *name, size_t nlen, const void *rdata,
> -                         size_t rlen) {
> -  size_t pos = io->len;
> -  uint16_t u16;
> -  uint32_t u32;
> -
> -  if (rr->kind == MG_DNS_INVALID_RECORD) {
> -    return -1; /* LCOV_EXCL_LINE */
> -  }
> -
> -  if (mg_dns_encode_name(io, name, nlen) == -1) {
> -    return -1;
> -  }
> -
> -  u16 = htons(rr->rtype);
> -  mbuf_append(io, &u16, 2);
> -  u16 = htons(rr->rclass);
> -  mbuf_append(io, &u16, 2);
> -
> -  if (rr->kind == MG_DNS_ANSWER) {
> -    u32 = htonl(rr->ttl);
> -    mbuf_append(io, &u32, 4);
> -
> -    if (rr->rtype == MG_DNS_CNAME_RECORD) {
> -      int clen;
> -      /* fill size after encoding */
> -      size_t off = io->len;
> -      mbuf_append(io, &u16, 2);
> -      if ((clen = mg_dns_encode_name(io, (const char *) rdata, rlen)) == -1) {
> -        return -1;
> -      }
> -      u16 = clen;
> -      io->buf[off] = u16 >> 8;
> -      io->buf[off + 1] = u16 & 0xff;
> -    } else {
> -      u16 = htons((uint16_t) rlen);
> -      mbuf_append(io, &u16, 2);
> -      mbuf_append(io, rdata, rlen);
> -    }
> -  }
> -
> -  return io->len - pos;
> -}
> -
> -void mg_send_dns_query(struct mg_connection *nc, const char *name,
> -                       int query_type) {
> -  struct mg_dns_message *msg =
> -      (struct mg_dns_message *) MG_CALLOC(1, sizeof(*msg));
> -  struct mbuf pkt;
> -  struct mg_dns_resource_record *rr = &msg->questions[0];
> -
> -  DBG(("%s %d", name, query_type));
> -
> -  mbuf_init(&pkt, 64 /* Start small, it'll grow as needed. */);
> -
> -  msg->transaction_id = ++mg_dns_tid;
> -  msg->flags = 0x100;
> -  msg->num_questions = 1;
> -
> -  mg_dns_insert_header(&pkt, 0, msg);
> -
> -  rr->rtype = query_type;
> -  rr->rclass = 1; /* Class: inet */
> -  rr->kind = MG_DNS_QUESTION;
> -
> -  if (mg_dns_encode_record(&pkt, rr, name, strlen(name), NULL, 0) == -1) {
> -    /* TODO(mkm): return an error code */
> -    goto cleanup; /* LCOV_EXCL_LINE */
> -  }
> -
> -  /* TCP DNS requires messages to be prefixed with len */
> -  if (!(nc->flags & MG_F_UDP)) {
> -    uint16_t len = htons((uint16_t) pkt.len);
> -    mbuf_insert(&pkt, 0, &len, 2);
> -  }
> -
> -  mg_send(nc, pkt.buf, pkt.len);
> -  mbuf_free(&pkt);
> -
> -cleanup:
> -  MG_FREE(msg);
> -}
> -
> -static unsigned char *mg_parse_dns_resource_record(
> -    unsigned char *data, unsigned char *end, struct mg_dns_resource_record *rr,
> -    int reply) {
> -  unsigned char *name = data;
> -  int chunk_len, data_len;
> -
> -  while (data < end && (chunk_len = *data)) {
> -    if (((unsigned char *) data)[0] & 0xc0) {
> -      data += 1;
> -      break;
> -    }
> -    data += chunk_len + 1;
> -  }
> -
> -  if (data > end - 5) {
> -    return NULL;
> -  }
> -
> -  rr->name.p = (char *) name;
> -  rr->name.len = data - name + 1;
> -  data++;
> -
> -  rr->rtype = data[0] << 8 | data[1];
> -  data += 2;
> -
> -  rr->rclass = data[0] << 8 | data[1];
> -  data += 2;
> -
> -  rr->kind = reply ? MG_DNS_ANSWER : MG_DNS_QUESTION;
> -  if (reply) {
> -    if (data >= end - 6) {
> -      return NULL;
> -    }
> -
> -    rr->ttl = (uint32_t) data[0] << 24 | (uint32_t) data[1] << 16 |
> -              data[2] << 8 | data[3];
> -    data += 4;
> -
> -    data_len = *data << 8 | *(data + 1);
> -    data += 2;
> -
> -    rr->rdata.p = (char *) data;
> -    rr->rdata.len = data_len;
> -    data += data_len;
> -  }
> -  return data;
> -}
> -
> -int mg_parse_dns(const char *buf, int len, struct mg_dns_message *msg) {
> -  struct mg_dns_header *header = (struct mg_dns_header *) buf;
> -  unsigned char *data = (unsigned char *) buf + sizeof(*header);
> -  unsigned char *end = (unsigned char *) buf + len;
> -  int i;
> -
> -  memset(msg, 0, sizeof(*msg));
> -  msg->pkt.p = buf;
> -  msg->pkt.len = len;
> -
> -  if (len < (int) sizeof(*header)) return -1;
> -
> -  msg->transaction_id = header->transaction_id;
> -  msg->flags = ntohs(header->flags);
> -  msg->num_questions = ntohs(header->num_questions);
> -  if (msg->num_questions > (int) ARRAY_SIZE(msg->questions)) {
> -    msg->num_questions = (int) ARRAY_SIZE(msg->questions);
> -  }
> -  msg->num_answers = ntohs(header->num_answers);
> -  if (msg->num_answers > (int) ARRAY_SIZE(msg->answers)) {
> -    msg->num_answers = (int) ARRAY_SIZE(msg->answers);
> -  }
> -
> -  for (i = 0; i < msg->num_questions; i++) {
> -    data = mg_parse_dns_resource_record(data, end, &msg->questions[i], 0);
> -    if (data == NULL) return -1;
> -  }
> -
> -  for (i = 0; i < msg->num_answers; i++) {
> -    data = mg_parse_dns_resource_record(data, end, &msg->answers[i], 1);
> -    if (data == NULL) return -1;
> -  }
> -
> -  return 0;
> -}
> -
> -size_t mg_dns_uncompress_name(struct mg_dns_message *msg, struct mg_str *name,
> -                              char *dst, int dst_len) {
> -  int chunk_len, num_ptrs = 0;
> -  char *old_dst = dst;
> -  const unsigned char *data = (unsigned char *) name->p;
> -  const unsigned char *end = (unsigned char *) msg->pkt.p + msg->pkt.len;
> -
> -  if (data >= end) {
> -    return 0;
> -  }
> -
> -  while ((chunk_len = *data++)) {
> -    int leeway = dst_len - (dst - old_dst);
> -    if (data >= end) {
> -      return 0;
> -    }
> -
> -    if ((chunk_len & 0xc0) == 0xc0) {
> -      uint16_t off = (data[-1] & (~0xc0)) << 8 | data[0];
> -      if (off >= msg->pkt.len) {
> -        return 0;
> -      }
> -      /* Basic circular loop avoidance: allow up to 16 pointer hops. */
> -      if (++num_ptrs > 15) {
> -        return 0;
> -      }
> -      data = (unsigned char *) msg->pkt.p + off;
> -      continue;
> -    }
> -    if (chunk_len > 63) {
> -      return 0;
> -    }
> -    if (chunk_len > leeway) {
> -      chunk_len = leeway;
> -    }
> -
> -    if (data + chunk_len >= end) {
> -      return 0;
> -    }
> -
> -    memcpy(dst, data, chunk_len);
> -    data += chunk_len;
> -    dst += chunk_len;
> -    leeway -= chunk_len;
> -    if (leeway == 0) {
> -      return dst - old_dst;
> -    }
> -    *dst++ = '.';
> -  }
> -
> -  if (dst != old_dst) {
> -    *--dst = 0;
> -  }
> -  return dst - old_dst;
> -}
> -
> -static void dns_handler(struct mg_connection *nc, int ev,
> -                        void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct mbuf *io = &nc->recv_mbuf;
> -  struct mg_dns_message msg;
> -
> -  /* Pass low-level events to the user handler */
> -  nc->handler(nc, ev, ev_data MG_UD_ARG(user_data));
> -
> -  switch (ev) {
> -    case MG_EV_RECV:
> -      if (!(nc->flags & MG_F_UDP)) {
> -        mbuf_remove(&nc->recv_mbuf, 2);
> -      }
> -      if (mg_parse_dns(nc->recv_mbuf.buf, nc->recv_mbuf.len, &msg) == -1) {
> -        /* reply + recursion allowed + format error */
> -        memset(&msg, 0, sizeof(msg));
> -        msg.flags = 0x8081;
> -        mg_dns_insert_header(io, 0, &msg);
> -        if (!(nc->flags & MG_F_UDP)) {
> -          uint16_t len = htons((uint16_t) io->len);
> -          mbuf_insert(io, 0, &len, 2);
> -        }
> -        mg_send(nc, io->buf, io->len);
> -      } else {
> -        /* Call user handler with parsed message */
> -        nc->handler(nc, MG_DNS_MESSAGE, &msg MG_UD_ARG(user_data));
> -      }
> -      mbuf_remove(io, io->len);
> -      break;
> -  }
> -}
> -
> -void mg_set_protocol_dns(struct mg_connection *nc) {
> -  nc->proto_handler = dns_handler;
> -}
> -
> -#endif /* MG_ENABLE_DNS */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_dns_server.c"
> -#endif
> -
> -#if MG_ENABLE_DNS_SERVER
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "dns-server.h" */
> -
> -struct mg_dns_reply mg_dns_create_reply(struct mbuf *io,
> -                                        struct mg_dns_message *msg) {
> -  struct mg_dns_reply rep;
> -  rep.msg = msg;
> -  rep.io = io;
> -  rep.start = io->len;
> -
> -  /* reply + recursion allowed */
> -  msg->flags |= 0x8080;
> -  mg_dns_copy_questions(io, msg);
> -
> -  msg->num_answers = 0;
> -  return rep;
> -}
> -
> -void mg_dns_send_reply(struct mg_connection *nc, struct mg_dns_reply *r) {
> -  size_t sent = r->io->len - r->start;
> -  mg_dns_insert_header(r->io, r->start, r->msg);
> -  if (!(nc->flags & MG_F_UDP)) {
> -    uint16_t len = htons((uint16_t) sent);
> -    mbuf_insert(r->io, r->start, &len, 2);
> -  }
> -
> -  if (&nc->send_mbuf != r->io) {
> -    mg_send(nc, r->io->buf + r->start, r->io->len - r->start);
> -    r->io->len = r->start;
> -  }
> -}
> -
> -int mg_dns_reply_record(struct mg_dns_reply *reply,
> -                        struct mg_dns_resource_record *question,
> -                        const char *name, int rtype, int ttl, const void *rdata,
> -                        size_t rdata_len) {
> -  struct mg_dns_message *msg = (struct mg_dns_message *) reply->msg;
> -  char rname[512];
> -  struct mg_dns_resource_record *ans = &msg->answers[msg->num_answers];
> -  if (msg->num_answers >= MG_MAX_DNS_ANSWERS) {
> -    return -1; /* LCOV_EXCL_LINE */
> -  }
> -
> -  if (name == NULL) {
> -    name = rname;
> -    rname[511] = 0;
> -    mg_dns_uncompress_name(msg, &question->name, rname, sizeof(rname) - 1);
> -  }
> -
> -  *ans = *question;
> -  ans->kind = MG_DNS_ANSWER;
> -  ans->rtype = rtype;
> -  ans->ttl = ttl;
> -
> -  if (mg_dns_encode_record(reply->io, ans, name, strlen(name), rdata,
> -                           rdata_len) == -1) {
> -    return -1; /* LCOV_EXCL_LINE */
> -  };
> -
> -  msg->num_answers++;
> -  return 0;
> -}
> -
> -#endif /* MG_ENABLE_DNS_SERVER */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_resolv.c"
> -#endif
> -
> -#if MG_ENABLE_ASYNC_RESOLVER
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_resolv.h" */
> -
> -#ifndef MG_DEFAULT_NAMESERVER
> -#define MG_DEFAULT_NAMESERVER "8.8.8.8"
> -#endif
> -
> -struct mg_resolve_async_request {
> -  char name[1024];
> -  int query;
> -  mg_resolve_callback_t callback;
> -  void *data;
> -  time_t timeout;
> -  int max_retries;
> -  enum mg_resolve_err err;
> -
> -  /* state */
> -  time_t last_time;
> -  int retries;
> -};
> -
> -/*
> - * Find what nameserver to use.
> - *
> - * Return 0 if OK, -1 if error
> - */
> -static int mg_get_ip_address_of_nameserver(char *name, size_t name_len) {
> -  int ret = -1;
> -
> +static struct mg_fd *p_open(const char *path, int flags) {
> +  const char *mode = flags == (MG_FS_READ | MG_FS_WRITE) ? "r+b"
> +                     : flags & MG_FS_READ                ? "rb"
> +                     : flags & MG_FS_WRITE               ? "wb"
> +                                                         : "";
> +  void *fp = NULL;
> +  struct mg_fd *fd = NULL;
>   #ifdef _WIN32
> -  int i;
> -  LONG err;
> -  HKEY hKey, hSub;
> -  wchar_t subkey[512], value[128],
> -      *key = L"SYSTEM\\ControlSet001\\Services\\Tcpip\\Parameters\\Interfaces";
> -
> -  if ((err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey)) !=
> -      ERROR_SUCCESS) {
> -    fprintf(stderr, "cannot open reg key %S: %ld\n", key, err);
> -    ret = -1;
> -  } else {
> -    for (ret = -1, i = 0; 1; i++) {
> -      DWORD subkey_size = sizeof(subkey), type, len = sizeof(value);
> -      if (RegEnumKeyExW(hKey, i, subkey, &subkey_size, NULL, NULL, NULL,
> -                        NULL) != ERROR_SUCCESS) {
> -        break;
> -      }
> -      if (RegOpenKeyExW(hKey, subkey, 0, KEY_READ, &hSub) == ERROR_SUCCESS &&
> -          ((RegQueryValueExW(hSub, L"NameServer", 0, &type, (void *) value,
> -                             &len) == ERROR_SUCCESS &&
> -            value[0] != '\0') ||
> -           (RegQueryValueExW(hSub, L"DhcpNameServer", 0, &type, (void *) value,
> -                             &len) == ERROR_SUCCESS &&
> -            value[0] != '\0'))) {
> -        /*
> -         * See https://github.com/cesanta/mongoose/issues/176
> -         * The value taken from the registry can be empty, a single
> -         * IP address, or multiple IP addresses separated by comma.
> -         * If it's empty, check the next interface.
> -         * If it's multiple IP addresses, take the first one.
> -         */
> -        wchar_t *comma = wcschr(value, ',');
> -        if (comma != NULL) {
> -          *comma = '\0';
> -        }
> -        /* %S will convert wchar_t -> char */
> -        snprintf(name, name_len, "%S", value);
> -        ret = 0;
> -        RegCloseKey(hSub);
> -        break;
> -      }
> -    }
> -    RegCloseKey(hKey);
> -  }
> -#elif MG_ENABLE_FILESYSTEM && defined(MG_RESOLV_CONF_FILE_NAME)
> -  FILE *fp;
> -  char line[512];
> -
> -  if ((fp = mg_fopen(MG_RESOLV_CONF_FILE_NAME, "r")) == NULL) {
> -    ret = -1;
> -  } else {
> -    /* Try to figure out what nameserver to use */
> -    for (ret = -1; fgets(line, sizeof(line), fp) != NULL;) {
> -      unsigned int a, b, c, d;
> -      if (sscanf(line, "nameserver %u.%u.%u.%u", &a, &b, &c, &d) == 4) {
> -        snprintf(name, name_len, "%u.%u.%u.%u", a, b, c, d);
> -        ret = 0;
> -        break;
> -      }
> -    }
> -    (void) fclose(fp);
> -  }
> -#else
> -  snprintf(name, name_len, "%s", MG_DEFAULT_NAMESERVER);
> -#endif /* _WIN32 */
> -
> -  return ret;
> -}
> -
> -int mg_resolve_from_hosts_file(const char *name, union socket_address *usa) {
> -#if MG_ENABLE_FILESYSTEM && defined(MG_HOSTS_FILE_NAME)
> -  /* TODO(mkm) cache /etc/hosts */
> -  FILE *fp;
> -  char line[1024];
> -  char *p;
> -  char alias[256];
> -  unsigned int a, b, c, d;
> -  int len = 0;
> -
> -  if ((fp = mg_fopen(MG_HOSTS_FILE_NAME, "r")) == NULL) {
> -    return -1;
> -  }
> -
> -  for (; fgets(line, sizeof(line), fp) != NULL;) {
> -    if (line[0] == '#') continue;
> -
> -    if (sscanf(line, "%u.%u.%u.%u%n", &a, &b, &c, &d, &len) == 0) {
> -      /* TODO(mkm): handle ipv6 */
> -      continue;
> -    }
> -    for (p = line + len; sscanf(p, "%s%n", alias, &len) == 1; p += len) {
> -      if (strcmp(alias, name) == 0) {
> -        usa->sin.sin_addr.s_addr = htonl(a << 24 | b << 16 | c << 8 | d);
> -        fclose(fp);
> -        return 0;
> -      }
> -    }
> -  }
> -
> -  fclose(fp);
> +  wchar_t b1[PATH_MAX], b2[10];
> +  MultiByteToWideChar(CP_UTF8, 0, path, -1, b1, sizeof(b1) / sizeof(b1[0]));
> +  MultiByteToWideChar(CP_UTF8, 0, mode, -1, b2, sizeof(b2) / sizeof(b2[0]));
> +  fp = (void *) _wfopen(b1, b2);
>   #else
> -  (void) name;
> -  (void) usa;
> -#endif
> -
> -  return -1;
> -}
> -
> -static void mg_resolve_async_eh(struct mg_connection *nc, int ev,
> -                                void *data MG_UD_ARG(void *user_data)) {
> -  time_t now = (time_t) mg_time();
> -  struct mg_resolve_async_request *req;
> -  struct mg_dns_message *msg;
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -  void *user_data = nc->user_data;
> -#endif
> -
> -  if (ev != MG_EV_POLL) {
> -    DBG(("ev=%d user_data=%p", ev, user_data));
> -  }
> -
> -  req = (struct mg_resolve_async_request *) user_data;
> -
> -  if (req == NULL) {
> -    return;
> -  }
> -
> -  switch (ev) {
> -    case MG_EV_POLL:
> -      if (req->retries > req->max_retries) {
> -        req->err = MG_RESOLVE_EXCEEDED_RETRY_COUNT;
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        break;
> -      }
> -      if (nc->flags & MG_F_CONNECTING) break;
> -    /* fallthrough */
> -    case MG_EV_CONNECT:
> -      if (req->retries == 0 || now - req->last_time >= req->timeout) {
> -        mg_send_dns_query(nc, req->name, req->query);
> -        req->last_time = now;
> -        req->retries++;
> -      }
> -      break;
> -    case MG_EV_RECV:
> -      msg = (struct mg_dns_message *) MG_MALLOC(sizeof(*msg));
> -      if (mg_parse_dns(nc->recv_mbuf.buf, *(int *) data, msg) == 0 &&
> -          msg->num_answers > 0) {
> -        req->callback(msg, req->data, MG_RESOLVE_OK);
> -        nc->user_data = NULL;
> -        MG_FREE(req);
> -      } else {
> -        req->err = MG_RESOLVE_NO_ANSWERS;
> -      }
> -      MG_FREE(msg);
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      break;
> -    case MG_EV_SEND:
> -      /*
> -       * If a send error occurs, prevent closing of the connection by the core.
> -       * We will retry after timeout.
> -       */
> -      nc->flags &= ~MG_F_CLOSE_IMMEDIATELY;
> -      mbuf_remove(&nc->send_mbuf, nc->send_mbuf.len);
> -      break;
> -    case MG_EV_TIMER:
> -      req->err = MG_RESOLVE_TIMEOUT;
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      break;
> -    case MG_EV_CLOSE:
> -      /* If we got here with request still not done, fire an error callback. */
> -      if (req != NULL) {
> -        char addr[32];
> -        mg_sock_addr_to_str(&nc->sa, addr, sizeof(addr), MG_SOCK_STRINGIFY_IP);
> -#ifdef MG_LOG_DNS_FAILURES
> -        LOG(LL_ERROR, ("Failed to resolve '%s', server %s", req->name, addr));
> +  fp = (void *) fopen(path, mode);
>   #endif
> -        req->callback(NULL, req->data, req->err);
> -        nc->user_data = NULL;
> -        MG_FREE(req);
> -      }
> -      break;
> -  }
> +  if (fp == NULL) return NULL;
> +  fd = (struct mg_fd *) calloc(1, sizeof(*fd));
> +  fd->fd = fp;
> +  fd->fs = &mg_fs_posix;
> +  return fd;
>   }
>   
> -int mg_resolve_async(struct mg_mgr *mgr, const char *name, int query,
> -                     mg_resolve_callback_t cb, void *data) {
> -  struct mg_resolve_async_opts opts;
> -  memset(&opts, 0, sizeof(opts));
> -  return mg_resolve_async_opt(mgr, name, query, cb, data, opts);
> +static void p_close(struct mg_fd *fd) {
> +  if (fd != NULL) fclose((FILE *) fd->fd), free(fd);
>   }
>   
> -int mg_resolve_async_opt(struct mg_mgr *mgr, const char *name, int query,
> -                         mg_resolve_callback_t cb, void *data,
> -                         struct mg_resolve_async_opts opts) {
> -  struct mg_resolve_async_request *req;
> -  struct mg_connection *dns_nc;
> -  const char *nameserver = opts.nameserver;
> -  char dns_server_buff[17], nameserver_url[26];
> -
> -  if (nameserver == NULL) {
> -    nameserver = mgr->nameserver;
> -  }
> -
> -  DBG(("%s %d %p", name, query, opts.dns_conn));
> -
> -  /* resolve with DNS */
> -  req = (struct mg_resolve_async_request *) MG_CALLOC(1, sizeof(*req));
> -  if (req == NULL) {
> -    return -1;
> -  }
> -
> -  strncpy(req->name, name, sizeof(req->name));
> -  req->name[sizeof(req->name) - 1] = '\0';
> -
> -  req->query = query;
> -  req->callback = cb;
> -  req->data = data;
> -  /* TODO(mkm): parse defaults out of resolve.conf */
> -  req->max_retries = opts.max_retries ? opts.max_retries : 2;
> -  req->timeout = opts.timeout ? opts.timeout : 5;
> -
> -  /* Lazily initialize dns server */
> -  if (nameserver == NULL) {
> -    if (mg_get_ip_address_of_nameserver(dns_server_buff,
> -                                        sizeof(dns_server_buff)) != -1) {
> -      nameserver = dns_server_buff;
> -    } else {
> -      nameserver = MG_DEFAULT_NAMESERVER;
> -    }
> -  }
> -
> -  snprintf(nameserver_url, sizeof(nameserver_url), "udp://%s:53", nameserver);
> -
> -  dns_nc = mg_connect(mgr, nameserver_url, MG_CB(mg_resolve_async_eh, NULL));
> -  if (dns_nc == NULL) {
> -    MG_FREE(req);
> -    return -1;
> -  }
> -  dns_nc->user_data = req;
> -  if (opts.dns_conn != NULL) {
> -    *opts.dns_conn = dns_nc;
> -  }
> -
> -  return 0;
> +static size_t p_read(void *fp, void *buf, size_t len) {
> +  return fread(buf, 1, len, (FILE *) fp);
>   }
>   
> -void mg_set_nameserver(struct mg_mgr *mgr, const char *nameserver) {
> -  MG_FREE((char *) mgr->nameserver);
> -  mgr->nameserver = NULL;
> -  if (nameserver != NULL) {
> -    mgr->nameserver = strdup(nameserver);
> -  }
> +static size_t p_write(void *fp, const void *buf, size_t len) {
> +  return fwrite(buf, 1, len, (FILE *) fp);
>   }
>   
> -#endif /* MG_ENABLE_ASYNC_RESOLVER */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_coap.c"
> +static size_t p_seek(void *fp, size_t offset) {
> +#if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \
> +    _XOPEN_SOURCE >= 600
> +  fseeko((FILE *) fp, (off_t) offset, SEEK_SET);
> +#else
> +  fseek((FILE *) fp, (long) offset, SEEK_SET);
>   #endif
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_coap.h" */
> -
> -#if MG_ENABLE_COAP
> -
> -void mg_coap_free_options(struct mg_coap_message *cm) {
> -  while (cm->options != NULL) {
> -    struct mg_coap_option *next = cm->options->next;
> -    MG_FREE(cm->options);
> -    cm->options = next;
> -  }
> -}
> -
> -struct mg_coap_option *mg_coap_add_option(struct mg_coap_message *cm,
> -                                          uint32_t number, char *value,
> -                                          size_t len) {
> -  struct mg_coap_option *new_option =
> -      (struct mg_coap_option *) MG_CALLOC(1, sizeof(*new_option));
> -
> -  new_option->number = number;
> -  new_option->value.p = value;
> -  new_option->value.len = len;
> -
> -  if (cm->options == NULL) {
> -    cm->options = cm->optiomg_tail = new_option;
> -  } else {
> -    /*
> -     * A very simple attention to help clients to compose options:
> -     * CoAP wants to see options ASC ordered.
> -     * Could be change by using sort in coap_compose
> -     */
> -    if (cm->optiomg_tail->number <= new_option->number) {
> -      /* if option is already ordered just add it */
> -      cm->optiomg_tail = cm->optiomg_tail->next = new_option;
> -    } else {
> -      /* looking for appropriate position */
> -      struct mg_coap_option *current_opt = cm->options;
> -      struct mg_coap_option *prev_opt = 0;
> -
> -      while (current_opt != NULL) {
> -        if (current_opt->number > new_option->number) {
> -          break;
> -        }
> -        prev_opt = current_opt;
> -        current_opt = current_opt->next;
> -      }
> -
> -      if (prev_opt != NULL) {
> -        prev_opt->next = new_option;
> -        new_option->next = current_opt;
> -      } else {
> -        /* insert new_option to the beginning */
> -        new_option->next = cm->options;
> -        cm->options = new_option;
> -      }
> -    }
> -  }
> -
> -  return new_option;
> -}
> -
> -/*
> - * Fills CoAP header in mg_coap_message.
> - *
> - * Helper function.
> - */
> -static char *coap_parse_header(char *ptr, struct mbuf *io,
> -                               struct mg_coap_message *cm) {
> -  if (io->len < sizeof(uint32_t)) {
> -    cm->flags |= MG_COAP_NOT_ENOUGH_DATA;
> -    return NULL;
> -  }
> -
> -  /*
> -   * Version (Ver):  2-bit unsigned integer.  Indicates the CoAP version
> -   * number.  Implementations of this specification MUST set this field
> -   * to 1 (01 binary).  Other values are reserved for future versions.
> -   * Messages with unknown version numbers MUST be silently ignored.
> -   */
> -  if (((uint8_t) *ptr >> 6) != 1) {
> -    cm->flags |= MG_COAP_IGNORE;
> -    return NULL;
> -  }
> -
> -  /*
> -   * Type (T):  2-bit unsigned integer.  Indicates if this message is of
> -   * type Confirmable (0), Non-confirmable (1), Acknowledgement (2), or
> -   * Reset (3).
> -   */
> -  cm->msg_type = ((uint8_t) *ptr & 0x30) >> 4;
> -  cm->flags |= MG_COAP_MSG_TYPE_FIELD;
> -
> -  /*
> -   * Token Length (TKL):  4-bit unsigned integer.  Indicates the length of
> -   * the variable-length Token field (0-8 bytes).  Lengths 9-15 are
> -   * reserved, MUST NOT be sent, and MUST be processed as a message
> -   * format error.
> -   */
> -  cm->token.len = *ptr & 0x0F;
> -  if (cm->token.len > 8) {
> -    cm->flags |= MG_COAP_FORMAT_ERROR;
> -    return NULL;
> -  }
> -
> -  ptr++;
> -
> -  /*
> -   * Code:  8-bit unsigned integer, split into a 3-bit class (most
> -   * significant bits) and a 5-bit detail (least significant bits)
> -   */
> -  cm->code_class = (uint8_t) *ptr >> 5;
> -  cm->code_detail = *ptr & 0x1F;
> -  cm->flags |= (MG_COAP_CODE_CLASS_FIELD | MG_COAP_CODE_DETAIL_FIELD);
> -
> -  ptr++;
> -
> -  /* Message ID:  16-bit unsigned integer in network byte order. */
> -  cm->msg_id = (uint8_t) *ptr << 8 | (uint8_t) * (ptr + 1);
> -  cm->flags |= MG_COAP_MSG_ID_FIELD;
> -
> -  ptr += 2;
> -
> -  return ptr;
> +  return (size_t) ftell((FILE *) fp);
>   }
> -
> -/*
> - * Fills token information in mg_coap_message.
> - *
> - * Helper function.
> - */
> -static char *coap_get_token(char *ptr, struct mbuf *io,
> -                            struct mg_coap_message *cm) {
> -  if (cm->token.len != 0) {
> -    if (ptr + cm->token.len > io->buf + io->len) {
> -      cm->flags |= MG_COAP_NOT_ENOUGH_DATA;
> -      return NULL;
> -    } else {
> -      cm->token.p = ptr;
> -      ptr += cm->token.len;
> -      cm->flags |= MG_COAP_TOKEN_FIELD;
> -    }
> -  }
> -
> -  return ptr;
> +#else
> +static char *p_realpath(const char *path, char *resolved_path) {
> +  (void) path, (void) resolved_path;
> +  return NULL;
>   }
>   
> -/*
> - * Returns Option Delta or Length.
> - *
> - * Helper function.
> - */
> -static int coap_get_ext_opt(char *ptr, struct mbuf *io, uint16_t *opt_info) {
> -  int ret = 0;
> -
> -  if (*opt_info == 13) {
> -    /*
> -     * 13:  An 8-bit unsigned integer follows the initial byte and
> -     * indicates the Option Delta/Length minus 13.
> -     */
> -    if (ptr < io->buf + io->len) {
> -      *opt_info = (uint8_t) *ptr + 13;
> -      ret = sizeof(uint8_t);
> -    } else {
> -      ret = -1; /* LCOV_EXCL_LINE */
> -    }
> -  } else if (*opt_info == 14) {
> -    /*
> -     * 14:  A 16-bit unsigned integer in network byte order follows the
> -     * initial byte and indicates the Option Delta/Length minus 269.
> -     */
> -    if (ptr + sizeof(uint8_t) < io->buf + io->len) {
> -      *opt_info = ((uint8_t) *ptr << 8 | (uint8_t) * (ptr + 1)) + 269;
> -      ret = sizeof(uint16_t);
> -    } else {
> -      ret = -1; /* LCOV_EXCL_LINE */
> -    }
> -  }
> -
> -  return ret;
> +static int p_stat(const char *path, size_t *size, time_t *mtime) {
> +  (void) path, (void) size, (void) mtime;
> +  return 0;
>   }
>   
> -/*
> - * Fills options in mg_coap_message.
> - *
> - * Helper function.
> - *
> - * General options format:
> - * +---------------+---------------+
> - * | Option Delta  | Option Length |  1 byte
> - * +---------------+---------------+
> - * \    Option Delta (extended)    \  0-2 bytes
> - * +-------------------------------+
> - * / Option Length  (extended)     \  0-2 bytes
> - * +-------------------------------+
> - * \         Option Value          \  0 or more bytes
> - * +-------------------------------+
> - */
> -static char *coap_get_options(char *ptr, struct mbuf *io,
> -                              struct mg_coap_message *cm) {
> -  uint16_t prev_opt = 0;
> -
> -  if (ptr == io->buf + io->len) {
> -    /* end of packet, ok */
> -    return NULL;
> -  }
> -
> -  /* 0xFF is payload marker */
> -  while (ptr < io->buf + io->len && (uint8_t) *ptr != 0xFF) {
> -    uint16_t option_delta, option_lenght;
> -    int optinfo_len;
> -
> -    /* Option Delta:  4-bit unsigned integer */
> -    option_delta = ((uint8_t) *ptr & 0xF0) >> 4;
> -    /* Option Length:  4-bit unsigned integer */
> -    option_lenght = *ptr & 0x0F;
> -
> -    if (option_delta == 15 || option_lenght == 15) {
> -      /*
> -       * 15:  Reserved for future use.  If the field is set to this value,
> -       * it MUST be processed as a message format error
> -       */
> -      cm->flags |= MG_COAP_FORMAT_ERROR;
> -      break;
> -    }
> -
> -    ptr++;
> -
> -    /* check for extended option delta */
> -    optinfo_len = coap_get_ext_opt(ptr, io, &option_delta);
> -    if (optinfo_len == -1) {
> -      cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */
> -      break;                                /* LCOV_EXCL_LINE */
> -    }
> -
> -    ptr += optinfo_len;
> -
> -    /* check or extended option lenght */
> -    optinfo_len = coap_get_ext_opt(ptr, io, &option_lenght);
> -    if (optinfo_len == -1) {
> -      cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */
> -      break;                                /* LCOV_EXCL_LINE */
> -    }
> -
> -    ptr += optinfo_len;
> -
> -    /*
> -     * Instead of specifying the Option Number directly, the instances MUST
> -     * appear in order of their Option Numbers and a delta encoding is used
> -     * between them.
> -     */
> -    option_delta += prev_opt;
> -
> -    mg_coap_add_option(cm, option_delta, ptr, option_lenght);
> -
> -    prev_opt = option_delta;
> -
> -    if (ptr + option_lenght > io->buf + io->len) {
> -      cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */
> -      break;                                /* LCOV_EXCL_LINE */
> -    }
> -
> -    ptr += option_lenght;
> -  }
> -
> -  if ((cm->flags & MG_COAP_ERROR) != 0) {
> -    mg_coap_free_options(cm);
> -    return NULL;
> -  }
> -
> -  cm->flags |= MG_COAP_OPTIOMG_FIELD;
> -
> -  if (ptr == io->buf + io->len) {
> -    /* end of packet, ok */
> -    return NULL;
> -  }
> -
> -  ptr++;
> -
> -  return ptr;
> +static void p_list(const char *path, void (*fn)(const char *, void *),
> +                   void *userdata) {
> +  (void) path, (void) fn, (void) userdata;
>   }
>   
> -uint32_t mg_coap_parse(struct mbuf *io, struct mg_coap_message *cm) {
> -  char *ptr;
> -
> -  memset(cm, 0, sizeof(*cm));
> -
> -  if ((ptr = coap_parse_header(io->buf, io, cm)) == NULL) {
> -    return cm->flags;
> -  }
> -
> -  if ((ptr = coap_get_token(ptr, io, cm)) == NULL) {
> -    return cm->flags;
> -  }
> -
> -  if ((ptr = coap_get_options(ptr, io, cm)) == NULL) {
> -    return cm->flags;
> -  }
> -
> -  /* the rest is payload */
> -  cm->payload.len = io->len - (ptr - io->buf);
> -  if (cm->payload.len != 0) {
> -    cm->payload.p = ptr;
> -    cm->flags |= MG_COAP_PAYLOAD_FIELD;
> -  }
> -
> -  return cm->flags;
> +static struct mg_fd *p_open(const char *path, int flags) {
> +  (void) path, (void) flags;
> +  return NULL;
>   }
>   
> -/*
> - * Calculates extended size of given Opt Number/Length in coap message.
> - *
> - * Helper function.
> - */
> -static size_t coap_get_ext_opt_size(uint32_t value) {
> -  int ret = 0;
> -
> -  if (value >= 13 && value <= 0xFF + 13) {
> -    ret = sizeof(uint8_t);
> -  } else if (value > 0xFF + 13 && value <= 0xFFFF + 269) {
> -    ret = sizeof(uint16_t);
> -  }
> -
> -  return ret;
> +static void p_close(struct mg_fd *fd) {
> +  (void) fd;
>   }
>   
> -/*
> - * Splits given Opt Number/Length into base and ext values.
> - *
> - * Helper function.
> - */
> -static int coap_split_opt(uint32_t value, uint8_t *base, uint16_t *ext) {
> -  int ret = 0;
> -
> -  if (value < 13) {
> -    *base = value;
> -  } else if (value >= 13 && value <= 0xFF + 13) {
> -    *base = 13;
> -    *ext = value - 13;
> -    ret = sizeof(uint8_t);
> -  } else if (value > 0xFF + 13 && value <= 0xFFFF + 269) {
> -    *base = 14;
> -    *ext = value - 269;
> -    ret = sizeof(uint16_t);
> -  }
> -
> -  return ret;
> +static size_t p_read(void *fd, void *buf, size_t len) {
> +  (void) fd, (void) buf, (void) len;
> +  return 0;
>   }
>   
> -/*
> - * Puts uint16_t (in network order) into given char stream.
> - *
> - * Helper function.
> - */
> -static char *coap_add_uint16(char *ptr, uint16_t val) {
> -  *ptr = val >> 8;
> -  ptr++;
> -  *ptr = val & 0x00FF;
> -  ptr++;
> -  return ptr;
> +static size_t p_write(void *fd, const void *buf, size_t len) {
> +  (void) fd, (void) buf, (void) len;
> +  return 0;
>   }
>   
> -/*
> - * Puts extended value of Opt Number/Length into given char stream.
> - *
> - * Helper function.
> - */
> -static char *coap_add_opt_info(char *ptr, uint16_t val, size_t len) {
> -  if (len == sizeof(uint8_t)) {
> -    *ptr = (char) val;
> -    ptr++;
> -  } else if (len == sizeof(uint16_t)) {
> -    ptr = coap_add_uint16(ptr, val);
> -  }
> -
> -  return ptr;
> +static size_t p_seek(void *fd, size_t offset) {
> +  (void) fd, (void) offset;
> +  return (size_t) ~0;
>   }
> +#endif
>   
> -/*
> - * Verifies given mg_coap_message and calculates message size for it.
> - *
> - * Helper function.
> - */
> -static uint32_t coap_calculate_packet_size(struct mg_coap_message *cm,
> -                                           size_t *len) {
> -  struct mg_coap_option *opt;
> -  uint32_t prev_opt_number;
> -
> -  *len = 4; /* header */
> -  if (cm->msg_type > MG_COAP_MSG_MAX) {
> -    return MG_COAP_ERROR | MG_COAP_MSG_TYPE_FIELD;
> -  }
> -  if (cm->token.len > 8) {
> -    return MG_COAP_ERROR | MG_COAP_TOKEN_FIELD;
> -  }
> -  if (cm->code_class > 7) {
> -    return MG_COAP_ERROR | MG_COAP_CODE_CLASS_FIELD;
> -  }
> -  if (cm->code_detail > 31) {
> -    return MG_COAP_ERROR | MG_COAP_CODE_DETAIL_FIELD;
> -  }
> -
> -  *len += cm->token.len;
> -  if (cm->payload.len != 0) {
> -    *len += cm->payload.len + 1; /* ... + 1; add payload marker */
> -  }
> -
> -  opt = cm->options;
> -  prev_opt_number = 0;
> -  while (opt != NULL) {
> -    *len += 1; /* basic delta/length */
> -    *len += coap_get_ext_opt_size(opt->number - prev_opt_number);
> -    *len += coap_get_ext_opt_size((uint32_t) opt->value.len);
> -    /*
> -     * Current implementation performs check if
> -     * option_number > previous option_number and produces an error
> -     * TODO(alashkin): write design doc with limitations
> -     * May be resorting is more suitable solution.
> -     */
> -    if ((opt->next != NULL && opt->number > opt->next->number) ||
> -        opt->value.len > 0xFFFF + 269 ||
> -        opt->number - prev_opt_number > 0xFFFF + 269) {
> -      return MG_COAP_ERROR | MG_COAP_OPTIOMG_FIELD;
> -    }
> -    *len += opt->value.len;
> -    prev_opt_number = opt->number;
> -    opt = opt->next;
> -  }
> -
> -  return 0;
> -}
> +struct mg_fs mg_fs_posix = {p_stat, p_list,  p_open, p_close,
> +                            p_read, p_write, p_seek};
>   
> -uint32_t mg_coap_compose(struct mg_coap_message *cm, struct mbuf *io) {
> -  struct mg_coap_option *opt;
> -  uint32_t res, prev_opt_number;
> -  size_t prev_io_len, packet_size;
> -  char *ptr;
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/http.c"
> +#endif
>   
> -  res = coap_calculate_packet_size(cm, &packet_size);
> -  if (res != 0) {
> -    return res;
> -  }
>   
> -  /* saving previous lenght to handle non-empty mbuf */
> -  prev_io_len = io->len;
> -  if (mbuf_append(io, NULL, packet_size) == 0) return MG_COAP_ERROR;
> -  ptr = io->buf + prev_io_len;
>   
> -  /*
> -   * since cm is verified, it is possible to use bits shift operator
> -   * without additional zeroing of unused bits
> -   */
>   
> -  /* ver: 2 bits, msg_type: 2 bits, toklen: 4 bits */
> -  *ptr = (1 << 6) | (cm->msg_type << 4) | (uint8_t)(cm->token.len);
> -  ptr++;
>   
> -  /* code class: 3 bits, code detail: 5 bits */
> -  *ptr = (cm->code_class << 5) | (cm->code_detail);
> -  ptr++;
>   
> -  ptr = coap_add_uint16(ptr, cm->msg_id);
>   
> -  if (cm->token.len != 0) {
> -    memcpy(ptr, cm->token.p, cm->token.len);
> -    ptr += cm->token.len;
> -  }
>   
> -  opt = cm->options;
> -  prev_opt_number = 0;
> -  while (opt != NULL) {
> -    uint8_t delta_base = 0, length_base = 0;
> -    uint16_t delta_ext = 0, length_ext = 0;
>   
> -    size_t opt_delta_len =
> -        coap_split_opt(opt->number - prev_opt_number, &delta_base, &delta_ext);
> -    size_t opt_lenght_len =
> -        coap_split_opt((uint32_t) opt->value.len, &length_base, &length_ext);
>   
> -    *ptr = (delta_base << 4) | length_base;
> -    ptr++;
>   
> -    ptr = coap_add_opt_info(ptr, delta_ext, opt_delta_len);
> -    ptr = coap_add_opt_info(ptr, length_ext, opt_lenght_len);
> +// Multipart POST example:
> +// --xyz
> +// Content-Disposition: form-data; name="val"
> +//
> +// abcdef
> +// --xyz
> +// Content-Disposition: form-data; name="foo"; filename="a.txt"
> +// Content-Type: text/plain
> +//
> +// hello world
> +//
> +// --xyz--
> +size_t mg_http_next_multipart(struct mg_str body, size_t ofs,
> +                              struct mg_http_part *part) {
> +  struct mg_str cd = mg_str_n("Content-Disposition", 19);
> +  const char *s = body.ptr;
> +  size_t b = ofs, h1, h2, b1, b2, max = body.len;
>   
> -    if (opt->value.len != 0) {
> -      memcpy(ptr, opt->value.p, opt->value.len);
> -      ptr += opt->value.len;
> -    }
> +  // Init part params
> +  if (part != NULL) part->name = part->filename = part->body = mg_str_n(0, 0);
>   
> -    prev_opt_number = opt->number;
> -    opt = opt->next;
> -  }
> +  // Skip boundary
> +  while (b + 2 < max && s[b] != '\r' && s[b + 1] != '\n') b++;
> +  if (b <= ofs || b + 2 >= max) return 0;
> +  // LOG(LL_INFO, ("B: %zu %zu [%.*s]", ofs, b - ofs, (int) (b - ofs), s));
>   
> -  if (cm->payload.len != 0) {
> -    *ptr = (char) -1;
> -    ptr++;
> -    memcpy(ptr, cm->payload.p, cm->payload.len);
> +  // Skip headers
> +  h1 = h2 = b + 2;
> +  for (;;) {
> +    while (h2 + 2 < max && s[h2] != '\r' && s[h2 + 1] != '\n') h2++;
> +    if (h2 == h1) break;
> +    if (h2 + 2 >= max) return 0;
> +    // LOG(LL_INFO, ("Header: [%.*s]", (int) (h2 - h1), &s[h1]));
> +    if (part != NULL && h1 + cd.len + 2 < h2 && s[h1 + cd.len] == ':' &&
> +        mg_ncasecmp(&s[h1], cd.ptr, cd.len) == 0) {
> +      struct mg_str v = mg_str_n(&s[h1 + cd.len + 2], h2 - (h1 + cd.len + 2));
> +      part->name = mg_http_get_header_var(v, mg_str_n("name", 4));
> +      part->filename = mg_http_get_header_var(v, mg_str_n("filename", 8));
> +    }
> +    h1 = h2 = h2 + 2;
>     }
> +  b1 = b2 = h2 + 2;
> +  while (b2 + 2 + (b - ofs) + 2 < max && !(s[b2] == '\r' && s[b2 + 1] == '\n' &&
> +                                           memcmp(&s[b2 + 2], s, b - ofs) == 0))
> +    b2++;
>   
> -  return 0;
> +  if (b2 + 2 >= max) return 0;
> +  if (part != NULL) part->body = mg_str_n(&s[b1], b2 - b1);
> +  // LOG(LL_INFO, ("Body: [%.*s]", (int) (b2 - b1), &s[b1]));
> +  return b2 + 2;
>   }
>   
> -uint32_t mg_coap_send_message(struct mg_connection *nc,
> -                              struct mg_coap_message *cm) {
> -  struct mbuf packet_out;
> -  uint32_t compose_res;
> -
> -  mbuf_init(&packet_out, 0);
> -  compose_res = mg_coap_compose(cm, &packet_out);
> -  if (compose_res != 0) {
> -    return compose_res; /* LCOV_EXCL_LINE */
> +void mg_http_bauth(struct mg_connection *c, const char *user,
> +                   const char *pass) {
> +  struct mg_str u = mg_str(user), p = mg_str(pass);
> +  size_t need = c->send.len + 36 + (u.len + p.len) * 2;
> +  if (c->send.size < need) mg_iobuf_resize(&c->send, need);
> +  if (c->send.size >= need) {
> +    int i, n = 0;
> +    char *buf = (char *) &c->send.buf[c->send.len + 21];
> +    memcpy(&buf[-21], "Authorization: Basic ", 21);  // DON'T use mg_send!
> +    for (i = 0; i < (int) u.len; i++) {
> +      n = mg_base64_update(((unsigned char *) u.ptr)[i], buf, n);
> +    }
> +    if (p.len > 0) {
> +      n = mg_base64_update(':', buf, n);
> +      for (i = 0; i < (int) p.len; i++) {
> +        n = mg_base64_update(((unsigned char *) p.ptr)[i], buf, n);
> +      }
> +    }
> +    n = mg_base64_final(buf, n);
> +    c->send.len += 21 + (size_t) n + 2;
> +    memcpy(&c->send.buf[c->send.len - 2], "\r\n", 2);
> +  } else {
> +    LOG(LL_ERROR, ("%lu %s cannot resize iobuf %d->%d ", c->id, c->label,
> +                   (int) c->send.size, (int) need));
>     }
> -
> -  mg_send(nc, packet_out.buf, (int) packet_out.len);
> -  mbuf_free(&packet_out);
> -
> -  return 0;
>   }
>   
> -uint32_t mg_coap_send_ack(struct mg_connection *nc, uint16_t msg_id) {
> -  struct mg_coap_message cm;
> -  memset(&cm, 0, sizeof(cm));
> -  cm.msg_type = MG_COAP_MSG_ACK;
> -  cm.msg_id = msg_id;
> +int mg_http_get_var(const struct mg_str *buf, const char *name, char *dst,
> +                    size_t dst_len) {
> +  const char *p, *e, *s;
> +  size_t name_len;
> +  int len;
>   
> -  return mg_coap_send_message(nc, &cm);
> +  if (dst == NULL || dst_len == 0) {
> +    len = -2;  // Bad destination
> +  } else if (buf->ptr == NULL || name == NULL || buf->len == 0) {
> +    len = -1;  // Bad source
> +    dst[0] = '\0';
> +  } else {
> +    name_len = strlen(name);
> +    e = buf->ptr + buf->len;
> +    len = -4;  // Name does not exist
> +    dst[0] = '\0';
> +    for (p = buf->ptr; p + name_len < e; p++) {
> +      if ((p == buf->ptr || p[-1] == '&') && p[name_len] == '=' &&
> +          !mg_ncasecmp(name, p, name_len)) {
> +        p += name_len + 1;
> +        s = (const char *) memchr(p, '&', (size_t) (e - p));
> +        if (s == NULL) s = e;
> +        len = mg_url_decode(p, (size_t) (s - p), dst, dst_len, 1);
> +        if (len < 0) len = -3;  // Failed to decode
> +        break;
> +      }
> +    }
> +  }
> +  return len;
>   }
>   
> -static void coap_handler(struct mg_connection *nc, int ev,
> -                         void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct mbuf *io = &nc->recv_mbuf;
> -  struct mg_coap_message cm;
> -  uint32_t parse_res;
> -
> -  memset(&cm, 0, sizeof(cm));
> -
> -  nc->handler(nc, ev, ev_data MG_UD_ARG(user_data));
> -
> -  switch (ev) {
> -    case MG_EV_RECV:
> -      parse_res = mg_coap_parse(io, &cm);
> -      if ((parse_res & MG_COAP_IGNORE) == 0) {
> -        if ((cm.flags & MG_COAP_NOT_ENOUGH_DATA) != 0) {
> -          /*
> -           * Since we support UDP only
> -           * MG_COAP_NOT_ENOUGH_DATA == MG_COAP_FORMAT_ERROR
> -           */
> -          cm.flags |= MG_COAP_FORMAT_ERROR; /* LCOV_EXCL_LINE */
> -        }                                   /* LCOV_EXCL_LINE */
> -        nc->handler(nc, MG_COAP_EVENT_BASE + cm.msg_type,
> -                    &cm MG_UD_ARG(user_data));
> +int mg_url_decode(const char *src, size_t src_len, char *dst, size_t dst_len,
> +                  int is_form_url_encoded) {
> +  size_t i, j;
> +  for (i = j = 0; i < src_len && j + 1 < dst_len; i++, j++) {
> +    if (src[i] == '%') {
> +      // Use `i + 2 < src_len`, not `i < src_len - 2`, note small src_len
> +      if (i + 2 < src_len && isxdigit(*(const unsigned char *) (src + i + 1)) &&
> +          isxdigit(*(const unsigned char *) (src + i + 2))) {
> +        mg_unhex(src + i + 1, 2, (uint8_t *) &dst[j]);
> +        i += 2;
> +      } else {
> +        return -1;
>         }
> -
> -      mg_coap_free_options(&cm);
> -      mbuf_remove(io, io->len);
> -      break;
> +    } else if (is_form_url_encoded && src[i] == '+') {
> +      dst[j] = ' ';
> +    } else {
> +      dst[j] = src[i];
> +    }
>     }
> +  if (j < dst_len) dst[j] = '\0';  // Null-terminate the destination
> +  return i >= src_len && j < dst_len ? (int) j : -1;
>   }
> -/*
> - * Attach built-in CoAP event handler to the given connection.
> - *
> - * The user-defined event handler will receive following extra events:
> - *
> - * - MG_EV_COAP_CON
> - * - MG_EV_COAP_NOC
> - * - MG_EV_COAP_ACK
> - * - MG_EV_COAP_RST
> - */
> -int mg_set_protocol_coap(struct mg_connection *nc) {
> -  /* supports UDP only */
> -  if ((nc->flags & MG_F_UDP) == 0) {
> -    return -1;
> -  }
> -
> -  nc->proto_handler = coap_handler;
>   
> +int mg_http_get_request_len(const unsigned char *buf, size_t buf_len) {
> +  size_t i;
> +  for (i = 0; i < buf_len; i++) {
> +    if (!isprint(buf[i]) && buf[i] != '\r' && buf[i] != '\n' && buf[i] < 128)
> +      return -1;
> +    if ((i > 0 && buf[i] == '\n' && buf[i - 1] == '\n') ||
> +        (i > 3 && buf[i] == '\n' && buf[i - 1] == '\r' && buf[i - 2] == '\n'))
> +      return (int) i + 1;
> +  }
>     return 0;
>   }
>   
> -#endif /* MG_ENABLE_COAP */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_sntp.c"
> -#endif
> -
> -/* Amalgamated: #include "mg_internal.h" */
> -/* Amalgamated: #include "mg_sntp.h" */
> -/* Amalgamated: #include "mg_util.h" */
> +static const char *skip(const char *s, const char *e, const char *d,
> +                        struct mg_str *v) {
> +  v->ptr = s;
> +  while (s < e && *s != '\n' && strchr(d, *s) == NULL) s++;
> +  v->len = (size_t) (s - v->ptr);
> +  while (s < e && strchr(d, *s) != NULL) s++;
> +  return s;
> +}
>   
> -#if MG_ENABLE_SNTP
> +struct mg_str *mg_http_get_header(struct mg_http_message *h, const char *name) {
> +  size_t i, n = strlen(name), max = sizeof(h->headers) / sizeof(h->headers[0]);
> +  for (i = 0; i < max && h->headers[i].name.len > 0; i++) {
> +    struct mg_str *k = &h->headers[i].name, *v = &h->headers[i].value;
> +    if (n == k->len && mg_ncasecmp(k->ptr, name, n) == 0) return v;
> +  }
> +  return NULL;
> +}
>   
> -#define SNTP_TIME_OFFSET 2208988800
> +void mg_http_parse_headers(const char *s, const char *end,
> +                           struct mg_http_header *h, int max_headers) {
> +  int i;
> +  for (i = 0; i < max_headers; i++) {
> +    struct mg_str k, v, tmp;
> +    const char *he = skip(s, end, "\n", &tmp);
> +    s = skip(s, he, ": \r\n", &k);
> +    s = skip(s, he, "\r\n", &v);
> +    if (k.len == tmp.len) continue;
> +    while (v.len > 0 && v.ptr[v.len - 1] == ' ') v.len--;  // Trim spaces
> +    if (k.len == 0) break;
> +    // LOG(LL_INFO, ("--HH [%.*s] [%.*s] [%.*s]", (int) tmp.len - 1, tmp.ptr,
> +    //(int) k.len, k.ptr, (int) v.len, v.ptr));
> +    h[i].name = k;
> +    h[i].value = v;
> +  }
> +}
> +
> +int mg_http_parse(const char *s, size_t len, struct mg_http_message *hm) {
> +  int is_response, req_len = mg_http_get_request_len((unsigned char *) s, len);
> +  const char *end = s + req_len, *qs;
> +  struct mg_str *cl;
>   
> -#ifndef SNTP_TIMEOUT
> -#define SNTP_TIMEOUT 10
> -#endif
> +  memset(hm, 0, sizeof(*hm));
> +  if (req_len <= 0) return req_len;
> +
> +  hm->message.ptr = hm->head.ptr = s;
> +  hm->body.ptr = end;
> +  hm->head.len = (size_t) req_len;
> +  hm->chunk.ptr = end;
> +  hm->message.len = hm->body.len = (size_t) ~0;  // Set body length to infinite
> +
> +  // Parse request line
> +  s = skip(s, end, " ", &hm->method);
> +  s = skip(s, end, " ", &hm->uri);
> +  s = skip(s, end, "\r\n", &hm->proto);
> +
> +  // Sanity check. Allow protocol/reason to be empty
> +  if (hm->method.len == 0 || hm->uri.len == 0) return -1;
> +
> +  // If URI contains '?' character, setup query string
> +  if ((qs = (const char *) memchr(hm->uri.ptr, '?', hm->uri.len)) != NULL) {
> +    hm->query.ptr = qs + 1;
> +    hm->query.len = (size_t) (&hm->uri.ptr[hm->uri.len] - (qs + 1));
> +    hm->uri.len = (size_t) (qs - hm->uri.ptr);
> +  }
> +
> +  mg_http_parse_headers(s, end, hm->headers,
> +                        sizeof(hm->headers) / sizeof(hm->headers[0]));
> +  if ((cl = mg_http_get_header(hm, "Content-Length")) != NULL) {
> +    hm->body.len = (size_t) mg_to64(*cl);
> +    hm->message.len = (size_t) req_len + hm->body.len;
> +  }
> +
> +  // mg_http_parse() is used to parse both HTTP requests and HTTP
> +  // responses. If HTTP response does not have Content-Length set, then
> +  // body is read until socket is closed, i.e. body.len is infinite (~0).
> +  //
> +  // For HTTP requests though, according to
> +  // http://tools.ietf.org/html/rfc7231#section-8.1.3,
> +  // only POST and PUT methods have defined body semantics.
> +  // Therefore, if Content-Length is not specified and methods are
> +  // not one of PUT or POST, set body length to 0.
> +  //
> +  // So, if it is HTTP request, and Content-Length is not set,
> +  // and method is not (PUT or POST) then reset body length to zero.
> +  is_response = mg_ncasecmp(hm->method.ptr, "HTTP/", 5) == 0;
> +  if (hm->body.len == (size_t) ~0 && !is_response &&
> +      mg_vcasecmp(&hm->method, "PUT") != 0 &&
> +      mg_vcasecmp(&hm->method, "POST") != 0) {
> +    hm->body.len = 0;
> +    hm->message.len = (size_t) req_len;
> +  }
>   
> -#ifndef SNTP_ATTEMPTS
> -#define SNTP_ATTEMPTS 3
> -#endif
> +  // The 204 (No content) responses also have 0 body length
> +  if (hm->body.len == (size_t) ~0 && is_response &&
> +      mg_vcasecmp(&hm->uri, "204") == 0) {
> +    hm->body.len = 0;
> +    hm->message.len = (size_t) req_len;
> +  }
>   
> -static uint64_t mg_get_sec(uint64_t val) {
> -  return (val & 0xFFFFFFFF00000000) >> 32;
> +  return req_len;
>   }
>   
> -static uint64_t mg_get_usec(uint64_t val) {
> -  uint64_t tmp = (val & 0x00000000FFFFFFFF);
> -  tmp *= 1000000;
> -  tmp >>= 32;
> -  return tmp;
> +static void mg_http_vprintf_chunk(struct mg_connection *c, const char *fmt,
> +                                  va_list ap) {
> +  char mem[256], *buf = mem;
> +  int len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  mg_printf(c, "%X\r\n", len);
> +  mg_send(c, buf, len > 0 ? (size_t) len : 0);
> +  mg_send(c, "\r\n", 2);
> +  if (buf != mem) free(buf);
>   }
>   
> -static void mg_ntp_to_tv(uint64_t val, struct timeval *tv) {
> -  uint64_t tmp;
> -  tmp = mg_get_sec(val);
> -  tmp -= SNTP_TIME_OFFSET;
> -  tv->tv_sec = tmp;
> -  tv->tv_usec = mg_get_usec(val);
> +void mg_http_printf_chunk(struct mg_connection *c, const char *fmt, ...) {
> +  va_list ap;
> +  va_start(ap, fmt);
> +  mg_http_vprintf_chunk(c, fmt, ap);
> +  va_end(ap);
>   }
>   
> -static void mg_get_ntp_ts(const char *ntp, uint64_t *val) {
> -  uint32_t tmp;
> -  memcpy(&tmp, ntp, sizeof(tmp));
> -  tmp = ntohl(tmp);
> -  *val = (uint64_t) tmp << 32;
> -  memcpy(&tmp, ntp + 4, sizeof(tmp));
> -  tmp = ntohl(tmp);
> -  *val |= tmp;
> +void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len) {
> +  mg_printf(c, "%lX\r\n", (unsigned long) len);
> +  mg_send(c, buf, len);
> +  mg_send(c, "\r\n", 2);
>   }
>   
> -void mg_sntp_send_request(struct mg_connection *c) {
> -  uint8_t buf[48] = {0};
> -  /*
> -   * header - 8 bit:
> -   * LI (2 bit) - 3 (not in sync), VN (3 bit) - 4 (version),
> -   * mode (3 bit) - 3 (client)
> -   */
> -  buf[0] = (3 << 6) | (4 << 3) | 3;
> -
> -/*
> - * Next fields should be empty in client request
> - * stratum, 8 bit
> - * poll interval, 8 bit
> - * rrecision, 8 bit
> - * root delay, 32 bit
> - * root dispersion, 32 bit
> - * ref id, 32 bit
> - * ref timestamp, 64 bit
> - * originate Timestamp, 64 bit
> - * receive Timestamp, 64 bit
> -*/
> -
> -/*
> - * convert time to sntp format (sntp starts from 00:00:00 01.01.1900)
> - * according to rfc868 it is 2208988800L sec
> - * this information is used to correct roundtrip delay
> - * but if local clock is absolutely broken (and doesn't work even
> - * as simple timer), it is better to disable it
> -*/
> -#ifndef MG_SNTP_NO_DELAY_CORRECTION
> -  uint32_t sec;
> -  sec = htonl((uint32_t)(mg_time() + SNTP_TIME_OFFSET));
> -  memcpy(&buf[40], &sec, sizeof(sec));
> -#endif
> -
> -  mg_send(c, buf, sizeof(buf));
> +// clang-format off
> +static const char *mg_http_status_code_str(int status_code) {
> +  switch (status_code) {
> +    case 100: return "Continue";
> +    case 101: return "Switching Protocols";
> +    case 102: return "Processing";
> +    case 200: return "OK";
> +    case 201: return "Created";
> +    case 202: return "Accepted";
> +    case 203: return "Non-authoritative Information";
> +    case 204: return "No Content";
> +    case 205: return "Reset Content";
> +    case 206: return "Partial Content";
> +    case 207: return "Multi-Status";
> +    case 208: return "Already Reported";
> +    case 226: return "IM Used";
> +    case 300: return "Multiple Choices";
> +    case 301: return "Moved Permanently";
> +    case 302: return "Found";
> +    case 303: return "See Other";
> +    case 304: return "Not Modified";
> +    case 305: return "Use Proxy";
> +    case 307: return "Temporary Redirect";
> +    case 308: return "Permanent Redirect";
> +    case 400: return "Bad Request";
> +    case 401: return "Unauthorized";
> +    case 402: return "Payment Required";
> +    case 403: return "Forbidden";
> +    case 404: return "Not Found";
> +    case 405: return "Method Not Allowed";
> +    case 406: return "Not Acceptable";
> +    case 407: return "Proxy Authentication Required";
> +    case 408: return "Request Timeout";
> +    case 409: return "Conflict";
> +    case 410: return "Gone";
> +    case 411: return "Length Required";
> +    case 412: return "Precondition Failed";
> +    case 413: return "Payload Too Large";
> +    case 414: return "Request-URI Too Long";
> +    case 415: return "Unsupported Media Type";
> +    case 416: return "Requested Range Not Satisfiable";
> +    case 417: return "Expectation Failed";
> +    case 418: return "I'm a teapot";
> +    case 421: return "Misdirected Request";
> +    case 422: return "Unprocessable Entity";
> +    case 423: return "Locked";
> +    case 424: return "Failed Dependency";
> +    case 426: return "Upgrade Required";
> +    case 428: return "Precondition Required";
> +    case 429: return "Too Many Requests";
> +    case 431: return "Request Header Fields Too Large";
> +    case 444: return "Connection Closed Without Response";
> +    case 451: return "Unavailable For Legal Reasons";
> +    case 499: return "Client Closed Request";
> +    case 500: return "Internal Server Error";
> +    case 501: return "Not Implemented";
> +    case 502: return "Bad Gateway";
> +    case 503: return "Service Unavailable";
> +    case 504: return "Gateway Timeout";
> +    case 505: return "HTTP Version Not Supported";
> +    case 506: return "Variant Also Negotiates";
> +    case 507: return "Insufficient Storage";
> +    case 508: return "Loop Detected";
> +    case 510: return "Not Extended";
> +    case 511: return "Network Authentication Required";
> +    case 599: return "Network Connect Timeout Error";
> +    default: return "OK";
> +  }
> +}
> +// clang-format on
> +
> +void mg_http_reply(struct mg_connection *c, int code, const char *headers,
> +                   const char *fmt, ...) {
> +  char mem[256], *buf = mem;
> +  va_list ap;
> +  int len;
> +  va_start(ap, fmt);
> +  len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  va_end(ap);
> +  mg_printf(c, "HTTP/1.1 %d %s\r\n%sContent-Length: %d\r\n\r\n", code,
> +            mg_http_status_code_str(code), headers == NULL ? "" : headers, len);
> +  mg_send(c, buf, len > 0 ? (size_t) len : 0);
> +  if (buf != mem) free(buf);
>   }
>   
> -#ifndef MG_SNTP_NO_DELAY_CORRECTION
> -static uint64_t mg_calculate_delay(uint64_t t1, uint64_t t2, uint64_t t3) {
> -  /* roundloop delay = (T4 - T1) - (T3 - T2) */
> -  uint64_t d1 = ((mg_time() + SNTP_TIME_OFFSET) * 1000000) -
> -                (mg_get_sec(t1) * 1000000 + mg_get_usec(t1));
> -  uint64_t d2 = (mg_get_sec(t3) * 1000000 + mg_get_usec(t3)) -
> -                (mg_get_sec(t2) * 1000000 + mg_get_usec(t2));
> -
> -  return (d1 > d2) ? d1 - d2 : 0;
> +static void http_cb(struct mg_connection *, int, void *, void *);
> +static void restore_http_cb(struct mg_connection *c) {
> +  struct mg_fd *fd = (struct mg_fd *) c->pfn_data;
> +  if (fd != NULL) fd->fs->close(fd);
> +  c->pfn_data = NULL;
> +  c->pfn = http_cb;
>   }
> -#endif
> -
> -MG_INTERNAL int mg_sntp_parse_reply(const char *buf, int len,
> -                                    struct mg_sntp_message *msg) {
> -  uint8_t hdr;
> -  uint64_t trsm_ts_T3, delay = 0;
> -  int mode;
> -  struct timeval tv;
> -
> -  if (len < 48) {
> -    return -1;
> -  }
>   
> -  hdr = buf[0];
> +char *mg_http_etag(char *buf, size_t len, size_t size, time_t mtime) {
> +  snprintf(buf, len, "\"%lx." MG_INT64_FMT "\"", (unsigned long) mtime,
> +           (int64_t) size);
> +  return buf;
> +}
>   
> -  if ((hdr & 0x38) >> 3 != 4) {
> -    /* Wrong version */
> +int mg_http_upload(struct mg_connection *c, struct mg_http_message *hm,
> +                   const char *dir) {
> +  char offset[40] = "", name[200] = "", path[256];
> +  mg_http_get_var(&hm->query, "offset", offset, sizeof(offset));
> +  mg_http_get_var(&hm->query, "name", name, sizeof(name));
> +  if (name[0] == '\0') {
> +    mg_http_reply(c, 400, "", "%s", "name required");
>       return -1;
> +  } else {
> +    FILE *fp;
> +    size_t oft = strtoul(offset, NULL, 0);
> +    snprintf(path, sizeof(path), "%s%c%s", dir, MG_DIRSEP, name);
> +    LOG(LL_DEBUG,
> +        ("%p %d bytes @ %d [%s]", c->fd, (int) hm->body.len, (int) oft, name));
> +    if ((fp = fopen(path, oft == 0 ? "wb" : "ab")) == NULL) {
> +      mg_http_reply(c, 400, "", "fopen(%s): %d", name, errno);
> +      return -2;
> +    } else {
> +      fwrite(hm->body.ptr, 1, hm->body.len, fp);
> +      fclose(fp);
> +      mg_http_reply(c, 200, "", "");
> +      return (int) hm->body.len;
> +    }
>     }
> +}
>   
> -  mode = hdr & 0x7;
> -  if (mode != 4 && mode != 5) {
> -    /* Not a server reply */
> -    return -1;
> +static void static_cb(struct mg_connection *c, int ev, void *ev_data,
> +                      void *fn_data) {
> +  if (ev == MG_EV_WRITE || ev == MG_EV_POLL) {
> +    struct mg_fd *fd = (struct mg_fd *) fn_data;
> +    // Read to send IO buffer directly, avoid extra on-stack buffer
> +    size_t n, max = 2 * MG_IO_SIZE;
> +    if (c->send.size < max) mg_iobuf_resize(&c->send, max);
> +    if (c->send.len >= c->send.size) return;  // Rate limit
> +    n = fd->fs->read(fd->fd, c->send.buf + c->send.len,
> +                     c->send.size - c->send.len);
> +    if (n > 0) c->send.len += n;
> +    if (c->send.len < c->send.size) restore_http_cb(c);
> +  } else if (ev == MG_EV_CLOSE) {
> +    restore_http_cb(c);
>     }
> +  (void) ev_data;
> +}
>   
> -  memset(msg, 0, sizeof(*msg));
> -
> -  msg->kiss_of_death = (buf[1] == 0); /* Server asks to not send requests */
> +static struct mg_str guess_content_type(struct mg_str path, const char *extra) {
> +  // clang-format off
> +  struct mimeentry { struct mg_str extension, value; };
> +  #define MIME_ENTRY(a, b) {{a, sizeof(a) - 1 }, { b, sizeof(b) - 1 }}
> +  // clang-format on
> +  const struct mimeentry tab[] = {
> +      MIME_ENTRY("html", "text/html; charset=utf-8"),
> +      MIME_ENTRY("htm", "text/html; charset=utf-8"),
> +      MIME_ENTRY("css", "text/css; charset=utf-8"),
> +      MIME_ENTRY("js", "text/javascript; charset=utf-8"),
> +      MIME_ENTRY("gif", "image/gif"),
> +      MIME_ENTRY("png", "image/png"),
> +      MIME_ENTRY("woff", "font/woff"),
> +      MIME_ENTRY("ttf", "font/ttf"),
> +      MIME_ENTRY("aac", "audio/aac"),
> +      MIME_ENTRY("avi", "video/x-msvideo"),
> +      MIME_ENTRY("azw", "application/vnd.amazon.ebook"),
> +      MIME_ENTRY("bin", "application/octet-stream"),
> +      MIME_ENTRY("bmp", "image/bmp"),
> +      MIME_ENTRY("bz", "application/x-bzip"),
> +      MIME_ENTRY("bz2", "application/x-bzip2"),
> +      MIME_ENTRY("csv", "text/csv"),
> +      MIME_ENTRY("doc", "application/msword"),
> +      MIME_ENTRY("epub", "application/epub+zip"),
> +      MIME_ENTRY("exe", "application/octet-stream"),
> +      MIME_ENTRY("gz", "application/gzip"),
> +      MIME_ENTRY("ico", "image/x-icon"),
> +      MIME_ENTRY("json", "application/json"),
> +      MIME_ENTRY("mid", "audio/mid"),
> +      MIME_ENTRY("mjs", "text/javascript"),
> +      MIME_ENTRY("mov", "video/quicktime"),
> +      MIME_ENTRY("mp3", "audio/mpeg"),
> +      MIME_ENTRY("mp4", "video/mp4"),
> +      MIME_ENTRY("mpeg", "video/mpeg"),
> +      MIME_ENTRY("mpg", "video/mpeg"),
> +      MIME_ENTRY("ogg", "application/ogg"),
> +      MIME_ENTRY("pdf", "application/pdf"),
> +      MIME_ENTRY("rar", "application/rar"),
> +      MIME_ENTRY("rtf", "application/rtf"),
> +      MIME_ENTRY("shtml", "text/html; charset=utf-8"),
> +      MIME_ENTRY("svg", "image/svg+xml"),
> +      MIME_ENTRY("tar", "application/tar"),
> +      MIME_ENTRY("tgz", "application/tar-gz"),
> +      MIME_ENTRY("txt", "text/plain; charset=utf-8"),
> +      MIME_ENTRY("wasm", "application/wasm"),
> +      MIME_ENTRY("wav", "audio/wav"),
> +      MIME_ENTRY("weba", "audio/webm"),
> +      MIME_ENTRY("webm", "video/webm"),
> +      MIME_ENTRY("webp", "image/webp"),
> +      MIME_ENTRY("xls", "application/excel"),
> +      MIME_ENTRY("xml", "application/xml"),
> +      MIME_ENTRY("xsl", "application/xml"),
> +      MIME_ENTRY("zip", "application/zip"),
> +      MIME_ENTRY("3gp", "video/3gpp"),
> +      MIME_ENTRY("7z", "application/x-7z-compressed"),
> +      MIME_ENTRY("7z", "application/x-7z-compressed"),
> +      {{0, 0}, {0, 0}},
> +  };
> +  size_t i = 0;
> +  struct mg_str k, v, s = mg_str(extra);
>   
> -  mg_get_ntp_ts(&buf[40], &trsm_ts_T3);
> +  // Shrink path to its extension only
> +  while (i < path.len && path.ptr[path.len - i - 1] != '.') i++;
> +  path.ptr += path.len - i;
> +  path.len = i;
>   
> -#ifndef MG_SNTP_NO_DELAY_CORRECTION
> -  {
> -    uint64_t orig_ts_T1, recv_ts_T2;
> -    mg_get_ntp_ts(&buf[24], &orig_ts_T1);
> -    mg_get_ntp_ts(&buf[32], &recv_ts_T2);
> -    delay = mg_calculate_delay(orig_ts_T1, recv_ts_T2, trsm_ts_T3);
> +  // Process user-provided mime type overrides, if any
> +  while (mg_commalist(&s, &k, &v)) {
> +    if (mg_strcmp(path, k) == 0) return v;
>     }
> -#endif
>   
> -  mg_ntp_to_tv(trsm_ts_T3, &tv);
> -
> -  msg->time = (double) tv.tv_sec + (((double) tv.tv_usec + delay) / 1000000.0);
> +  // Process built-in mime types
> +  for (i = 0; tab[i].extension.ptr != NULL; i++) {
> +    if (mg_strcmp(path, tab[i].extension) == 0) return tab[i].value;
> +  }
>   
> -  return 0;
> +  return mg_str("text/plain; charset=utf-8");
>   }
>   
> -static void mg_sntp_handler(struct mg_connection *c, int ev,
> -                            void *ev_data MG_UD_ARG(void *user_data)) {
> -  struct mbuf *io = &c->recv_mbuf;
> -  struct mg_sntp_message msg;
> -
> -  c->handler(c, ev, ev_data MG_UD_ARG(user_data));
> -
> -  switch (ev) {
> -    case MG_EV_RECV: {
> -      if (mg_sntp_parse_reply(io->buf, io->len, &msg) < 0) {
> -        DBG(("Invalid SNTP packet received (%d)", (int) io->len));
> -        c->handler(c, MG_SNTP_MALFORMED_REPLY, NULL MG_UD_ARG(user_data));
> +static int getrange(struct mg_str *s, int64_t *a, int64_t *b) {
> +  size_t i, numparsed = 0;
> +  LOG(LL_INFO, ("%.*s", (int) s->len, s->ptr));
> +  for (i = 0; i + 6 < s->len; i++) {
> +    if (memcmp(&s->ptr[i], "bytes=", 6) == 0) {
> +      struct mg_str p = mg_str_n(s->ptr + i + 6, s->len - i - 6);
> +      if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++;
> +      *a = mg_to64(p);
> +      // LOG(LL_INFO, ("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed));
> +      while (p.len && p.ptr[0] >= '0' && p.ptr[0] <= '9') p.ptr++, p.len--;
> +      if (p.len && p.ptr[0] == '-') p.ptr++, p.len--;
> +      *b = mg_to64(p);
> +      if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++;
> +      // LOG(LL_INFO, ("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed));
> +      break;
> +    }
> +  }
> +  return (int) numparsed;
> +}
> +
> +void mg_http_serve_file(struct mg_connection *c, struct mg_http_message *hm,
> +                        const char *path, struct mg_http_serve_opts *opts) {
> +  char etag[64];
> +  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
> +  struct mg_fd *fd = fs->open(path, MG_FS_READ);
> +  size_t size = 0;
> +  time_t mtime = 0;
> +  struct mg_str *inm = NULL;
> +
> +  if (fd == NULL || fs->stat(path, &size, &mtime) == 0) {
> +    LOG(LL_DEBUG, ("404 [%s] %p", path, (void *) fd));
> +    mg_http_reply(c, 404, "", "%s", "Not found\n");
> +    fs->close(fd);
> +    // NOTE: mg_http_etag() call should go first!
> +  } else if (mg_http_etag(etag, sizeof(etag), size, mtime) != NULL &&
> +             (inm = mg_http_get_header(hm, "If-None-Match")) != NULL &&
> +             mg_vcasecmp(inm, etag) == 0) {
> +    fs->close(fd);
> +    mg_printf(c, "HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\n\r\n");
> +  } else {
> +    int n, status = 200;
> +    char range[100] = "";
> +    int64_t r1 = 0, r2 = 0, cl = (int64_t) size;
> +    struct mg_str mime = guess_content_type(mg_str(path), opts->mime_types);
> +
> +    // Handle Range header
> +    struct mg_str *rh = mg_http_get_header(hm, "Range");
> +    if (rh != NULL && (n = getrange(rh, &r1, &r2)) > 0 && r1 >= 0 && r2 >= 0) {
> +      // If range is specified like "400-", set second limit to content len
> +      if (n == 1) r2 = cl - 1;
> +      if (r1 > r2 || r2 >= cl) {
> +        status = 416;
> +        cl = 0;
> +        snprintf(range, sizeof(range),
> +                 "Content-Range: bytes */" MG_INT64_FMT "\r\n", (int64_t) size);
>         } else {
> -        c->handler(c, MG_SNTP_REPLY, (void *) &msg MG_UD_ARG(user_data));
> +        status = 206;
> +        cl = r2 - r1 + 1;
> +        snprintf(range, sizeof(range),
> +                 "Content-Range: bytes " MG_INT64_FMT "-" MG_INT64_FMT
> +                 "/" MG_INT64_FMT "\r\n",
> +                 r1, r1 + cl - 1, (int64_t) size);
> +        fs->seek(fd->fd, (size_t) r1);
>         }
> +    }
>   
> -      mbuf_remove(io, io->len);
> -      break;
> +    mg_printf(c,
> +              "HTTP/1.1 %d %s\r\nContent-Type: %.*s\r\n"
> +              "Etag: %s\r\nContent-Length: " MG_INT64_FMT "\r\n%s%s\r\n",
> +              status, mg_http_status_code_str(status), (int) mime.len, mime.ptr,
> +              etag, cl, range, opts->extra_headers ? opts->extra_headers : "");
> +    if (mg_vcasecmp(&hm->method, "HEAD") == 0) {
> +      c->is_draining = 1;
> +      fs->close(fd);
> +    } else {
> +      c->pfn = static_cb;
> +      c->pfn_data = fd;
>       }
>     }
>   }
>   
> -int mg_set_protocol_sntp(struct mg_connection *c) {
> -  if ((c->flags & MG_F_UDP) == 0) {
> -    return -1;
> -  }
> -
> -  c->proto_handler = mg_sntp_handler;
> +struct printdirentrydata {
> +  struct mg_connection *c;
> +  struct mg_http_message *hm;
> +  struct mg_http_serve_opts *opts;
> +  const char *dir;
> +};
>   
> -  return 0;
> +static void printdirentry(const char *name, void *userdata) {
> +  struct printdirentrydata *d = (struct printdirentrydata *) userdata;
> +  struct mg_fs *fs = d->opts->fs == NULL ? &mg_fs_posix : d->opts->fs;
> +  size_t size = 0;
> +  time_t mtime = 0;
> +  char path[MG_PATH_MAX], sz[64], mod[64];
> +  int flags, n = 0;
> +
> +  // LOG(LL_DEBUG, ("[%s] [%s]", d->dir, name));
> +  if (snprintf(path, sizeof(path), "%s%c%s", d->dir, '/', name) < 0) {
> +    LOG(LL_ERROR, ("%s truncated", name));
> +  } else if ((flags = fs->stat(path, &size, &mtime)) == 0) {
> +    LOG(LL_ERROR, ("%lu stat(%s): %d", d->c->id, path, errno));
> +  } else {
> +    const char *slash = flags & MG_FS_DIR ? "/" : "";
> +    struct tm t;
> +    if (flags & MG_FS_DIR) {
> +      snprintf(sz, sizeof(sz), "%s", "[DIR]");
> +    } else if (size < 1024) {
> +      snprintf(sz, sizeof(sz), "%d", (int) size);
> +    } else if (size < 0x100000) {
> +      snprintf(sz, sizeof(sz), "%.1fk", (double) size / 1024.0);
> +    } else if (size < 0x40000000) {
> +      snprintf(sz, sizeof(sz), "%.1fM", (double) size / 1048576);
> +    } else {
> +      snprintf(sz, sizeof(sz), "%.1fG", (double) size / 1073741824);
> +    }
> +    strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime_r(&mtime, &t));
> +    n = (int) mg_url_encode(name, strlen(name), path, sizeof(path));
> +    mg_printf(d->c,
> +              "  <tr><td><a href=\"%.*s%s\">%s%s</a></td>"
> +              "<td>%s</td><td>%s</td></tr>\n",
> +              n, path, slash, name, slash, mod, sz);
> +  }
>   }
>   
> -struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr,
> -                                      MG_CB(mg_event_handler_t event_handler,
> -                                            void *user_data),
> -                                      const char *sntp_server_name) {
> -  struct mg_connection *c = NULL;
> -  char url[100], *p_url = url;
> -  const char *proto = "", *port = "", *tmp;
> +static void listdir(struct mg_connection *c, struct mg_http_message *hm,
> +                    struct mg_http_serve_opts *opts, char *dir) {
> +  static const char *sort_js_code =
> +      "<script>function srt(tb, sc, so, d) {"
> +      "var tr = Array.prototype.slice.call(tb.rows, 0),"
> +      "tr = tr.sort(function (a, b) { var c1 = a.cells[sc], c2 = b.cells[sc],"
> +      "n1 = c1.getAttribute('name'), n2 = c2.getAttribute('name'), "
> +      "t1 = a.cells[2].getAttribute('name'), "
> +      "t2 = b.cells[2].getAttribute('name'); "
> +      "return so * (t1 < 0 && t2 >= 0 ? -1 : t2 < 0 && t1 >= 0 ? 1 : "
> +      "n1 ? parseInt(n2) - parseInt(n1) : "
> +      "c1.textContent.trim().localeCompare(c2.textContent.trim())); });";
> +  static const char *sort_js_code2 =
> +      "for (var i = 0; i < tr.length; i++) tb.appendChild(tr[i]); "
> +      "if (!d) window.location.hash = ('sc=' + sc + '&so=' + so); "
> +      "};"
> +      "window.onload = function() {"
> +      "var tb = document.getElementById('tb');"
> +      "var m = /sc=([012]).so=(1|-1)/.exec(window.location.hash) || [0, 2, 1];"
> +      "var sc = m[1], so = m[2]; document.onclick = function(ev) { "
> +      "var c = ev.target.rel; if (c) {if (c == sc) so *= -1; srt(tb, c, so); "
> +      "sc = c; ev.preventDefault();}};"
> +      "srt(tb, sc, so, true);"
> +      "}"
> +      "</script>";
> +  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
> +  struct printdirentrydata d = {c, hm, opts, dir};
> +  char tmp[10];
> +  size_t off, n;
>   
> -  /* If port is not specified, use default (123) */
> -  tmp = strchr(sntp_server_name, ':');
> -  if (tmp != NULL && *(tmp + 1) == '/') {
> -    tmp = strchr(tmp + 1, ':');
> +  mg_printf(c,
> +            "HTTP/1.1 200 OK\r\n"
> +            "Content-Type: text/html; charset=utf-8\r\n"
> +            "%s"
> +            "Content-Length:         \r\n\r\n",
> +            opts->extra_headers == NULL ? "" : opts->extra_headers);
> +  off = c->send.len;  // Start of body
> +  mg_printf(c,
> +            "<!DOCTYPE html><html><head><title>Index of %.*s</title>%s%s"
> +            "<style>th,td {text-align: left; padding-right: 1em; "
> +            "font-family: monospace; }</style></head>"
> +            "<body><h1>Index of %.*s</h1><table cellpadding=\"0\"><thead>"
> +            "<tr><th><a href=\"#\" rel=\"0\">Name</a></th><th>"
> +            "<a href=\"#\" rel=\"1\">Modified</a></th>"
> +            "<th><a href=\"#\" rel=\"2\">Size</a></th></tr>"
> +            "<tr><td colspan=\"3\"><hr></td></tr>"
> +            "</thead>"
> +            "<tbody id=\"tb\">\n",
> +            (int) hm->uri.len, hm->uri.ptr, sort_js_code, sort_js_code2,
> +            (int) hm->uri.len, hm->uri.ptr);
> +
> +  fs->list(dir, printdirentry, &d);
> +  mg_printf(c,
> +            "</tbody><tfoot><tr><td colspan=\"3\"><hr></td></tr></tfoot>"
> +            "</table><address>Mongoose v.%s</address></body></html>\n",
> +            MG_VERSION);
> +  n = (size_t) snprintf(tmp, sizeof(tmp), "%lu",
> +                        (unsigned long) (c->send.len - off));
> +  if (n > sizeof(tmp)) n = 0;
> +  memcpy(c->send.buf + off - 10, tmp, n);  // Set content length
> +}
> +
> +static void remove_double_dots(char *s) {
> +  char *p = s;
> +  while (*s != '\0') {
> +    *p++ = *s++;
> +    if (s[-1] == '/' || s[-1] == '\\') {
> +      while (s[0] != '\0') {
> +        if (s[0] == '/' || s[0] == '\\') {
> +          s++;
> +        } else if (s[0] == '.' && s[1] == '.') {
> +          s += 2;
> +        } else {
> +          break;
> +        }
> +      }
> +    }
>     }
> +  *p = '\0';
> +}
>   
> -  if (tmp == NULL) {
> -    port = ":123";
> +// Resolve requested file into `path` and return its fs->stat() result
> +static int uri_to_path2(struct mg_connection *c, struct mg_http_message *hm,
> +                        struct mg_fs *fs, struct mg_str url, struct mg_str dir,
> +                        char *path, size_t path_size) {
> +  int flags = 0, tmp;
> +  // Append URI to the root_dir, and sanitize it
> +  size_t n = (size_t) snprintf(path, path_size, "%.*s", (int) dir.len, dir.ptr);
> +  if (n > path_size) n = path_size;
> +  path[path_size - 1] = '\0';
> +  if ((fs->stat(path, NULL, NULL) & MG_FS_DIR) == 0) {
> +    mg_http_reply(c, 400, "", "Invalid web root [%.*s]\n", (int) dir.len,
> +                  dir.ptr);
> +  } else {
> +    if (n + 2 < path_size) path[n++] = '/', path[n] = '\0';
> +    mg_url_decode(hm->uri.ptr + url.len, hm->uri.len - url.len, path + n,
> +                  path_size - n, 0);
> +    path[path_size - 1] = '\0';  // Double-check
> +    remove_double_dots(path);
> +    n = strlen(path);
> +    LOG(LL_DEBUG, ("--> %s", path));
> +    while (n > 0 && path[n - 1] == '/') path[--n] = 0;  // Trim trailing slashes
> +    flags = fs->stat(path, NULL, NULL);                 // Does it exist?
> +    if (flags == 0) {
> +      mg_http_reply(c, 404, "", "Not found\n");  // Does not exist, doh
> +    } else if (flags & MG_FS_DIR) {
> +      if (((snprintf(path + n, path_size - n, "/index.html") > 0 &&
> +            (tmp = fs->stat(path, NULL, NULL)) != 0) ||
> +           (snprintf(path + n, path_size - n, "/index.shtml") > 0 &&
> +            (tmp = fs->stat(path, NULL, NULL)) != 0))) {
> +        flags = tmp;
> +      } else {
> +        path[n] = '\0';  // Remove appended index file name
> +      }
> +    }
>     }
> +  return flags;
> +}
>   
> -  /* Add udp:// if needed */
> -  if (strncmp(sntp_server_name, "udp://", 6) != 0) {
> -    proto = "udp://";
> +static int uri_to_path(struct mg_connection *c, struct mg_http_message *hm,
> +                       struct mg_http_serve_opts *opts, char *path,
> +                       size_t path_size) {
> +  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
> +  struct mg_str k, v, s = mg_str(opts->root_dir), u = {0, 0}, p = {0, 0};
> +  while (mg_commalist(&s, &k, &v)) {
> +    if (v.len == 0) v = k, k = mg_str("/");
> +    if (hm->uri.len < k.len) continue;
> +    if (mg_strcmp(k, mg_str_n(hm->uri.ptr, k.len)) != 0) continue;
> +    u = k, p = v;
>     }
> +  return uri_to_path2(c, hm, fs, u, p, path, path_size);
> +}
>   
> -  mg_asprintf(&p_url, sizeof(url), "%s%s%s", proto, sntp_server_name, port);
> -
> -  c = mg_connect(mgr, p_url, event_handler MG_UD_ARG(user_data));
> -
> -  if (c == NULL) {
> -    goto cleanup;
> +void mg_http_serve_dir(struct mg_connection *c, struct mg_http_message *hm,
> +                       struct mg_http_serve_opts *opts) {
> +  char path[MG_PATH_MAX] = "";
> +  const char *sp = opts->ssi_pattern;
> +  int flags = uri_to_path(c, hm, opts, path, sizeof(path));
> +  if (flags == 0) return;
> +  LOG(LL_DEBUG, ("%.*s %s %d", (int) hm->uri.len, hm->uri.ptr, path, flags));
> +  if (flags & MG_FS_DIR) {
> +    listdir(c, hm, opts, path);
> +  } else if (sp != NULL && mg_globmatch(sp, strlen(sp), path, strlen(path))) {
> +    mg_http_serve_ssi(c, opts->root_dir, path);
> +  } else {
> +    mg_http_serve_file(c, hm, path, opts);
>     }
> +}
>   
> -  mg_set_protocol_sntp(c);
> +static bool mg_is_url_safe(int c) {
> +  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
> +         (c >= 'A' && c <= 'Z') || c == '.' || c == '_' || c == '-' || c == '~';
> +}
>   
> -cleanup:
> -  if (p_url != url) {
> -    MG_FREE(p_url);
> +size_t mg_url_encode(const char *s, size_t sl, char *buf, size_t len) {
> +  size_t i, n = 0;
> +  for (i = 0; i < sl; i++) {
> +    int c = *(unsigned char *) &s[i];
> +    if (n + 4 >= len) return 0;
> +    if (mg_is_url_safe(c)) {
> +      buf[n++] = s[i];
> +    } else {
> +      buf[n++] = '%';
> +      mg_hex(&s[i], 1, &buf[n]);
> +      n += 2;
> +    }
>     }
> -
> -  return c;
> +  return n;
>   }
>   
> -struct sntp_data {
> -  mg_event_handler_t hander;
> -  int count;
> -};
> -
> -static void mg_sntp_util_ev_handler(struct mg_connection *c, int ev,
> -                                    void *ev_data MG_UD_ARG(void *user_data)) {
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -  void *user_data = c->user_data;
> -#endif
> -  struct sntp_data *sd = (struct sntp_data *) user_data;
> -
> -  switch (ev) {
> -    case MG_EV_CONNECT:
> -      if (*(int *) ev_data != 0) {
> -        mg_call(c, sd->hander, c->user_data, MG_SNTP_FAILED, NULL);
> -        break;
> -      }
> -    /* fallthrough */
> -    case MG_EV_TIMER:
> -      if (sd->count <= SNTP_ATTEMPTS) {
> -        mg_sntp_send_request(c);
> -        mg_set_timer(c, mg_time() + 10);
> -        sd->count++;
> -      } else {
> -        mg_call(c, sd->hander, c->user_data, MG_SNTP_FAILED, NULL);
> -        c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      }
> -      break;
> -    case MG_SNTP_MALFORMED_REPLY:
> -      mg_call(c, sd->hander, c->user_data, MG_SNTP_FAILED, NULL);
> -      c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      break;
> -    case MG_SNTP_REPLY:
> -      mg_call(c, sd->hander, c->user_data, MG_SNTP_REPLY, ev_data);
> -      c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      break;
> -    case MG_EV_CLOSE:
> -      MG_FREE(user_data);
> -      c->user_data = NULL;
> -      break;
> +void mg_http_creds(struct mg_http_message *hm, char *user, size_t userlen,
> +                   char *pass, size_t passlen) {
> +  struct mg_str *v = mg_http_get_header(hm, "Authorization");
> +  user[0] = pass[0] = '\0';
> +  if (v != NULL && v->len > 6 && memcmp(v->ptr, "Basic ", 6) == 0) {
> +    char buf[256];
> +    int n = mg_base64_decode(v->ptr + 6, (int) v->len - 6, buf);
> +    const char *p = (const char *) memchr(buf, ':', n > 0 ? (size_t) n : 0);
> +    if (p != NULL) {
> +      snprintf(user, userlen, "%.*s", (int) (p - buf), buf);
> +      snprintf(pass, passlen, "%.*s", n - (int) (p - buf) - 1, p + 1);
> +    }
> +  } else if (v != NULL && v->len > 7 && memcmp(v->ptr, "Bearer ", 7) == 0) {
> +    snprintf(pass, passlen, "%.*s", (int) v->len - 7, v->ptr + 7);
> +  } else if ((v = mg_http_get_header(hm, "Cookie")) != NULL) {
> +    struct mg_str t = mg_http_get_header_var(*v, mg_str_n("access_token", 12));
> +    if (t.len > 0) snprintf(pass, passlen, "%.*s", (int) t.len, t.ptr);
> +  } else {
> +    mg_http_get_var(&hm->query, "access_token", pass, passlen);
>     }
>   }
>   
> -struct mg_connection *mg_sntp_get_time(struct mg_mgr *mgr,
> -                                       mg_event_handler_t event_handler,
> -                                       const char *sntp_server_name) {
> -  struct mg_connection *c;
> -  struct sntp_data *sd = (struct sntp_data *) MG_CALLOC(1, sizeof(*sd));
> -  if (sd == NULL) {
> -    return NULL;
> -  }
> +static struct mg_str stripquotes(struct mg_str s) {
> +  return s.len > 1 && s.ptr[0] == '"' && s.ptr[s.len - 1] == '"'
> +             ? mg_str_n(s.ptr + 1, s.len - 2)
> +             : s;
> +}
>   
> -  c = mg_sntp_connect(mgr, MG_CB(mg_sntp_util_ev_handler, sd),
> -                      sntp_server_name);
> -  if (c == NULL) {
> -    MG_FREE(sd);
> -    return NULL;
> +struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v) {
> +  size_t i;
> +  for (i = 0; i + v.len + 2 < s.len; i++) {
> +    if (s.ptr[i + v.len] == '=' && memcmp(&s.ptr[i], v.ptr, v.len) == 0) {
> +      const char *p = &s.ptr[i + v.len + 1], *b = p, *x = &s.ptr[s.len];
> +      int q = p < x && *p == '"' ? 1 : 0;
> +      while (p < x && (q ? p == b || *p != '"' : *p != ';' && *p != ' ')) p++;
> +      // LOG(LL_INFO, ("[%.*s] [%.*s] [%.*s]", (int) s.len, s.ptr, (int) v.len,
> +      // v.ptr, (int) (p - b), b));
> +      return stripquotes(mg_str_n(b, (size_t) (p - b + q)));
> +    }
>     }
> -
> -  sd->hander = event_handler;
> -#if !MG_ENABLE_CALLBACK_USERDATA
> -  c->user_data = sd;
> -#endif
> -
> -  return c;
> +  return mg_str_n(NULL, 0);
>   }
>   
> -#endif /* MG_ENABLE_SNTP */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_socks.c"
> -#endif
> -
> -#if MG_ENABLE_SOCKS
> +bool mg_http_match_uri(const struct mg_http_message *hm, const char *glob) {
> +  return mg_globmatch(glob, strlen(glob), hm->uri.ptr, hm->uri.len);
> +}
>   
> -/* Amalgamated: #include "mg_socks.h" */
> -/* Amalgamated: #include "mg_internal.h" */
> +static size_t get_chunk_length(const char *buf, size_t len, size_t *ll) {
> +  size_t i = 0, n;
> +  while (i < len && buf[i] != '\r' && i != '\n') i++;
> +  n = mg_unhexn((char *) buf, i);
> +  while (i < len && (buf[i] == '\r' || i == '\n')) i++;
> +  // LOG(LL_INFO, ("len %zu i %zu n %zu ", len, i, n));
> +  if (ll != NULL) *ll = i + 1;
> +  if (i < len && i + n + 2 < len) return i + n + 3;
> +  return 0;
> +}
>   
> -/*
> - *  https://www.ietf.org/rfc/rfc1928.txt paragraph 3, handle client handshake
> - *
> - *  +----+----------+----------+
> - *  |VER | NMETHODS | METHODS  |
> - *  +----+----------+----------+
> - *  | 1  |    1     | 1 to 255 |
> - *  +----+----------+----------+
> - */
> -static void mg_socks5_handshake(struct mg_connection *c) {
> -  struct mbuf *r = &c->recv_mbuf;
> -  if (r->buf[0] != MG_SOCKS_VERSION) {
> -    c->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  } else if (r->len > 2 && (size_t) r->buf[1] + 2 <= r->len) {
> -    /* https://www.ietf.org/rfc/rfc1928.txt paragraph 3 */
> -    unsigned char reply[2] = {MG_SOCKS_VERSION, MG_SOCKS_HANDSHAKE_FAILURE};
> -    int i;
> -    for (i = 2; i < r->buf[1] + 2; i++) {
> -      /* TODO(lsm): support other auth methods */
> -      if (r->buf[i] == MG_SOCKS_HANDSHAKE_NOAUTH) reply[1] = r->buf[i];
> +// Walk through all chunks in the chunked body. For each chunk, fire
> +// an MG_EV_HTTP_CHUNK event.
> +static void walkchunks(struct mg_connection *c, struct mg_http_message *hm,
> +                       size_t reqlen) {
> +  size_t off = 0, bl, ll;
> +  while (off + reqlen < c->recv.len) {
> +    char *buf = (char *) &c->recv.buf[reqlen];
> +    size_t memo = c->recv.len;
> +    size_t cl = get_chunk_length(&buf[off], memo - reqlen - off, &ll);
> +    // LOG(LL_INFO, ("len %zu off %zu cl %zu ll %zu", len, off, cl, ll));
> +    if (cl == 0) break;
> +    hm->chunk = mg_str_n(&buf[off + ll], cl < ll + 2 ? 0 : cl - ll - 2);
> +    mg_call(c, MG_EV_HTTP_CHUNK, hm);
> +    // Increase offset only if user has not deleted this chunk
> +    if (memo == c->recv.len) off += cl;
> +    if (cl <= 5) {
> +      // Zero chunk - last one. Prepare body - cut off chunk lengths
> +      off = bl = 0;
> +      while (off + reqlen < c->recv.len) {
> +        char *buf2 = (char *) &c->recv.buf[reqlen];
> +        size_t memo2 = c->recv.len;
> +        size_t cl2 = get_chunk_length(&buf2[off], memo2 - reqlen - off, &ll);
> +        size_t n = cl2 < ll + 2 ? 0 : cl2 - ll - 2;
> +        memmove(buf2 + bl, buf2 + off + ll, n);
> +        bl += n;
> +        off += cl2;
> +        if (cl2 <= 5) break;
> +      }
> +      // LOG(LL_INFO, ("BL->%d del %d off %d", (int) bl, (int) del, (int) off));
> +      c->recv.len -= off - bl;
> +      // Set message length to indicate we've received
> +      // everything, to fire MG_EV_HTTP_MSG
> +      hm->message.len = bl + reqlen;
> +      hm->body.len = bl;
> +      break;
>       }
> -    mbuf_remove(r, 2 + r->buf[1]);
> -    mg_send(c, reply, sizeof(reply));
> -    c->flags |= MG_SOCKS_HANDSHAKE_DONE; /* Mark handshake done */
>     }
>   }
>   
> -static void disband(struct mg_connection *c) {
> -  struct mg_connection *c2 = (struct mg_connection *) c->user_data;
> -  if (c2 != NULL) {
> -    c2->flags |= MG_F_SEND_AND_CLOSE;
> -    c2->user_data = NULL;
> -  }
> -  c->flags |= MG_F_SEND_AND_CLOSE;
> -  c->user_data = NULL;
> +static bool mg_is_chunked(struct mg_http_message *hm) {
> +  struct mg_str needle = mg_str_n("chunked", 7);
> +  struct mg_str *te = mg_http_get_header(hm, "Transfer-Encoding");
> +  return te != NULL && mg_strstr(*te, needle) != NULL;
>   }
>   
> -static void relay_data(struct mg_connection *c) {
> -  struct mg_connection *c2 = (struct mg_connection *) c->user_data;
> -  if (c2 != NULL) {
> -    mg_send(c2, c->recv_mbuf.buf, c->recv_mbuf.len);
> -    mbuf_remove(&c->recv_mbuf, c->recv_mbuf.len);
> -  } else {
> -    c->flags |= MG_F_SEND_AND_CLOSE;
> +void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm) {
> +  struct mg_str ch = hm->chunk;
> +  if (mg_is_chunked(hm)) {
> +    ch.len += 4;  // \r\n before and after the chunk
> +    ch.ptr -= 2;
> +    while (ch.ptr > hm->body.ptr && *ch.ptr != '\n') ch.ptr--, ch.len++;
> +  }
> +  {
> +    const char *end = &ch.ptr[ch.len];
> +    size_t n = (size_t) (end - (char *) c->recv.buf);
> +    if (c->recv.len > n) {
> +      memmove((char *) ch.ptr, end, (size_t) (c->recv.len - n));
> +    }
> +    // LOG(LL_INFO, ("DELETING CHUNK: %zu %zu %zu\n%.*s", c->recv.len, n,
> +    // ch.len, (int) ch.len, ch.ptr));
> +  }
> +  c->recv.len -= ch.len;
> +}
> +
> +static void http_cb(struct mg_connection *c, int ev, void *evd, void *fnd) {
> +  if (ev == MG_EV_READ || ev == MG_EV_CLOSE) {
> +    struct mg_http_message hm;
> +    for (;;) {
> +      int n = mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
> +      bool is_chunked = n > 0 && mg_is_chunked(&hm);
> +      if (ev == MG_EV_CLOSE) {
> +        hm.message.len = c->recv.len;
> +        hm.body.len = hm.message.len - (size_t) (hm.body.ptr - hm.message.ptr);
> +      } else if (is_chunked && n > 0) {
> +        walkchunks(c, &hm, (size_t) n);
> +      }
> +      // LOG(LL_INFO,
> +      //("---->%d %d\n%.*s", n, is_chunked, (int) c->recv.len, c->recv.buf));
> +      if (n < 0 && ev == MG_EV_READ) {
> +        mg_error(c, "HTTP parse:\n%.*s", (int) c->recv.len, c->recv.buf);
> +        break;
> +      } else if (n > 0 && (size_t) c->recv.len >= hm.message.len) {
> +        mg_call(c, MG_EV_HTTP_MSG, &hm);
> +        mg_iobuf_del(&c->recv, 0, hm.message.len);
> +      } else {
> +        if (n > 0 && !is_chunked) {
> +          hm.chunk =
> +              mg_str_n((char *) &c->recv.buf[n], c->recv.len - (size_t) n);
> +          mg_call(c, MG_EV_HTTP_CHUNK, &hm);
> +        }
> +        break;
> +      }
> +    }
>     }
> +  (void) fnd;
> +  (void) evd;
>   }
>   
> -static void serv_ev_handler(struct mg_connection *c, int ev, void *ev_data) {
> -  if (ev == MG_EV_CLOSE) {
> -    disband(c);
> -  } else if (ev == MG_EV_RECV) {
> -    relay_data(c);
> -  } else if (ev == MG_EV_CONNECT) {
> -    int res = *(int *) ev_data;
> -    if (res != 0) LOG(LL_ERROR, ("connect error: %d", res));
> -  }
> +struct mg_connection *mg_http_connect(struct mg_mgr *mgr, const char *url,
> +                                      mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
> +  if (c != NULL) c->pfn = http_cb;
> +  return c;
>   }
>   
> -static void mg_socks5_connect(struct mg_connection *c, const char *addr) {
> -  struct mg_connection *serv = mg_connect(c->mgr, addr, serv_ev_handler);
> -  serv->user_data = c;
> -  c->user_data = serv;
> +struct mg_connection *mg_http_listen(struct mg_mgr *mgr, const char *url,
> +                                     mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = mg_listen(mgr, url, fn, fn_data);
> +  if (c != NULL) c->pfn = http_cb;
> +  return c;
>   }
>   
> -/*
> - *  Request, https://www.ietf.org/rfc/rfc1928.txt paragraph 4
> - *
> - *  +----+-----+-------+------+----------+----------+
> - *  |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
> - *  +----+-----+-------+------+----------+----------+
> - *  | 1  |  1  | X'00' |  1   | Variable |    2     |
> - *  +----+-----+-------+------+----------+----------+
> - */
> -static void mg_socks5_handle_request(struct mg_connection *c) {
> -  struct mbuf *r = &c->recv_mbuf;
> -  unsigned char *p = (unsigned char *) r->buf;
> -  unsigned char addr_len = 4, reply = MG_SOCKS_SUCCESS;
> -  int ver, cmd, atyp;
> -  char addr[300];
> -
> -  if (r->len < 8) return; /* return if not fully buffered. min DST.ADDR is 2 */
> -  ver = p[0];
> -  cmd = p[1];
> -  atyp = p[3];
> -
> -  /* TODO(lsm): support other commands */
> -  if (ver != MG_SOCKS_VERSION || cmd != MG_SOCKS_CMD_CONNECT) {
> -    reply = MG_SOCKS_CMD_NOT_SUPPORTED;
> -  } else if (atyp == MG_SOCKS_ADDR_IPV4) {
> -    addr_len = 4;
> -    if (r->len < (size_t) addr_len + 6) return; /* return if not buffered */
> -    snprintf(addr, sizeof(addr), "%d.%d.%d.%d:%d", p[4], p[5], p[6], p[7],
> -             p[8] << 8 | p[9]);
> -    mg_socks5_connect(c, addr);
> -  } else if (atyp == MG_SOCKS_ADDR_IPV6) {
> -    addr_len = 16;
> -    if (r->len < (size_t) addr_len + 6) return; /* return if not buffered */
> -    snprintf(addr, sizeof(addr), "[%x:%x:%x:%x:%x:%x:%x:%x]:%d",
> -             p[4] << 8 | p[5], p[6] << 8 | p[7], p[8] << 8 | p[9],
> -             p[10] << 8 | p[11], p[12] << 8 | p[13], p[14] << 8 | p[15],
> -             p[16] << 8 | p[17], p[18] << 8 | p[19], p[20] << 8 | p[21]);
> -    mg_socks5_connect(c, addr);
> -  } else if (atyp == MG_SOCKS_ADDR_DOMAIN) {
> -    addr_len = p[4] + 1;
> -    if (r->len < (size_t) addr_len + 6) return; /* return if not buffered */
> -    snprintf(addr, sizeof(addr), "%.*s:%d", p[4], p + 5,
> -             p[4 + addr_len] << 8 | p[4 + addr_len + 1]);
> -    mg_socks5_connect(c, addr);
> -  } else {
> -    reply = MG_SOCKS_ADDR_NOT_SUPPORTED;
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/iobuf.c"
> +#endif
> +
> +
> +
> +#include <string.h>
> +
> +// Not using memset for zeroing memory, cause it can be dropped by compiler
> +// See https://github.com/cesanta/mongoose/pull/1265
> +static void zeromem(volatile unsigned char *buf, size_t len) {
> +  if (buf != NULL) {
> +    while (len--) *buf++ = 0;
>     }
> +}
>   
> -  /*
> -   *  Reply, https://www.ietf.org/rfc/rfc1928.txt paragraph 5
> -   *
> -   *  +----+-----+-------+------+----------+----------+
> -   *  |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
> -   *  +----+-----+-------+------+----------+----------+
> -   *  | 1  |  1  | X'00' |  1   | Variable |    2     |
> -   *  +----+-----+-------+------+----------+----------+
> -   */
> -  {
> -    unsigned char buf[] = {MG_SOCKS_VERSION, reply, 0};
> -    mg_send(c, buf, sizeof(buf));
> +int mg_iobuf_resize(struct mg_iobuf *io, size_t new_size) {
> +  int ok = 1;
> +  if (new_size == 0) {
> +    zeromem(io->buf, io->size);
> +    free(io->buf);
> +    io->buf = NULL;
> +    io->len = io->size = 0;
> +  } else if (new_size != io->size) {
> +    // NOTE(lsm): do not use realloc here. Use calloc/free only, to ease the
> +    // porting to some obscure platforms like FreeRTOS
> +    void *p = calloc(1, new_size);
> +    if (p != NULL) {
> +      size_t len = new_size < io->len ? new_size : io->len;
> +      if (len > 0) memcpy(p, io->buf, len);
> +      zeromem(io->buf, io->size);
> +      free(io->buf);
> +      io->buf = (unsigned char *) p;
> +      io->size = new_size;
> +    } else {
> +      ok = 0;
> +      LOG(LL_ERROR,
> +          ("%lu->%lu", (unsigned long) io->size, (unsigned long) new_size));
> +    }
>     }
> -  mg_send(c, r->buf + 3, addr_len + 1 + 2);
> +  return ok;
> +}
>   
> -  mbuf_remove(r, 6 + addr_len);      /* Remove request from the input stream */
> -  c->flags |= MG_SOCKS_CONNECT_DONE; /* Mark ourselves as connected */
> +int mg_iobuf_init(struct mg_iobuf *io, size_t size) {
> +  return mg_iobuf_resize(io, size);
>   }
>   
> -static void socks_handler(struct mg_connection *c, int ev, void *ev_data) {
> -  if (ev == MG_EV_RECV) {
> -    if (!(c->flags & MG_SOCKS_HANDSHAKE_DONE)) mg_socks5_handshake(c);
> -    if (c->flags & MG_SOCKS_HANDSHAKE_DONE &&
> -        !(c->flags & MG_SOCKS_CONNECT_DONE)) {
> -      mg_socks5_handle_request(c);
> -    }
> -    if (c->flags & MG_SOCKS_CONNECT_DONE) relay_data(c);
> -  } else if (ev == MG_EV_CLOSE) {
> -    disband(c);
> +size_t mg_iobuf_add(struct mg_iobuf *io, size_t ofs, const void *buf,
> +                    size_t len, size_t chunk_size) {
> +  size_t new_size = io->len + len;
> +  if (new_size > io->size) {
> +    new_size += chunk_size;             // Make sure that io->size
> +    new_size -= new_size % chunk_size;  // is aligned by chunk_size boundary
> +    mg_iobuf_resize(io, new_size);      // Attempt to realloc
> +    if (new_size != io->size) len = 0;  // Realloc failure, append nothing
>     }
> -  (void) ev_data;
> +  if (ofs < io->len) memmove(io->buf + ofs + len, io->buf + ofs, io->len - ofs);
> +  if (buf != NULL) memmove(io->buf + ofs, buf, len);
> +  if (ofs > io->len) io->len += ofs - io->len;
> +  io->len += len;
> +  return len;
>   }
>   
> -void mg_set_protocol_socks(struct mg_connection *c) {
> -  c->proto_handler = socks_handler;
> +size_t mg_iobuf_del(struct mg_iobuf *io, size_t ofs, size_t len) {
> +  if (ofs > io->len) ofs = io->len;
> +  if (ofs + len > io->len) len = io->len - ofs;
> +  memmove(io->buf + ofs, io->buf + ofs + len, io->len - ofs - len);
> +  zeromem(io->buf + io->len - len, len);
> +  io->len -= len;
> +  return len;
>   }
> -#endif
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/cc3200/cc3200_libc.c"
> +
> +void mg_iobuf_free(struct mg_iobuf *io) {
> +  mg_iobuf_resize(io, 0);
> +}
> +
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/log.c"
>   #endif
>   
> -#if CS_PLATFORM == CS_P_CC3200
>   
> -/* Amalgamated: #include "common/mg_mem.h" */
> -#include <stdio.h>
> -#include <string.h>
>   
> -#ifndef __TI_COMPILER_VERSION__
> -#include <reent.h>
> -#include <sys/stat.h>
> -#include <sys/time.h>
> -#include <unistd.h>
> -#endif
> +#if MG_ENABLE_LOG
> +static void mg_log_stdout(const void *buf, size_t len, void *userdata) {
> +  (void) userdata;
> +  fwrite(buf, 1, len, stdout);
> +}
>   
> -#include <inc/hw_types.h>
> -#include <inc/hw_memmap.h>
> -#include <driverlib/prcm.h>
> -#include <driverlib/rom.h>
> -#include <driverlib/rom_map.h>
> -#include <driverlib/uart.h>
> -#include <driverlib/utils.h>
> +static const char *s_spec = "2";
> +static void (*s_fn)(const void *, size_t, void *) = mg_log_stdout;
> +static void *s_fn_param = NULL;
>   
> -#define CONSOLE_UART UARTA0_BASE
> +void mg_log_set(const char *spec) {
> +  LOG(LL_DEBUG, ("Setting log level to %s", spec));
> +  s_spec = spec;
> +}
>   
> -#ifdef __TI_COMPILER_VERSION__
> -int asprintf(char **strp, const char *fmt, ...) {
> -  va_list ap;
> -  int len;
> +bool mg_log_prefix(int level, const char *file, int line, const char *fname) {
> +  // static unsigned long seq;
> +  int max = LL_INFO;
> +  struct mg_str k, v, s = mg_str(s_spec);
> +  const char *p = strrchr(file, '/');
>   
> -  *strp = MG_MALLOC(BUFSIZ);
> -  if (*strp == NULL) return -1;
> +  if (s_fn == NULL) return false;
>   
> -  va_start(ap, fmt);
> -  len = vsnprintf(*strp, BUFSIZ, fmt, ap);
> -  va_end(ap);
> +  if (p == NULL) p = strrchr(file, '\\');
> +  p = p == NULL ? file : p + 1;
>   
> -  if (len > 0) {
> -    *strp = MG_REALLOC(*strp, len + 1);
> -    if (*strp == NULL) return -1;
> +  while (mg_commalist(&s, &k, &v)) {
> +    if (v.len == 0) max = atoi(k.ptr);
> +    if (v.len > 0 && strncmp(p, k.ptr, k.len) == 0) max = atoi(v.ptr);
>     }
>   
> -  if (len >= BUFSIZ) {
> -    va_start(ap, fmt);
> -    len = vsnprintf(*strp, len + 1, fmt, ap);
> -    va_end(ap);
> +  if (level <= max) {
> +    char timebuf[21], buf[50] = "";
> +    time_t t = time(NULL);
> +    struct tm tmp, *tm = gmtime_r(&t, &tmp);
> +    int n;
> +    (void) tmp;
> +    strftime(timebuf, sizeof(timebuf), "%Y-%m-%d %H:%M:%S", tm);
> +    n = snprintf(buf, sizeof(buf), "%s %d %s:%d:%s", timebuf, level, p, line,
> +                 fname);
> +    if (n < 0 || n > (int) sizeof(buf) - 2) n = sizeof(buf) - 2;
> +    while (n < (int) sizeof(buf) - 1) buf[n++] = ' ';
> +    s_fn(buf, sizeof(buf) - 1, s_fn_param);
> +    return true;
> +  } else {
> +    return false;
>     }
> +}
>   
> -  return len;
> +void mg_log(const char *fmt, ...) {
> +  char mem[256], *buf = mem;
> +  va_list ap;
> +  int len = 0;
> +  va_start(ap, fmt);
> +  len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  va_end(ap);
> +  s_fn(buf, len > 0 ? (size_t) len : 0, s_fn_param);
> +  s_fn("\n", 1, s_fn_param);
> +  if (buf != mem) free(buf);
>   }
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -time_t HOSTtime() {
> -  struct timeval tp;
> -  gettimeofday(&tp, NULL);
> -  return tp.tv_sec;
> +void mg_log_set_callback(void (*fn)(const void *, size_t, void *), void *fnd) {
> +  s_fn = fn;
> +  s_fn_param = fnd;
>   }
>   #endif
>   
> -#endif /* __TI_COMPILER_VERSION__ */
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/md5.c"
> +#endif
> +#include <string.h>
>   
> -void fprint_str(FILE *fp, const char *str) {
> -  while (*str != '\0') {
> -    if (*str == '\n') MAP_UARTCharPut(CONSOLE_UART, '\r');
> -    MAP_UARTCharPut(CONSOLE_UART, *str++);
> -  }
> -}
>   
> -void _exit(int status) {
> -  fprint_str(stderr, "_exit\n");
> -  /* cause an unaligned access exception, that will drop you into gdb */
> -  *(int *) 1 = status;
> -  while (1)
> -    ; /* avoid gcc warning because stdlib abort() has noreturn attribute */
> -}
> +#if MG_ENABLE_MD5
> +#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
> +#define BYTE_ORDER __BYTE_ORDER
> +#ifndef LITTLE_ENDIAN
> +#define LITTLE_ENDIAN __LITTLE_ENDIAN
> +#endif /* LITTLE_ENDIAN */
> +#ifndef BIG_ENDIAN
> +#define BIG_ENDIAN __LITTLE_ENDIAN
> +#endif /* BIG_ENDIAN */
> +#endif /* BYTE_ORDER */
>   
> -void _not_implemented(const char *what) {
> -  fprint_str(stderr, what);
> -  fprint_str(stderr, " is not implemented\n");
> -  _exit(42);
> +static void mg_byte_reverse(unsigned char *buf, unsigned longs) {
> +/* Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN */
> +#if BYTE_ORDER == BIG_ENDIAN
> +  do {
> +    uint32_t t = (uint32_t)((unsigned) buf[3] << 8 | buf[2]) << 16 |
> +                 ((unsigned) buf[1] << 8 | buf[0]);
> +    *(uint32_t *) buf = t;
> +    buf += 4;
> +  } while (--longs);
> +#else
> +  (void) buf;
> +  (void) longs;
> +#endif
>   }
>   
> -int _kill(int pid, int sig) {
> -  (void) pid;
> -  (void) sig;
> -  _not_implemented("_kill");
> -  return -1;
> -}
> +#define F1(x, y, z) (z ^ (x & (y ^ z)))
> +#define F2(x, y, z) F1(z, x, y)
> +#define F3(x, y, z) (x ^ y ^ z)
> +#define F4(x, y, z) (y ^ (x | ~z))
>   
> -int _getpid() {
> -  fprint_str(stderr, "_getpid is not implemented\n");
> -  return 42;
> -}
> +#define MD5STEP(f, w, x, y, z, data, s) \
> +  (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x)
>   
> -int _isatty(int fd) {
> -  /* 0, 1 and 2 are TTYs. */
> -  return fd < 2;
> +/*
> + * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
> + * initialization constants.
> + */
> +void mg_md5_init(mg_md5_ctx *ctx) {
> +  ctx->buf[0] = 0x67452301;
> +  ctx->buf[1] = 0xefcdab89;
> +  ctx->buf[2] = 0x98badcfe;
> +  ctx->buf[3] = 0x10325476;
> +
> +  ctx->bits[0] = 0;
> +  ctx->bits[1] = 0;
>   }
>   
> -#endif /* CS_PLATFORM == CS_P_CC3200 */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/msp432/msp432_libc.c"
> -#endif
> +static void mg_md5_transform(uint32_t buf[4], uint32_t const in[16]) {
> +  uint32_t a, b, c, d;
> +
> +  a = buf[0];
> +  b = buf[1];
> +  c = buf[2];
> +  d = buf[3];
>   
> -#if CS_PLATFORM == CS_P_MSP432
> +  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
> +  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
> +  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
> +  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
> +  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
> +  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
> +  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
> +  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
> +  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
> +  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
> +  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
> +  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
> +  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
> +  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
> +  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
> +  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
>   
> -#include <ti/sysbios/BIOS.h>
> -#include <ti/sysbios/knl/Clock.h>
> +  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
> +  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
> +  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
> +  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
> +  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
> +  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
> +  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
> +  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
> +  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
> +  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
> +  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
> +  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
> +  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
> +  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
> +  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
> +  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
>   
> -int gettimeofday(struct timeval *tp, void *tzp) {
> -  uint32_t ticks = Clock_getTicks();
> -  tp->tv_sec = ticks / 1000;
> -  tp->tv_usec = (ticks % 1000) * 1000;
> -  return 0;
> +  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
> +  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
> +  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
> +  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
> +  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
> +  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
> +  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
> +  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
> +  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
> +  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
> +  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
> +  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
> +  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
> +  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
> +  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
> +  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
> +
> +  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
> +  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
> +  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
> +  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
> +  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
> +  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
> +  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
> +  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
> +  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
> +  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
> +  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
> +  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
> +  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
> +  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
> +  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
> +  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
> +
> +  buf[0] += a;
> +  buf[1] += b;
> +  buf[2] += c;
> +  buf[3] += d;
>   }
>   
> -#endif /* CS_PLATFORM == CS_P_MSP432 */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/nrf5/nrf5_libc.c"
> -#endif
> +void mg_md5_update(mg_md5_ctx *ctx, const unsigned char *buf, size_t len) {
> +  uint32_t t;
>   
> -#if (CS_PLATFORM == CS_P_NRF51 || CS_PLATFORM == CS_P_NRF52) && \
> -    defined(__ARMCC_VERSION)
> -int gettimeofday(struct timeval *tp, void *tzp) {
> -  /* TODO */
> -  tp->tv_sec = 0;
> -  tp->tv_usec = 0;
> -  return 0;
> +  t = ctx->bits[0];
> +  if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) ctx->bits[1]++;
> +  ctx->bits[1] += (uint32_t) len >> 29;
> +
> +  t = (t >> 3) & 0x3f;
> +
> +  if (t) {
> +    unsigned char *p = (unsigned char *) ctx->in + t;
> +
> +    t = 64 - t;
> +    if (len < t) {
> +      memcpy(p, buf, len);
> +      return;
> +    }
> +    memcpy(p, buf, t);
> +    mg_byte_reverse(ctx->in, 16);
> +    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> +    buf += t;
> +    len -= t;
> +  }
> +
> +  while (len >= 64) {
> +    memcpy(ctx->in, buf, 64);
> +    mg_byte_reverse(ctx->in, 16);
> +    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> +    buf += 64;
> +    len -= 64;
> +  }
> +
> +  memcpy(ctx->in, buf, len);
>   }
> -#endif
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_fs_slfs.h"
> -#endif
>   
> -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_
> -#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_
> +void mg_md5_final(mg_md5_ctx *ctx, unsigned char digest[16]) {
> +  unsigned count;
> +  unsigned char *p;
> +  uint32_t *a;
> +
> +  count = (ctx->bits[0] >> 3) & 0x3F;
> +
> +  p = ctx->in + count;
> +  *p++ = 0x80;
> +  count = 64 - 1 - count;
> +  if (count < 8) {
> +    memset(p, 0, count);
> +    mg_byte_reverse(ctx->in, 16);
> +    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> +    memset(ctx->in, 0, 56);
> +  } else {
> +    memset(p, 0, count - 8);
> +  }
> +  mg_byte_reverse(ctx->in, 14);
>   
> -#if defined(MG_FS_SLFS)
> +  a = (uint32_t *) ctx->in;
> +  a[14] = ctx->bits[0];
> +  a[15] = ctx->bits[1];
>   
> -#include <stdio.h>
> -#ifndef __TI_COMPILER_VERSION__
> -#include <unistd.h>
> -#include <sys/stat.h>
> +  mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
> +  mg_byte_reverse((unsigned char *) ctx->buf, 4);
> +  memcpy(digest, ctx->buf, 16);
> +  memset((char *) ctx, 0, sizeof(*ctx));
> +}
>   #endif
>   
> -#define MAX_OPEN_SLFS_FILES 8
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/mqtt.c"
> +#endif
>   
> -/* Indirect libc interface - same functions, different names. */
> -int fs_slfs_open(const char *pathname, int flags, mode_t mode);
> -int fs_slfs_close(int fd);
> -ssize_t fs_slfs_read(int fd, void *buf, size_t count);
> -ssize_t fs_slfs_write(int fd, const void *buf, size_t count);
> -int fs_slfs_stat(const char *pathname, struct stat *s);
> -int fs_slfs_fstat(int fd, struct stat *s);
> -off_t fs_slfs_lseek(int fd, off_t offset, int whence);
> -int fs_slfs_unlink(const char *filename);
> -int fs_slfs_rename(const char *from, const char *to);
>   
> -void fs_slfs_set_file_size(const char *name, size_t size);
> -void fs_slfs_set_file_flags(const char *name, uint32_t flags, uint32_t *token);
> -void fs_slfs_unset_file_flags(const char *name);
>   
> -#endif /* defined(MG_FS_SLFS) */
>   
> -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_fs_slfs.c"
> -#endif
>   
> -/* Standard libc interface to TI SimpleLink FS. */
>   
> -#if defined(MG_FS_SLFS) || defined(CC3200_FS_SLFS)
>   
> -/* Amalgamated: #include "common/platforms/simplelink/sl_fs_slfs.h" */
>   
> -#include <errno.h>
>   
> -#if CS_PLATFORM == CS_P_CC3200
> -#include <inc/hw_types.h>
> -#endif
> +#define MQTT_CLEAN_SESSION 0x02
> +#define MQTT_HAS_WILL 0x04
> +#define MQTT_WILL_RETAIN 0x20
> +#define MQTT_HAS_PASSWORD 0x40
> +#define MQTT_HAS_USER_NAME 0x80
> +#define MQTT_GET_WILL_QOS(flags) (((flags) &0x18) >> 3)
> +#define MQTT_SET_WILL_QOS(flags, qos) (flags) = ((flags) & ~0x18) | ((qos) << 3)
>   
> -/* Amalgamated: #include "common/cs_dbg.h" */
> -/* Amalgamated: #include "common/mg_mem.h" */
> +enum { MQTT_OK, MQTT_INCOMPLETE, MQTT_MALFORMED };
>   
> -#if SL_MAJOR_VERSION_NUM < 2
> -int slfs_open(const unsigned char *fname, uint32_t flags, uint32_t *token) {
> -  _i32 fh;
> -  _i32 r = sl_FsOpen(fname, flags, (unsigned long *) token, &fh);
> -  return (r < 0 ? r : fh);
> -}
> -#else /* SL_MAJOR_VERSION_NUM >= 2 */
> -int slfs_open(const unsigned char *fname, uint32_t flags, uint32_t *token) {
> -  return sl_FsOpen(fname, flags, (unsigned long *) token);
> +void mg_mqtt_send_header(struct mg_connection *c, uint8_t cmd, uint8_t flags,
> +                         uint32_t len) {
> +  uint8_t buf[1 + sizeof(len)], *vlen = &buf[1];
> +  buf[0] = (uint8_t) ((cmd << 4) | flags);
> +  do {
> +    *vlen = len % 0x80;
> +    len /= 0x80;
> +    if (len > 0) *vlen |= 0x80;
> +    vlen++;
> +  } while (len > 0 && vlen < &buf[sizeof(buf)]);
> +  mg_send(c, buf, (size_t) (vlen - buf));
>   }
> -#endif
>   
> -/* From sl_fs.c */
> -int set_errno(int e);
> -const char *drop_dir(const char *fname, bool *is_slfs);
> -
> -/*
> - * With SLFS, you have to pre-declare max file size. Yes. Really.
> - * 64K should be enough for everyone. Right?
> - */
> -#ifndef FS_SLFS_MAX_FILE_SIZE
> -#define FS_SLFS_MAX_FILE_SIZE (64 * 1024)
> -#endif
> +static void mg_send_u16(struct mg_connection *c, uint16_t value) {
> +  mg_send(c, &value, sizeof(value));
> +}
>   
> -struct sl_file_open_info {
> -  char *name;
> -  size_t size;
> -  uint32_t flags;
> -  uint32_t *token;
> -};
> +void mg_mqtt_login(struct mg_connection *c, const char *url,
> +                   struct mg_mqtt_opts *opts) {
> +  uint32_t total_len = 7 + 1 + 2 + 2;
> +  uint16_t flags = (uint16_t) (((uint16_t) opts->qos & 3) << 3);
> +  struct mg_str user = mg_url_user(url);
> +  struct mg_str pass = mg_url_pass(url);
>   
> -struct sl_fd_info {
> -  _i32 fh;
> -  _off_t pos;
> -  size_t size;
> -};
> +  if (user.len > 0) {
> +    total_len += 2 + (uint32_t) user.len;
> +    flags |= MQTT_HAS_USER_NAME;
> +  }
> +  if (pass.len > 0) {
> +    total_len += 2 + (uint32_t) pass.len;
> +    flags |= MQTT_HAS_PASSWORD;
> +  }
> +  if (opts->will_topic.len > 0 && opts->will_message.len > 0) {
> +    total_len +=
> +        4 + (uint32_t) opts->will_topic.len + (uint32_t) opts->will_message.len;
> +    flags |= MQTT_HAS_WILL;
> +  }
> +  if (opts->clean || opts->client_id.len == 0) flags |= MQTT_CLEAN_SESSION;
> +  if (opts->will_retain) flags |= MQTT_WILL_RETAIN;
> +  total_len += (uint32_t) opts->client_id.len;
> +
> +  mg_mqtt_send_header(c, MQTT_CMD_CONNECT, 0, total_len);
> +  mg_send(c, "\00\04MQTT\04", 7);
> +  mg_send(c, &flags, 1);
> +  // keepalive == 0 means "do not disconnect us!"
> +  mg_send_u16(c, mg_htons((uint16_t) opts->keepalive));
> +  mg_send_u16(c, mg_htons((uint16_t) opts->client_id.len));
> +  mg_send(c, opts->client_id.ptr, opts->client_id.len);
> +  if (flags & MQTT_HAS_WILL) {
> +    mg_send_u16(c, mg_htons((uint16_t) opts->will_topic.len));
> +    mg_send(c, opts->will_topic.ptr, opts->will_topic.len);
> +    mg_send_u16(c, mg_htons((uint16_t) opts->will_message.len));
> +    mg_send(c, opts->will_message.ptr, opts->will_message.len);
> +  }
> +  if (user.len > 0) {
> +    mg_send_u16(c, mg_htons((uint16_t) user.len));
> +    mg_send(c, user.ptr, user.len);
> +  }
> +  if (pass.len > 0) {
> +    mg_send_u16(c, mg_htons((uint16_t) pass.len));
> +    mg_send(c, pass.ptr, pass.len);
> +  }
> +}
> +
> +void mg_mqtt_pub(struct mg_connection *c, struct mg_str *topic,
> +                 struct mg_str *data, int qos, bool retain) {
> +  uint8_t flags = (uint8_t) (((qos & 3) << 1) | (retain ? 1 : 0));
> +  uint32_t total_len = 2 + (uint32_t) topic->len + (uint32_t) data->len;
> +  LOG(LL_DEBUG, ("%lu [%.*s] -> [%.*s]", c->id, (int) topic->len,
> +                 (char *) topic->ptr, (int) data->len, (char *) data->ptr));
> +  if (MQTT_GET_QOS(flags) > 0) total_len += 2;
> +  mg_mqtt_send_header(c, MQTT_CMD_PUBLISH, flags, total_len);
> +  mg_send_u16(c, mg_htons((uint16_t) topic->len));
> +  mg_send(c, topic->ptr, topic->len);
> +  if (MQTT_GET_QOS(flags) > 0) {
> +    static uint16_t s_id;
> +    if (++s_id == 0) s_id++;
> +    mg_send_u16(c, mg_htons(s_id));
> +  }
> +  mg_send(c, data->ptr, data->len);
> +}
> +
> +void mg_mqtt_sub(struct mg_connection *c, struct mg_str *topic, int qos) {
> +  static uint16_t s_id;
> +  uint8_t qos_ = qos & 3;
> +  uint32_t total_len = 2 + (uint32_t) topic->len + 2 + 1;
> +  mg_mqtt_send_header(c, MQTT_CMD_SUBSCRIBE, (uint8_t) MQTT_QOS(qos_),
> +                      total_len);
> +  if (++s_id == 0) ++s_id;
> +  mg_send_u16(c, mg_htons(s_id));
> +  mg_send_u16(c, mg_htons((uint16_t) topic->len));
> +  mg_send(c, topic->ptr, topic->len);
> +  mg_send(c, &qos_, sizeof(qos_));
> +}
> +
> +int mg_mqtt_parse(const uint8_t *buf, size_t len, struct mg_mqtt_message *m) {
> +  uint8_t lc = 0, *p, *end;
> +  uint32_t n = 0, len_len = 0;
>   
> -static struct sl_fd_info s_sl_fds[MAX_OPEN_SLFS_FILES];
> -static struct sl_file_open_info s_sl_file_open_infos[MAX_OPEN_SLFS_FILES];
> -
> -static struct sl_file_open_info *fs_slfs_find_foi(const char *name,
> -                                                  bool create);
> -
> -static int sl_fs_to_errno(_i32 r) {
> -  DBG(("SL error: %d", (int) r));
> -  switch (r) {
> -    case SL_FS_OK:
> -      return 0;
> -    case SL_ERROR_FS_FILE_NAME_EXIST:
> -      return EEXIST;
> -    case SL_ERROR_FS_WRONG_FILE_NAME:
> -      return EINVAL;
> -    case SL_ERROR_FS_NO_AVAILABLE_NV_INDEX:
> -    case SL_ERROR_FS_NOT_ENOUGH_STORAGE_SPACE:
> -      return ENOSPC;
> -    case SL_ERROR_FS_FAILED_TO_ALLOCATE_MEM:
> -      return ENOMEM;
> -    case SL_ERROR_FS_FILE_NOT_EXISTS:
> -      return ENOENT;
> -    case SL_ERROR_FS_NOT_SUPPORTED:
> -      return ENOTSUP;
> -  }
> -  return ENXIO;
> -}
> -
> -int fs_slfs_open(const char *pathname, int flags, mode_t mode) {
> -  int fd;
> -  for (fd = 0; fd < MAX_OPEN_SLFS_FILES; fd++) {
> -    if (s_sl_fds[fd].fh <= 0) break;
> -  }
> -  if (fd >= MAX_OPEN_SLFS_FILES) return set_errno(ENOMEM);
> -  struct sl_fd_info *fi = &s_sl_fds[fd];
> +  memset(m, 0, sizeof(*m));
> +  m->dgram.ptr = (char *) buf;
> +  if (len < 2) return MQTT_INCOMPLETE;
> +  m->cmd = (uint8_t) (buf[0] >> 4);
> +  m->qos = (buf[0] >> 1) & 3;
> +
> +  n = len_len = 0;
> +  p = (uint8_t *) buf + 1;
> +  while ((size_t) (p - buf) < len) {
> +    lc = *((uint8_t *) p++);
> +    n += (uint32_t) ((lc & 0x7f) << 7 * len_len);
> +    len_len++;
> +    if (!(lc & 0x80)) break;
> +    if (len_len >= 4) return MQTT_MALFORMED;
> +  }
> +  end = p + n;
> +  if (lc & 0x80 || end > buf + len) return MQTT_INCOMPLETE;
> +  m->dgram.len = (size_t) (end - buf);
>   
> -  /*
> -   * Apply path manipulations again, in case we got here directly
> -   * (via TI libc's "add_device").
> -   */
> -  pathname = drop_dir(pathname, NULL);
> -
> -  _u32 am = 0;
> -  fi->size = (size_t) -1;
> -  int rw = (flags & 3);
> -  size_t new_size = 0;
> -  struct sl_file_open_info *foi =
> -      fs_slfs_find_foi(pathname, false /* create */);
> -  if (foi != NULL) {
> -    LOG(LL_DEBUG, ("FOI for %s: %d 0x%x %p", pathname, (int) foi->size,
> -                   (unsigned int) foi->flags, foi->token));
> -  }
> -  if (rw == O_RDONLY) {
> -    SlFsFileInfo_t sl_fi;
> -    _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi);
> -    if (r == SL_FS_OK) {
> -      fi->size = SL_FI_FILE_SIZE(sl_fi);
> +  switch (m->cmd) {
> +    case MQTT_CMD_CONNACK:
> +      if (end - p < 2) return MQTT_MALFORMED;
> +      m->ack = p[1];
> +      break;
> +    case MQTT_CMD_PUBACK:
> +    case MQTT_CMD_PUBREC:
> +    case MQTT_CMD_PUBREL:
> +    case MQTT_CMD_PUBCOMP:
> +    case MQTT_CMD_SUBACK:
> +      if (p + 2 > end) return MQTT_MALFORMED;
> +      m->id = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
> +      break;
> +    case MQTT_CMD_SUBSCRIBE: {
> +      if (p + 2 > end) return MQTT_MALFORMED;
> +      m->id = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
> +      p += 2;
> +      break;
>       }
> -    am = SL_FS_READ;
> -  } else {
> -    if (!(flags & O_TRUNC) || (flags & O_APPEND)) {
> -      // FailFS files cannot be opened for append and will be truncated
> -      // when opened for write.
> -      return set_errno(ENOTSUP);
> +    case MQTT_CMD_PUBLISH: {
> +      if (p + 2 > end) return MQTT_MALFORMED;
> +      m->topic.len = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
> +      m->topic.ptr = (char *) p + 2;
> +      p += 2 + m->topic.len;
> +      if (p > end) return MQTT_MALFORMED;
> +      if (m->qos > 0) {
> +        if (p + 2 > end) return MQTT_MALFORMED;
> +        m->id = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
> +        p += 2;
> +      }
> +      if (p > end) return MQTT_MALFORMED;
> +      m->data.ptr = (char *) p;
> +      m->data.len = (size_t) (end - p);
> +      break;
>       }
> -    if (flags & O_CREAT) {
> -      if (foi->size > 0) {
> -        new_size = foi->size;
> +    default:
> +      break;
> +  }
> +  return MQTT_OK;
> +}
> +
> +static size_t mg_mqtt_next_topic(struct mg_mqtt_message *msg,
> +                                 struct mg_str *topic, uint8_t *qos,
> +                                 size_t pos) {
> +  unsigned char *buf = (unsigned char *) msg->dgram.ptr + pos;
> +  size_t new_pos;
> +  if (pos >= msg->dgram.len) return 0;
> +
> +  topic->len = (size_t) (((unsigned) buf[0]) << 8 | buf[1]);
> +  topic->ptr = (char *) buf + 2;
> +  new_pos = pos + 2 + topic->len + (qos == NULL ? 0 : 1);
> +  if ((size_t) new_pos > msg->dgram.len) return 0;
> +  if (qos != NULL) *qos = buf[2 + topic->len];
> +  return new_pos;
> +}
> +
> +size_t mg_mqtt_next_sub(struct mg_mqtt_message *msg, struct mg_str *topic,
> +                        uint8_t *qos, size_t pos) {
> +  uint8_t tmp;
> +  return mg_mqtt_next_topic(msg, topic, qos == NULL ? &tmp : qos, pos);
> +}
> +
> +size_t mg_mqtt_next_unsub(struct mg_mqtt_message *msg, struct mg_str *topic,
> +                          size_t pos) {
> +  return mg_mqtt_next_topic(msg, topic, NULL, pos);
> +}
> +
> +static void mqtt_cb(struct mg_connection *c, int ev, void *ev_data,
> +                    void *fn_data) {
> +  if (ev == MG_EV_READ) {
> +    for (;;) {
> +      struct mg_mqtt_message mm;
> +      int rc = mg_mqtt_parse(c->recv.buf, c->recv.len, &mm);
> +      if (rc == MQTT_MALFORMED) {
> +        LOG(LL_ERROR, ("%lu MQTT malformed message", c->id));
> +        c->is_closing = 1;
> +        break;
> +      } else if (rc == MQTT_OK) {
> +        LOG(LL_VERBOSE_DEBUG,
> +            ("%p MQTT CMD %d len %d [%.*s]", c->fd, mm.cmd, (int) mm.dgram.len,
> +             (int) mm.data.len, mm.data.ptr));
> +        switch (mm.cmd) {
> +          case MQTT_CMD_CONNACK:
> +            mg_call(c, MG_EV_MQTT_OPEN, &mm.ack);
> +            if (mm.ack == 0) {
> +              LOG(LL_INFO, ("%lu Connected", c->id));
> +            } else {
> +              LOG(LL_ERROR, ("%lu MQTT auth failed, code %d", c->id, mm.ack));
> +              c->is_closing = 1;
> +            }
> +            break;
> +          case MQTT_CMD_PUBLISH: {
> +            LOG(LL_DEBUG, ("%lu [%.*s] -> [%.*s]", c->id, (int) mm.topic.len,
> +                           mm.topic.ptr, (int) mm.data.len, mm.data.ptr));
> +            mg_call(c, MG_EV_MQTT_MSG, &mm);
> +            break;
> +          }
> +        }
> +        mg_call(c, MG_EV_MQTT_CMD, &mm);
> +        mg_iobuf_del(&c->recv, 0, mm.dgram.len);
>         } else {
> -        new_size = FS_SLFS_MAX_FILE_SIZE;
> +        break;
>         }
> -      am = FS_MODE_OPEN_CREATE(new_size, 0);
> -    } else {
> -      am = SL_FS_WRITE;
>       }
> -#if SL_MAJOR_VERSION_NUM >= 2
> -    am |= SL_FS_OVERWRITE;
> -#endif
> -  }
> -  uint32_t *token = NULL;
> -  if (foi != NULL) {
> -    am |= foi->flags;
> -    token = foi->token;
> -  }
> -  fi->fh = slfs_open((_u8 *) pathname, am, token);
> -  LOG(LL_DEBUG, ("sl_FsOpen(%s, 0x%x, %p) sz %u = %d", pathname, (int) am,
> -                 token, (unsigned int) new_size, (int) fi->fh));
> -  int r;
> -  if (fi->fh >= 0) {
> -    fi->pos = 0;
> -    r = fd;
> -  } else {
> -    r = set_errno(sl_fs_to_errno(fi->fh));
>     }
> -  return r;
> +  (void) ev_data;
> +  (void) fn_data;
>   }
>   
> -int fs_slfs_close(int fd) {
> -  struct sl_fd_info *fi = &s_sl_fds[fd];
> -  if (fi->fh <= 0) return set_errno(EBADF);
> -  _i32 r = sl_FsClose(fi->fh, NULL, NULL, 0);
> -  LOG(LL_DEBUG, ("sl_FsClose(%d) = %d", (int) fi->fh, (int) r));
> -  s_sl_fds[fd].fh = -1;
> -  return set_errno(sl_fs_to_errno(r));
> +void mg_mqtt_ping(struct mg_connection *nc) {
> +  mg_mqtt_send_header(nc, MQTT_CMD_PINGREQ, 0, 0);
>   }
>   
> -ssize_t fs_slfs_read(int fd, void *buf, size_t count) {
> -  struct sl_fd_info *fi = &s_sl_fds[fd];
> -  if (fi->fh <= 0) return set_errno(EBADF);
> -  /* Simulate EOF. sl_FsRead @ file_size return SL_FS_ERR_OFFSET_OUT_OF_RANGE.
> -   */
> -  if (fi->pos == fi->size) return 0;
> -  _i32 r = sl_FsRead(fi->fh, fi->pos, buf, count);
> -  DBG(("sl_FsRead(%d, %d, %d) = %d", (int) fi->fh, (int) fi->pos, (int) count,
> -       (int) r));
> -  if (r >= 0) {
> -    fi->pos += r;
> -    return r;
> -  }
> -  return set_errno(sl_fs_to_errno(r));
> +void mg_mqtt_pong(struct mg_connection *nc) {
> +  mg_mqtt_send_header(nc, MQTT_CMD_PINGRESP, 0, 0);
>   }
>   
> -ssize_t fs_slfs_write(int fd, const void *buf, size_t count) {
> -  struct sl_fd_info *fi = &s_sl_fds[fd];
> -  if (fi->fh <= 0) return set_errno(EBADF);
> -  _i32 r = sl_FsWrite(fi->fh, fi->pos, (_u8 *) buf, count);
> -  DBG(("sl_FsWrite(%d, %d, %d) = %d", (int) fi->fh, (int) fi->pos, (int) count,
> -       (int) r));
> -  if (r >= 0) {
> -    fi->pos += r;
> -    return r;
> -  }
> -  return set_errno(sl_fs_to_errno(r));
> +void mg_mqtt_disconnect(struct mg_connection *nc) {
> +  mg_mqtt_send_header(nc, MQTT_CMD_DISCONNECT, 0, 0);
>   }
>   
> -int fs_slfs_stat(const char *pathname, struct stat *s) {
> -  SlFsFileInfo_t sl_fi;
> -  /*
> -   * Apply path manipulations again, in case we got here directly
> -   * (via TI libc's "add_device").
> -   */
> -  pathname = drop_dir(pathname, NULL);
> -  _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi);
> -  if (r == SL_FS_OK) {
> -    s->st_mode = S_IFREG | 0666;
> -    s->st_nlink = 1;
> -    s->st_size = SL_FI_FILE_SIZE(sl_fi);
> -    return 0;
> +struct mg_connection *mg_mqtt_connect(struct mg_mgr *mgr, const char *url,
> +                                      struct mg_mqtt_opts *opts,
> +                                      mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
> +  if (c != NULL) {
> +    struct mg_mqtt_opts empty;
> +    memset(&empty, 0, sizeof(empty));
> +    mg_mqtt_login(c, url, opts == NULL ? &empty : opts);
> +    c->pfn = mqtt_cb;
>     }
> -  return set_errno(sl_fs_to_errno(r));
> +  return c;
>   }
>   
> -int fs_slfs_fstat(int fd, struct stat *s) {
> -  struct sl_fd_info *fi = &s_sl_fds[fd];
> -  if (fi->fh <= 0) return set_errno(EBADF);
> -  s->st_mode = 0666;
> -  s->st_mode = S_IFREG | 0666;
> -  s->st_nlink = 1;
> -  s->st_size = fi->size;
> -  return 0;
> +struct mg_connection *mg_mqtt_listen(struct mg_mgr *mgr, const char *url,
> +                                     mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = mg_listen(mgr, url, fn, fn_data);
> +  if (c != NULL) c->pfn = mqtt_cb, c->pfn_data = mgr;
> +  return c;
>   }
>   
> -off_t fs_slfs_lseek(int fd, off_t offset, int whence) {
> -  if (s_sl_fds[fd].fh <= 0) return set_errno(EBADF);
> -  switch (whence) {
> -    case SEEK_SET:
> -      s_sl_fds[fd].pos = offset;
> -      break;
> -    case SEEK_CUR:
> -      s_sl_fds[fd].pos += offset;
> -      break;
> -    case SEEK_END:
> -      return set_errno(ENOTSUP);
> -  }
> -  return 0;
> -}
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/net.c"
> +#endif
>   
> -int fs_slfs_unlink(const char *pathname) {
> -  /*
> -   * Apply path manipulations again, in case we got here directly
> -   * (via TI libc's "add_device").
> -   */
> -  pathname = drop_dir(pathname, NULL);
> -  return set_errno(sl_fs_to_errno(sl_FsDel((const _u8 *) pathname, 0)));
> -}
>   
> -int fs_slfs_rename(const char *from, const char *to) {
> -  return set_errno(ENOTSUP);
> -}
>   
> -static struct sl_file_open_info *fs_slfs_find_foi(const char *name,
> -                                                  bool create) {
> -  int i = 0;
> -  for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) {
> -    if (s_sl_file_open_infos[i].name != NULL &&
> -        strcmp(drop_dir(s_sl_file_open_infos[i].name, NULL), name) == 0) {
> -      break;
> -    }
> -  }
> -  if (i != MAX_OPEN_SLFS_FILES) return &s_sl_file_open_infos[i];
> -  if (!create) return NULL;
> -  for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) {
> -    if (s_sl_file_open_infos[i].name == NULL) break;
> -  }
> -  if (i == MAX_OPEN_SLFS_FILES) {
> -    i = 0; /* Evict a random slot. */
> -  }
> -  if (s_sl_file_open_infos[i].name != NULL) {
> -    free(s_sl_file_open_infos[i].name);
> -  }
> -  s_sl_file_open_infos[i].name = strdup(name);
> -  return &s_sl_file_open_infos[i];
> +
> +int mg_vprintf(struct mg_connection *c, const char *fmt, va_list ap) {
> +  char mem[256], *buf = mem;
> +  int len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  len = mg_send(c, buf, len > 0 ? (size_t) len : 0);
> +  if (buf != mem) free(buf);
> +  return len;
>   }
>   
> -void fs_slfs_set_file_size(const char *name, size_t size) {
> -  struct sl_file_open_info *foi = fs_slfs_find_foi(name, true /* create */);
> -  foi->size = size;
> +int mg_printf(struct mg_connection *c, const char *fmt, ...) {
> +  int len = 0;
> +  va_list ap;
> +  va_start(ap, fmt);
> +  len = mg_vprintf(c, fmt, ap);
> +  va_end(ap);
> +  return len;
>   }
>   
> -void fs_slfs_set_file_flags(const char *name, uint32_t flags, uint32_t *token) {
> -  struct sl_file_open_info *foi = fs_slfs_find_foi(name, true /* create */);
> -  foi->flags = flags;
> -  foi->token = token;
> +char *mg_straddr(struct mg_connection *c, char *buf, size_t len) {
> +  char tmp[100];
> +  const char *fmt = c->peer.is_ip6 ? "[%s]:%d" : "%s:%d";
> +  mg_ntoa(&c->peer, tmp, sizeof(tmp));
> +  snprintf(buf, len, fmt, tmp, (int) mg_ntohs(c->peer.port));
> +  return buf;
>   }
>   
> -void fs_slfs_unset_file_flags(const char *name) {
> -  struct sl_file_open_info *foi = fs_slfs_find_foi(name, false /* create */);
> -  if (foi == NULL) return;
> -  free(foi->name);
> -  memset(foi, 0, sizeof(*foi));
> +char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len) {
> +  if (addr->is_ip6) {
> +    uint16_t *p = (uint16_t *) addr->ip6;
> +    snprintf(buf, len, "%x:%x:%x:%x:%x:%x:%x:%x", mg_htons(p[0]),
> +             mg_htons(p[1]), mg_htons(p[2]), mg_htons(p[3]), mg_htons(p[4]),
> +             mg_htons(p[5]), mg_htons(p[6]), mg_htons(p[7]));
> +  } else {
> +    uint8_t p[4];
> +    memcpy(p, &addr->ip, sizeof(p));
> +    snprintf(buf, len, "%d.%d.%d.%d", (int) p[0], (int) p[1], (int) p[2],
> +             (int) p[3]);
> +  }
> +  return buf;
>   }
>   
> -#endif /* defined(MG_FS_SLFS) || defined(CC3200_FS_SLFS) */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_fs.c"
> -#endif
> +static bool mg_atonl(struct mg_str str, struct mg_addr *addr) {
> +  if (mg_vcasecmp(&str, "localhost") != 0) return false;
> +  addr->ip = mg_htonl(0x7f000001);
> +  addr->is_ip6 = false;
> +  return true;
> +}
>   
> -#if MG_NET_IF == MG_NET_IF_SIMPLELINK && \
> -    (defined(MG_FS_SLFS) || defined(MG_FS_SPIFFS))
> +static bool mg_aton4(struct mg_str str, struct mg_addr *addr) {
> +  uint8_t data[4] = {0, 0, 0, 0};
> +  size_t i, num_dots = 0;
> +  for (i = 0; i < str.len; i++) {
> +    if (str.ptr[i] >= '0' && str.ptr[i] <= '9') {
> +      int octet = data[num_dots] * 10 + (str.ptr[i] - '0');
> +      if (octet > 255) return false;
> +      data[num_dots] = (uint8_t) octet;
> +    } else if (str.ptr[i] == '.') {
> +      if (num_dots >= 3 || i == 0 || str.ptr[i - 1] == '.') return false;
> +      num_dots++;
> +    } else {
> +      return false;
> +    }
> +  }
> +  if (num_dots != 3 || str.ptr[i - 1] == '.') return false;
> +  memcpy(&addr->ip, data, sizeof(data));
> +  addr->is_ip6 = false;
> +  return true;
> +}
>   
> -int set_errno(int e) {
> -  errno = e;
> -  return (e == 0 ? 0 : -1);
> +static bool mg_v4mapped(struct mg_str str, struct mg_addr *addr) {
> +  int i;
> +  if (str.len < 14) return false;
> +  if (str.ptr[0] != ':' || str.ptr[1] != ':' || str.ptr[6] != ':') return false;
> +  for (i = 2; i < 6; i++) {
> +    if (str.ptr[i] != 'f' && str.ptr[i] != 'F') return false;
> +  }
> +  if (!mg_aton4(mg_str_n(&str.ptr[7], str.len - 7), addr)) return false;
> +  memset(addr->ip6, 0, sizeof(addr->ip6));
> +  addr->ip6[10] = addr->ip6[11] = 255;
> +  memcpy(&addr->ip6[12], &addr->ip, 4);
> +  addr->is_ip6 = true;
> +  return true;
>   }
>   
> -const char *drop_dir(const char *fname, bool *is_slfs) {
> -  if (is_slfs != NULL) {
> -    *is_slfs = (strncmp(fname, "SL:", 3) == 0);
> -    if (*is_slfs) fname += 3;
> -  }
> -  /* Drop "./", if any */
> -  if (fname[0] == '.' && fname[1] == '/') {
> -    fname += 2;
> +static bool mg_aton6(struct mg_str str, struct mg_addr *addr) {
> +  size_t i, j = 0, n = 0, dc = 42;
> +  if (str.len > 2 && str.ptr[0] == '[') str.ptr++, str.len -= 2;
> +  if (mg_v4mapped(str, addr)) return true;
> +  for (i = 0; i < str.len; i++) {
> +    if ((str.ptr[i] >= '0' && str.ptr[i] <= '9') ||
> +        (str.ptr[i] >= 'a' && str.ptr[i] <= 'f') ||
> +        (str.ptr[i] >= 'A' && str.ptr[i] <= 'F')) {
> +      unsigned long val;
> +      if (i > j + 3) return false;
> +      // LOG(LL_DEBUG, ("%zu %zu [%.*s]", i, j, (int) (i - j + 1),
> +      // &str.ptr[j]));
> +      val = mg_unhexn(&str.ptr[j], i - j + 1);
> +      addr->ip6[n] = (uint8_t) ((val >> 8) & 255);
> +      addr->ip6[n + 1] = (uint8_t) (val & 255);
> +    } else if (str.ptr[i] == ':') {
> +      j = i + 1;
> +      if (i > 0 && str.ptr[i - 1] == ':') {
> +        dc = n;  // Double colon
> +        if (i > 1 && str.ptr[i - 2] == ':') return false;
> +      } else if (i > 0) {
> +        n += 2;
> +      }
> +      if (n > 14) return false;
> +      addr->ip6[n] = addr->ip6[n + 1] = 0;  // For trailing ::
> +    } else {
> +      return false;
> +    }
>     }
> -  /*
> -   * Drop / if it is the only one in the path.
> -   * This allows use of /pretend/directories but serves /file.txt as normal.
> -   */
> -  if (fname[0] == '/' && strchr(fname + 1, '/') == NULL) {
> -    fname++;
> +  if (n < 14 && dc == 42) return false;
> +  if (n < 14) {
> +    memmove(&addr->ip6[dc + (14 - n)], &addr->ip6[dc], n - dc + 2);
> +    memset(&addr->ip6[dc], 0, 14 - n);
>     }
> -  return fname;
> +  addr->is_ip6 = true;
> +  return true;
>   }
>   
> -#if !defined(MG_FS_NO_VFS)
> +bool mg_aton(struct mg_str str, struct mg_addr *addr) {
> +  // LOG(LL_INFO, ("[%.*s]", (int) str.len, str.ptr));
> +  return mg_atonl(str, addr) || mg_aton4(str, addr) || mg_aton6(str, addr);
> +}
>   
> -#include <errno.h>
> -#include <stdbool.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#ifdef __TI_COMPILER_VERSION__
> -#include <file.h>
> +void mg_mgr_free(struct mg_mgr *mgr) {
> +  struct mg_connection *c;
> +  for (c = mgr->conns; c != NULL; c = c->next) c->is_closing = 1;
> +  mg_mgr_poll(mgr, 0);
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP
> +  FreeRTOS_DeleteSocketSet(mgr->ss);
> +#endif
> +  LOG(LL_INFO, ("All connections closed"));
> +}
> +
> +void mg_mgr_init(struct mg_mgr *mgr) {
> +  memset(mgr, 0, sizeof(*mgr));
> +#if defined(_WIN32) && MG_ENABLE_WINSOCK
> +  // clang-format off
> +  { WSADATA data; WSAStartup(MAKEWORD(2, 2), &data); }
> +  // clang-format on
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
> +  mgr->ss = FreeRTOS_CreateSocketSet();
> +#elif defined(__unix) || defined(__unix__) || defined(__APPLE__)
> +  // Ignore SIGPIPE signal, so if client cancels the request, it
> +  // won't kill the whole process.
> +  signal(SIGPIPE, SIG_IGN);
>   #endif
> +  mgr->dnstimeout = 3000;
> +  mgr->dns4.url = "udp://8.8.8.8:53";
> +  mgr->dns6.url = "udp://[2001:4860:4860::8888]:53";
> +}
>   
> -/* Amalgamated: #include "common/cs_dbg.h" */
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifdef CC3200_FS_SPIFFS
> -/* Amalgamated: #include "cc3200_fs_spiffs.h" */
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/sha1.c"
>   #endif
> +/* Copyright(c) By Steve Reid <steve@edmweb.com> */
> +/* 100% Public Domain */
>   
> -#ifdef MG_FS_SLFS
> -/* Amalgamated: #include "sl_fs_slfs.h" */
> -#endif
> +#include <string.h>
>   
> -#define NUM_SYS_FDS 3
> -#define SPIFFS_FD_BASE 10
> -#define SLFS_FD_BASE 100
> -
> -#if !defined(MG_UART_CHAR_PUT) && !defined(MG_UART_WRITE)
> -#if CS_PLATFORM == CS_P_CC3200
> -#include <inc/hw_types.h>
> -#include <inc/hw_memmap.h>
> -#include <driverlib/rom.h>
> -#include <driverlib/rom_map.h>
> -#include <driverlib/uart.h>
> -#define MG_UART_CHAR_PUT(fd, c) MAP_UARTCharPut(UARTA0_BASE, c);
> -#else
> -#define MG_UART_WRITE(fd, buf, len)
> -#endif /* CS_PLATFORM == CS_P_CC3200 */
> -#endif /* !MG_UART_CHAR_PUT */
> -
> -enum fd_type {
> -  FD_INVALID,
> -  FD_SYS,
> -#ifdef CC3200_FS_SPIFFS
> -  FD_SPIFFS,
> -#endif
> -#ifdef MG_FS_SLFS
> -  FD_SLFS
> -#endif
> +/*
> + * clang with std=-c99 uses __LITTLE_ENDIAN, by default
> + * while for ex, RTOS gcc - LITTLE_ENDIAN, by default
> + * it depends on __USE_BSD, but let's have everything
> + */
> +#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
> +#define BYTE_ORDER __BYTE_ORDER
> +#ifndef LITTLE_ENDIAN
> +#define LITTLE_ENDIAN __LITTLE_ENDIAN
> +#endif /* LITTLE_ENDIAN */
> +#ifndef BIG_ENDIAN
> +#define BIG_ENDIAN __LITTLE_ENDIAN
> +#endif /* BIG_ENDIAN */
> +#endif /* BYTE_ORDER */
> +
> +union char64long16 {
> +  unsigned char c[64];
> +  uint32_t l[16];
>   };
> -static int fd_type(int fd) {
> -  if (fd >= 0 && fd < NUM_SYS_FDS) return FD_SYS;
> -#ifdef CC3200_FS_SPIFFS
> -  if (fd >= SPIFFS_FD_BASE && fd < SPIFFS_FD_BASE + MAX_OPEN_SPIFFS_FILES) {
> -    return FD_SPIFFS;
> -  }
> -#endif
> -#ifdef MG_FS_SLFS
> -  if (fd >= SLFS_FD_BASE && fd < SLFS_FD_BASE + MAX_OPEN_SLFS_FILES) {
> -    return FD_SLFS;
> -  }
> -#endif
> -  return FD_INVALID;
> -}
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -int open(const char *pathname, unsigned flags, int mode) {
> -#else
> -int _open(const char *pathname, int flags, mode_t mode) {
> -#endif
> -  int fd = -1;
> -  bool is_sl;
> -  const char *fname = drop_dir(pathname, &is_sl);
> -  if (is_sl) {
> -#ifdef MG_FS_SLFS
> -    fd = fs_slfs_open(fname, flags, mode);
> -    if (fd >= 0) fd += SLFS_FD_BASE;
> -#endif
> -  } else {
> -#ifdef CC3200_FS_SPIFFS
> -    fd = fs_spiffs_open(fname, flags, mode);
> -    if (fd >= 0) fd += SPIFFS_FD_BASE;
> +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
> +
> +static uint32_t blk0(union char64long16 *block, int i) {
> +/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
> +#if BYTE_ORDER == LITTLE_ENDIAN
> +  block->l[i] =
> +      (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
>   #endif
> -  }
> -  LOG(LL_DEBUG,
> -      ("open(%s, 0x%x) = %d, fname = %s", pathname, flags, fd, fname));
> -  return fd;
> +  return block->l[i];
>   }
>   
> -int _stat(const char *pathname, struct stat *st) {
> -  int res = -1;
> -  bool is_sl;
> -  const char *fname = drop_dir(pathname, &is_sl);
> -  memset(st, 0, sizeof(*st));
> -  /* Simulate statting the root directory. */
> -  if (fname[0] == '\0' || strcmp(fname, ".") == 0) {
> -    st->st_ino = 0;
> -    st->st_mode = S_IFDIR | 0777;
> -    st->st_nlink = 1;
> -    st->st_size = 0;
> -    return 0;
> -  }
> -  if (is_sl) {
> -#ifdef MG_FS_SLFS
> -    res = fs_slfs_stat(fname, st);
> -#endif
> -  } else {
> -#ifdef CC3200_FS_SPIFFS
> -    res = fs_spiffs_stat(fname, st);
> -#endif
> -  }
> -  LOG(LL_DEBUG, ("stat(%s) = %d; fname = %s", pathname, res, fname));
> -  return res;
> +/* Avoid redefine warning (ARM /usr/include/sys/ucontext.h define R0~R4) */
> +#undef blk
> +#undef R0
> +#undef R1
> +#undef R2
> +#undef R3
> +#undef R4
> +
> +#define blk(i)                                                               \
> +  (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
> +                              block->l[(i + 2) & 15] ^ block->l[i & 15],     \
> +                          1))
> +#define R0(v, w, x, y, z, i)                                          \
> +  z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \
> +  w = rol(w, 30);
> +#define R1(v, w, x, y, z, i)                                  \
> +  z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
> +  w = rol(w, 30);
> +#define R2(v, w, x, y, z, i)                          \
> +  z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
> +  w = rol(w, 30);
> +#define R3(v, w, x, y, z, i)                                        \
> +  z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
> +  w = rol(w, 30);
> +#define R4(v, w, x, y, z, i)                          \
> +  z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
> +  w = rol(w, 30);
> +
> +void mg_sha1_transform(uint32_t state[5], const unsigned char buffer[64]) {
> +  uint32_t a, b, c, d, e;
> +  union char64long16 block[1];
> +
> +  memcpy(block, buffer, 64);
> +  a = state[0];
> +  b = state[1];
> +  c = state[2];
> +  d = state[3];
> +  e = state[4];
> +  R0(a, b, c, d, e, 0);
> +  R0(e, a, b, c, d, 1);
> +  R0(d, e, a, b, c, 2);
> +  R0(c, d, e, a, b, 3);
> +  R0(b, c, d, e, a, 4);
> +  R0(a, b, c, d, e, 5);
> +  R0(e, a, b, c, d, 6);
> +  R0(d, e, a, b, c, 7);
> +  R0(c, d, e, a, b, 8);
> +  R0(b, c, d, e, a, 9);
> +  R0(a, b, c, d, e, 10);
> +  R0(e, a, b, c, d, 11);
> +  R0(d, e, a, b, c, 12);
> +  R0(c, d, e, a, b, 13);
> +  R0(b, c, d, e, a, 14);
> +  R0(a, b, c, d, e, 15);
> +  R1(e, a, b, c, d, 16);
> +  R1(d, e, a, b, c, 17);
> +  R1(c, d, e, a, b, 18);
> +  R1(b, c, d, e, a, 19);
> +  R2(a, b, c, d, e, 20);
> +  R2(e, a, b, c, d, 21);
> +  R2(d, e, a, b, c, 22);
> +  R2(c, d, e, a, b, 23);
> +  R2(b, c, d, e, a, 24);
> +  R2(a, b, c, d, e, 25);
> +  R2(e, a, b, c, d, 26);
> +  R2(d, e, a, b, c, 27);
> +  R2(c, d, e, a, b, 28);
> +  R2(b, c, d, e, a, 29);
> +  R2(a, b, c, d, e, 30);
> +  R2(e, a, b, c, d, 31);
> +  R2(d, e, a, b, c, 32);
> +  R2(c, d, e, a, b, 33);
> +  R2(b, c, d, e, a, 34);
> +  R2(a, b, c, d, e, 35);
> +  R2(e, a, b, c, d, 36);
> +  R2(d, e, a, b, c, 37);
> +  R2(c, d, e, a, b, 38);
> +  R2(b, c, d, e, a, 39);
> +  R3(a, b, c, d, e, 40);
> +  R3(e, a, b, c, d, 41);
> +  R3(d, e, a, b, c, 42);
> +  R3(c, d, e, a, b, 43);
> +  R3(b, c, d, e, a, 44);
> +  R3(a, b, c, d, e, 45);
> +  R3(e, a, b, c, d, 46);
> +  R3(d, e, a, b, c, 47);
> +  R3(c, d, e, a, b, 48);
> +  R3(b, c, d, e, a, 49);
> +  R3(a, b, c, d, e, 50);
> +  R3(e, a, b, c, d, 51);
> +  R3(d, e, a, b, c, 52);
> +  R3(c, d, e, a, b, 53);
> +  R3(b, c, d, e, a, 54);
> +  R3(a, b, c, d, e, 55);
> +  R3(e, a, b, c, d, 56);
> +  R3(d, e, a, b, c, 57);
> +  R3(c, d, e, a, b, 58);
> +  R3(b, c, d, e, a, 59);
> +  R4(a, b, c, d, e, 60);
> +  R4(e, a, b, c, d, 61);
> +  R4(d, e, a, b, c, 62);
> +  R4(c, d, e, a, b, 63);
> +  R4(b, c, d, e, a, 64);
> +  R4(a, b, c, d, e, 65);
> +  R4(e, a, b, c, d, 66);
> +  R4(d, e, a, b, c, 67);
> +  R4(c, d, e, a, b, 68);
> +  R4(b, c, d, e, a, 69);
> +  R4(a, b, c, d, e, 70);
> +  R4(e, a, b, c, d, 71);
> +  R4(d, e, a, b, c, 72);
> +  R4(c, d, e, a, b, 73);
> +  R4(b, c, d, e, a, 74);
> +  R4(a, b, c, d, e, 75);
> +  R4(e, a, b, c, d, 76);
> +  R4(d, e, a, b, c, 77);
> +  R4(c, d, e, a, b, 78);
> +  R4(b, c, d, e, a, 79);
> +  state[0] += a;
> +  state[1] += b;
> +  state[2] += c;
> +  state[3] += d;
> +  state[4] += e;
> +  /* Erase working structures. The order of operations is important,
> +   * used to ensure that compiler doesn't optimize those out. */
> +  memset(block, 0, sizeof(block));
> +  a = b = c = d = e = 0;
> +  (void) a;
> +  (void) b;
> +  (void) c;
> +  (void) d;
> +  (void) e;
>   }
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -int close(int fd) {
> -#else
> -int _close(int fd) {
> -#endif
> -  int r = -1;
> -  switch (fd_type(fd)) {
> -    case FD_INVALID:
> -      r = set_errno(EBADF);
> -      break;
> -    case FD_SYS:
> -      r = set_errno(EACCES);
> -      break;
> -#ifdef CC3200_FS_SPIFFS
> -    case FD_SPIFFS:
> -      r = fs_spiffs_close(fd - SPIFFS_FD_BASE);
> -      break;
> -#endif
> -#ifdef MG_FS_SLFS
> -    case FD_SLFS:
> -      r = fs_slfs_close(fd - SLFS_FD_BASE);
> -      break;
> -#endif
> -  }
> -  DBG(("close(%d) = %d", fd, r));
> -  return r;
> +void mg_sha1_init(mg_sha1_ctx *context) {
> +  context->state[0] = 0x67452301;
> +  context->state[1] = 0xEFCDAB89;
> +  context->state[2] = 0x98BADCFE;
> +  context->state[3] = 0x10325476;
> +  context->state[4] = 0xC3D2E1F0;
> +  context->count[0] = context->count[1] = 0;
>   }
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -off_t lseek(int fd, off_t offset, int whence) {
> -#else
> -off_t _lseek(int fd, off_t offset, int whence) {
> -#endif
> -  int r = -1;
> -  switch (fd_type(fd)) {
> -    case FD_INVALID:
> -      r = set_errno(EBADF);
> -      break;
> -    case FD_SYS:
> -      r = set_errno(ESPIPE);
> -      break;
> -#ifdef CC3200_FS_SPIFFS
> -    case FD_SPIFFS:
> -      r = fs_spiffs_lseek(fd - SPIFFS_FD_BASE, offset, whence);
> -      break;
> -#endif
> -#ifdef MG_FS_SLFS
> -    case FD_SLFS:
> -      r = fs_slfs_lseek(fd - SLFS_FD_BASE, offset, whence);
> -      break;
> -#endif
> -  }
> -  DBG(("lseek(%d, %d, %d) = %d", fd, (int) offset, whence, r));
> -  return r;
> -}
> +void mg_sha1_update(mg_sha1_ctx *context, const unsigned char *data,
> +                    size_t len) {
> +  size_t i, j;
>   
> -int _fstat(int fd, struct stat *s) {
> -  int r = -1;
> -  memset(s, 0, sizeof(*s));
> -  switch (fd_type(fd)) {
> -    case FD_INVALID:
> -      r = set_errno(EBADF);
> -      break;
> -    case FD_SYS: {
> -      /* Create barely passable stats for STD{IN,OUT,ERR}. */
> -      memset(s, 0, sizeof(*s));
> -      s->st_ino = fd;
> -      s->st_mode = S_IFCHR | 0666;
> -      r = 0;
> -      break;
> +  j = context->count[0];
> +  if ((context->count[0] += (uint32_t) len << 3) < j) context->count[1]++;
> +  context->count[1] += (uint32_t)(len >> 29);
> +  j = (j >> 3) & 63;
> +  if ((j + len) > 63) {
> +    memcpy(&context->buffer[j], data, (i = 64 - j));
> +    mg_sha1_transform(context->state, context->buffer);
> +    for (; i + 63 < len; i += 64) {
> +      mg_sha1_transform(context->state, &data[i]);
>       }
> -#ifdef CC3200_FS_SPIFFS
> -    case FD_SPIFFS:
> -      r = fs_spiffs_fstat(fd - SPIFFS_FD_BASE, s);
> -      break;
> -#endif
> -#ifdef MG_FS_SLFS
> -    case FD_SLFS:
> -      r = fs_slfs_fstat(fd - SLFS_FD_BASE, s);
> -      break;
> -#endif
> -  }
> -  DBG(("fstat(%d) = %d", fd, r));
> -  return r;
> +    j = 0;
> +  } else
> +    i = 0;
> +  memcpy(&context->buffer[j], &data[i], len - i);
>   }
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -int read(int fd, char *buf, unsigned count) {
> -#else
> -ssize_t _read(int fd, void *buf, size_t count) {
> -#endif
> -  int r = -1;
> -  switch (fd_type(fd)) {
> -    case FD_INVALID:
> -      r = set_errno(EBADF);
> -      break;
> -    case FD_SYS: {
> -      if (fd != 0) {
> -        r = set_errno(EACCES);
> -        break;
> -      }
> -      /* Should we allow reading from stdin = uart? */
> -      r = set_errno(ENOTSUP);
> -      break;
> -    }
> -#ifdef CC3200_FS_SPIFFS
> -    case FD_SPIFFS:
> -      r = fs_spiffs_read(fd - SPIFFS_FD_BASE, buf, count);
> -      break;
> -#endif
> -#ifdef MG_FS_SLFS
> -    case FD_SLFS:
> -      r = fs_slfs_read(fd - SLFS_FD_BASE, buf, count);
> -      break;
> -#endif
> -  }
> -  DBG(("read(%d, %u) = %d", fd, count, r));
> -  return r;
> -}
> +void mg_sha1_final(unsigned char digest[20], mg_sha1_ctx *context) {
> +  unsigned i;
> +  unsigned char finalcount[8], c;
>   
> -#if MG_TI_NO_HOST_INTERFACE
> -int write(int fd, const char *buf, unsigned count) {
> -#else
> -ssize_t _write(int fd, const void *buf, size_t count) {
> -#endif
> -  int r = -1;
> -  switch (fd_type(fd)) {
> -    case FD_INVALID:
> -      r = set_errno(EBADF);
> -      break;
> -    case FD_SYS: {
> -      if (fd == 0) {
> -        r = set_errno(EACCES);
> -        break;
> -      }
> -#ifdef MG_UART_WRITE
> -      MG_UART_WRITE(fd, buf, count);
> -#elif defined(MG_UART_CHAR_PUT)
> -      {
> -        size_t i;
> -        for (i = 0; i < count; i++) {
> -          const char c = ((const char *) buf)[i];
> -          if (c == '\n') MG_UART_CHAR_PUT(fd, '\r');
> -          MG_UART_CHAR_PUT(fd, c);
> -        }
> -      }
> -#endif
> -      r = count;
> -      break;
> -    }
> -#ifdef CC3200_FS_SPIFFS
> -    case FD_SPIFFS:
> -      r = fs_spiffs_write(fd - SPIFFS_FD_BASE, buf, count);
> -      break;
> -#endif
> -#ifdef MG_FS_SLFS
> -    case FD_SLFS:
> -      r = fs_slfs_write(fd - SLFS_FD_BASE, buf, count);
> -      break;
> -#endif
> +  for (i = 0; i < 8; i++) {
> +    finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
> +                                      ((3 - (i & 3)) * 8)) &
> +                                     255);
>     }
> -  return r;
> -}
> -
> -/*
> - * On Newlib we override rename directly too, because the default
> - * implementation using _link and _unlink doesn't work for us.
> - */
> -#if MG_TI_NO_HOST_INTERFACE || defined(_NEWLIB_VERSION)
> -int rename(const char *frompath, const char *topath) {
> -  int r = -1;
> -  bool is_sl_from, is_sl_to;
> -  const char *from = drop_dir(frompath, &is_sl_from);
> -  const char *to = drop_dir(topath, &is_sl_to);
> -  if (is_sl_from || is_sl_to) {
> -    set_errno(ENOTSUP);
> -  } else {
> -#ifdef CC3200_FS_SPIFFS
> -    r = fs_spiffs_rename(from, to);
> -#endif
> +  c = 0200;
> +  mg_sha1_update(context, &c, 1);
> +  while ((context->count[0] & 504) != 448) {
> +    c = 0000;
> +    mg_sha1_update(context, &c, 1);
>     }
> -  DBG(("rename(%s, %s) = %d", from, to, r));
> -  return r;
> -}
> -#endif /* MG_TI_NO_HOST_INTERFACE || defined(_NEWLIB_VERSION) */
> -
> -#if MG_TI_NO_HOST_INTERFACE
> -int unlink(const char *pathname) {
> -#else
> -int _unlink(const char *pathname) {
> -#endif
> -  int r = -1;
> -  bool is_sl;
> -  const char *fname = drop_dir(pathname, &is_sl);
> -  if (is_sl) {
> -#ifdef MG_FS_SLFS
> -    r = fs_slfs_unlink(fname);
> -#endif
> -  } else {
> -#ifdef CC3200_FS_SPIFFS
> -    r = fs_spiffs_unlink(fname);
> -#endif
> +  mg_sha1_update(context, finalcount, 8);
> +  for (i = 0; i < 20; i++) {
> +    digest[i] =
> +        (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
>     }
> -  DBG(("unlink(%s) = %d, fname = %s", pathname, r, fname));
> -  return r;
> +  memset(context, '\0', sizeof(*context));
> +  memset(&finalcount, '\0', sizeof(finalcount));
>   }
>   
> -#ifdef CC3200_FS_SPIFFS /* FailFS does not support listing files. */
> -DIR *opendir(const char *dir_name) {
> -  DIR *r = NULL;
> -  bool is_sl;
> -  drop_dir(dir_name, &is_sl);
> -  if (is_sl) {
> -    r = NULL;
> -    set_errno(ENOTSUP);
> -  } else {
> -    r = fs_spiffs_opendir(dir_name);
> +void mg_hmac_sha1(const unsigned char *key, size_t keylen,
> +                  const unsigned char *data, size_t datalen,
> +                  unsigned char out[20]) {
> +  mg_sha1_ctx ctx;
> +  unsigned char buf1[64], buf2[64], tmp_key[20], i;
> +
> +  if (keylen > sizeof(buf1)) {
> +    mg_sha1_init(&ctx);
> +    mg_sha1_update(&ctx, key, keylen);
> +    mg_sha1_final(tmp_key, &ctx);
> +    key = tmp_key;
> +    keylen = sizeof(tmp_key);
>     }
> -  DBG(("opendir(%s) = %p", dir_name, r));
> -  return r;
> -}
>   
> -struct dirent *readdir(DIR *dir) {
> -  struct dirent *res = fs_spiffs_readdir(dir);
> -  DBG(("readdir(%p) = %p", dir, res));
> -  return res;
> -}
> +  memset(buf1, 0, sizeof(buf1));
> +  memset(buf2, 0, sizeof(buf2));
> +  memcpy(buf1, key, keylen);
> +  memcpy(buf2, key, keylen);
>   
> -int closedir(DIR *dir) {
> -  int res = fs_spiffs_closedir(dir);
> -  DBG(("closedir(%p) = %d", dir, res));
> -  return res;
> -}
> +  for (i = 0; i < sizeof(buf1); i++) {
> +    buf1[i] ^= 0x36;
> +    buf2[i] ^= 0x5c;
> +  }
>   
> -int rmdir(const char *path) {
> -  return fs_spiffs_rmdir(path);
> -}
> +  mg_sha1_init(&ctx);
> +  mg_sha1_update(&ctx, buf1, sizeof(buf1));
> +  mg_sha1_update(&ctx, data, datalen);
> +  mg_sha1_final(out, &ctx);
>   
> -int mkdir(const char *path, mode_t mode) {
> -  (void) path;
> -  (void) mode;
> -  /* for spiffs supports only root dir, which comes from mongoose as '.' */
> -  return (strlen(path) == 1 && *path == '.') ? 0 : ENOTDIR;
> +  mg_sha1_init(&ctx);
> +  mg_sha1_update(&ctx, buf2, sizeof(buf2));
> +  mg_sha1_update(&ctx, out, 20);
> +  mg_sha1_final(out, &ctx);
>   }
> -#endif
>   
> -int sl_fs_init(void) {
> -  int ret = 1;
> -#ifdef __TI_COMPILER_VERSION__
> -#ifdef MG_FS_SLFS
> -#pragma diag_push
> -#pragma diag_suppress 169 /* Nothing we can do about the prototype mismatch. \
> -                             */
> -  ret = (add_device("SL", _MSA, fs_slfs_open, fs_slfs_close, fs_slfs_read,
> -                    fs_slfs_write, fs_slfs_lseek, fs_slfs_unlink,
> -                    fs_slfs_rename) == 0);
> -#pragma diag_pop
> -#endif
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/sntp.c"
>   #endif
> -  return ret;
> -}
>   
> -#endif /* !defined(MG_FS_NO_VFS) */
> -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK && (defined(MG_FS_SLFS) || \
> -          defined(MG_FS_SPIFFS)) */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_socket.c"
> -#endif
>   
> -#if MG_NET_IF == MG_NET_IF_SIMPLELINK
>   
> -#include <errno.h>
> -#include <stdio.h>
>   
> -/* Amalgamated: #include "common/platform.h" */
>   
> -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
> -  int res;
> -  struct in_addr *in = (struct in_addr *) src;
> -  if (af != AF_INET) {
> -    errno = ENOTSUP;
> -    return NULL;
> -  }
> -  res = snprintf(dst, size, "%lu.%lu.%lu.%lu", SL_IPV4_BYTE(in->s_addr, 0),
> -                 SL_IPV4_BYTE(in->s_addr, 1), SL_IPV4_BYTE(in->s_addr, 2),
> -                 SL_IPV4_BYTE(in->s_addr, 3));
> -  return res > 0 ? dst : NULL;
> -}
>   
> -char *inet_ntoa(struct in_addr n) {
> -  static char a[16];
> -  return (char *) inet_ntop(AF_INET, &n, a, sizeof(a));
> -}
> +#define SNTP_INTERVAL_SEC (3600)
> +#define SNTP_TIME_OFFSET 2208988800UL
>   
> -int inet_pton(int af, const char *src, void *dst) {
> -  uint32_t a0, a1, a2, a3;
> -  uint8_t *db = (uint8_t *) dst;
> -  if (af != AF_INET) {
> -    errno = ENOTSUP;
> -    return 0;
> -  }
> -  if (sscanf(src, "%lu.%lu.%lu.%lu", &a0, &a1, &a2, &a3) != 4) {
> -    return 0;
> +static unsigned long s_sntmp_next;
> +
> +int mg_sntp_parse(const unsigned char *buf, size_t len, struct timeval *tv) {
> +  int mode = len > 0 ? buf[0] & 7 : 0, res = -1;
> +  if (len < 48) {
> +    LOG(LL_ERROR, ("%s", "corrupt packet"));
> +  } else if ((buf[0] & 0x38) >> 3 != 4) {
> +    LOG(LL_ERROR, ("%s", "wrong version"));
> +  } else if (mode != 4 && mode != 5) {
> +    LOG(LL_ERROR, ("%s", "not a server reply"));
> +  } else if (buf[1] == 0) {
> +    LOG(LL_ERROR, ("%s", "server sent a kiss of death"));
> +  } else {
> +    uint32_t *data = (uint32_t *) &buf[40];
> +    tv->tv_sec = (time_t) (mg_ntohl(data[0]) - SNTP_TIME_OFFSET);
> +    tv->tv_usec = (suseconds_t) mg_ntohl(data[1]);
> +    s_sntmp_next = (unsigned long) (tv->tv_sec + SNTP_INTERVAL_SEC);
> +    res = 0;
>     }
> -  *db = a3;
> -  *(db + 1) = a2;
> -  *(db + 2) = a1;
> -  *(db + 3) = a0;
> -  return 1;
> +  return res;
>   }
>   
> -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_mg_task.c"
> -#endif
> -#if MG_NET_IF == MG_NET_IF_SIMPLELINK && !defined(MG_SIMPLELINK_NO_OSI)
> -
> -/* Amalgamated: #include "mg_task.h" */
> -
> -#include <oslib/osi.h>
> -
> -enum mg_q_msg_type {
> -  MG_Q_MSG_CB,
> -};
> -struct mg_q_msg {
> -  enum mg_q_msg_type type;
> -  void (*cb)(struct mg_mgr *mgr, void *arg);
> -  void *arg;
> -};
> -static OsiMsgQ_t s_mg_q;
> -static void mg_task(void *arg);
> -
> -bool mg_start_task(int priority, int stack_size, mg_init_cb mg_init) {
> -  if (osi_MsgQCreate(&s_mg_q, "MG", sizeof(struct mg_q_msg), 16) != OSI_OK) {
> -    return false;
> -  }
> -  if (osi_TaskCreate(mg_task, (const signed char *) "MG", stack_size,
> -                     (void *) mg_init, priority, NULL) != OSI_OK) {
> -    return false;
> +static void sntp_cb(struct mg_connection *c, int ev, void *evd, void *fnd) {
> +  if (ev == MG_EV_READ) {
> +    struct timeval tv = {0, 0};
> +    if (mg_sntp_parse(c->recv.buf, c->recv.len, &tv) == 0) {
> +      mg_call(c, MG_EV_SNTP_TIME, &tv);
> +      LOG(LL_DEBUG, ("%u.%u, next at %lu", (unsigned) tv.tv_sec,
> +                     (unsigned) tv.tv_usec, s_sntmp_next));
> +    }
> +    c->recv.len = 0;  // Clear receive buffer
> +  } else if (ev == MG_EV_CONNECT) {
> +    mg_sntp_send(c, (unsigned long) time(NULL));
> +  } else if (ev == MG_EV_CLOSE) {
>     }
> -  return true;
> +  (void) fnd;
> +  (void) evd;
>   }
>   
> -static void mg_task(void *arg) {
> -  struct mg_mgr mgr;
> -  mg_init_cb mg_init = (mg_init_cb) arg;
> -  mg_mgr_init(&mgr, NULL);
> -  mg_init(&mgr);
> -  while (1) {
> -    struct mg_q_msg msg;
> -    mg_mgr_poll(&mgr, 1);
> -    if (osi_MsgQRead(&s_mg_q, &msg, 1) != OSI_OK) continue;
> -    switch (msg.type) {
> -      case MG_Q_MSG_CB: {
> -        msg.cb(&mgr, msg.arg);
> -      }
> -    }
> +void mg_sntp_send(struct mg_connection *c, unsigned long utc) {
> +  if (c->is_resolving) {
> +    LOG(LL_ERROR, ("%lu wait until resolved", c->id));
> +  } else if (utc > s_sntmp_next) {
> +    uint8_t buf[48] = {0};
> +    s_sntmp_next = utc + SNTP_INTERVAL_SEC;
> +    buf[0] = (3 << 6) | (4 << 3) | 3;
> +    mg_send(c, buf, sizeof(buf));
> +    LOG(LL_DEBUG,
> +        ("%p request sent, ct %lu, next at %lu", c->fd, utc, s_sntmp_next));
>     }
>   }
>   
> -void mg_run_in_task(void (*cb)(struct mg_mgr *mgr, void *arg), void *cb_arg) {
> -  struct mg_q_msg msg = {MG_Q_MSG_CB, cb, cb_arg};
> -  osi_MsgQWrite(&s_mg_q, &msg, OSI_NO_WAIT);
> +struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, const char *url,
> +                                      mg_event_handler_t fn, void *fnd) {
> +  struct mg_connection *c = NULL;
> +  if (url == NULL) url = "udp://time.google.com:123";
> +  if ((c = mg_connect(mgr, url, fn, fnd)) != NULL) c->pfn = sntp_cb;
> +  return c;
>   }
>   
> -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK && !defined(MG_SIMPLELINK_NO_OSI) \
> -          */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_net_if.h"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/sock.c"
>   #endif
>   
> -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_
> -#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_
>   
> -/* Amalgamated: #include "mongoose/src/net_if.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -#ifndef MG_ENABLE_NET_IF_SIMPLELINK
> -#define MG_ENABLE_NET_IF_SIMPLELINK MG_NET_IF == MG_NET_IF_SIMPLELINK
> -#endif
>   
> -extern const struct mg_iface_vtable mg_simplelink_iface_vtable;
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
>   
> -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_net_if.c"
> -#endif
>   
> -/* Amalgamated: #include "common/platforms/simplelink/sl_net_if.h" */
>   
> -#if MG_ENABLE_NET_IF_SIMPLELINK
>   
> -/* Amalgamated: #include "mongoose/src/internal.h" */
> -/* Amalgamated: #include "mongoose/src/util.h" */
>   
> -#define MG_TCP_RECV_BUFFER_SIZE 1024
> -#define MG_UDP_RECV_BUFFER_SIZE 1500
>   
> -static sock_t mg_open_listening_socket(struct mg_connection *nc,
> -                                       union socket_address *sa, int type,
> -                                       int proto);
>   
> -static void mg_set_non_blocking_mode(sock_t sock) {
> -  SlSockNonblocking_t opt;
> -#if SL_MAJOR_VERSION_NUM < 2
> -  opt.NonblockingEnabled = 1;
> +#if MG_ENABLE_SOCKET
> +#if defined(_WIN32) && MG_ENABLE_WINSOCK
> +#define MG_SOCK_ERRNO WSAGetLastError()
> +#ifndef SO_EXCLUSIVEADDRUSE
> +#define SO_EXCLUSIVEADDRUSE ((int) (~SO_REUSEADDR))
> +#endif
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
> +#define MG_SOCK_ERRNO errno
> +typedef Socket_t SOCKET;
> +#define INVALID_SOCKET FREERTOS_INVALID_SOCKET
>   #else
> -  opt.NonBlockingEnabled = 1;
> +#define MG_SOCK_ERRNO errno
> +#ifndef closesocket
> +#define closesocket(x) close(x)
> +#endif
> +#define INVALID_SOCKET (-1)
> +typedef int SOCKET;
>   #endif
> -  sl_SetSockOpt(sock, SL_SOL_SOCKET, SL_SO_NONBLOCKING, &opt, sizeof(opt));
> -}
>   
> -static int mg_is_error(int n) {
> -  return (n < 0 && n != SL_ERROR_BSD_EALREADY && n != SL_ERROR_BSD_EAGAIN);
> -}
> +#define FD(c_) ((SOCKET) (size_t) (c_)->fd)
> +#define S2PTR(s_) ((void *) (size_t) (s_))
>   
> -static void mg_sl_if_connect_tcp(struct mg_connection *nc,
> -                                 const union socket_address *sa) {
> -  int proto = 0;
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
> -  if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET;
> -#endif
> -  sock_t sock = sl_Socket(AF_INET, SOCK_STREAM, proto);
> -  if (sock < 0) {
> -    nc->err = sock;
> -    goto out;
> -  }
> -  mg_sock_set(nc, sock);
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
> -  nc->err = sl_set_ssl_opts(sock, nc);
> -  if (nc->err != 0) goto out;
> +#ifndef MSG_NONBLOCKING
> +#define MSG_NONBLOCKING 0
>   #endif
> -  nc->err = sl_Connect(sock, &sa->sa, sizeof(sa->sin));
> -out:
> -  DBG(("%p to %s:%d sock %d %d err %d", nc, inet_ntoa(sa->sin.sin_addr),
> -       ntohs(sa->sin.sin_port), nc->sock, proto, nc->err));
> -}
>   
> -static void mg_sl_if_connect_udp(struct mg_connection *nc) {
> -  sock_t sock = sl_Socket(AF_INET, SOCK_DGRAM, 0);
> -  if (sock < 0) {
> -    nc->err = sock;
> -    return;
> -  }
> -  mg_sock_set(nc, sock);
> -  nc->err = 0;
> -}
> +#ifndef AF_INET6
> +#define AF_INET6 10
> +#endif
>   
> -static int mg_sl_if_listen_tcp(struct mg_connection *nc,
> -                               union socket_address *sa) {
> -  int proto = 0;
> -  if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET;
> -  sock_t sock = mg_open_listening_socket(nc, sa, SOCK_STREAM, proto);
> -  if (sock < 0) return sock;
> -  mg_sock_set(nc, sock);
> -  return 0;
> -}
> +union usa {
> +  struct sockaddr sa;
> +  struct sockaddr_in sin;
> +#if MG_ENABLE_IPV6
> +  struct sockaddr_in6 sin6;
> +#endif
> +};
>   
> -static int mg_sl_if_listen_udp(struct mg_connection *nc,
> -                               union socket_address *sa) {
> -  sock_t sock = mg_open_listening_socket(nc, sa, SOCK_DGRAM, 0);
> -  if (sock == INVALID_SOCKET) return (errno ? errno : 1);
> -  mg_sock_set(nc, sock);
> -  return 0;
> +static socklen_t tousa(struct mg_addr *a, union usa *usa) {
> +  socklen_t len = sizeof(usa->sin);
> +  memset(usa, 0, sizeof(*usa));
> +  usa->sin.sin_family = AF_INET;
> +  usa->sin.sin_port = a->port;
> +  *(uint32_t *) &usa->sin.sin_addr = a->ip;
> +#if MG_ENABLE_IPV6
> +  if (a->is_ip6) {
> +    usa->sin.sin_family = AF_INET6;
> +    usa->sin6.sin6_port = a->port;
> +    memcpy(&usa->sin6.sin6_addr, a->ip6, sizeof(a->ip6));
> +    len = sizeof(usa->sin6);
> +  }
> +#endif
> +  return len;
>   }
>   
> -static int mg_sl_if_tcp_send(struct mg_connection *nc, const void *buf,
> -                             size_t len) {
> -  int n = (int) sl_Send(nc->sock, buf, len, 0);
> -  if (n < 0 && !mg_is_error(n)) n = 0;
> -  return n;
> +static void tomgaddr(union usa *usa, struct mg_addr *a, bool is_ip6) {
> +  a->is_ip6 = is_ip6;
> +  a->port = usa->sin.sin_port;
> +  memcpy(&a->ip, &usa->sin.sin_addr, sizeof(a->ip));
> +#if MG_ENABLE_IPV6
> +  if (is_ip6) {
> +    memcpy(a->ip6, &usa->sin6.sin6_addr, sizeof(a->ip6));
> +    a->port = usa->sin6.sin6_port;
> +  }
> +#endif
>   }
>   
> -static int mg_sl_if_udp_send(struct mg_connection *nc, const void *buf,
> -                             size_t len) {
> -  int n = sl_SendTo(nc->sock, buf, len, 0, &nc->sa.sa, sizeof(nc->sa.sin));
> -  if (n < 0 && !mg_is_error(n)) n = 0;
> -  return n;
> +static bool mg_sock_would_block(void) {
> +  int err = MG_SOCK_ERRNO;
> +  return err == EINPROGRESS || err == EWOULDBLOCK
> +#ifndef WINCE
> +         || err == EAGAIN || err == EINTR
> +#endif
> +#if defined(_WIN32) && MG_ENABLE_WINSOCK
> +         || err == WSAEINTR || err == WSAEWOULDBLOCK
> +#endif
> +      ;
>   }
>   
> -static int mg_sl_if_tcp_recv(struct mg_connection *nc, void *buf, size_t len) {
> -  int n = sl_Recv(nc->sock, buf, len, 0);
> -  if (n == 0) {
> -    /* Orderly shutdown of the socket, try flushing output. */
> -    nc->flags |= MG_F_SEND_AND_CLOSE;
> -  } else if (n < 0 && !mg_is_error(n)) {
> -    n = 0;
> +static struct mg_connection *alloc_conn(struct mg_mgr *mgr, bool is_client,
> +                                        SOCKET fd) {
> +  struct mg_connection *c = (struct mg_connection *) calloc(1, sizeof(*c));
> +  if (c != NULL) {
> +    c->is_client = is_client;
> +    c->fd = S2PTR(fd);
> +    c->mgr = mgr;
> +    c->id = ++mgr->nextid;
>     }
> -  return n;
> +  return c;
>   }
>   
> -static int mg_sl_if_udp_recv(struct mg_connection *nc, void *buf, size_t len,
> -                             union socket_address *sa, size_t *sa_len) {
> -  SlSocklen_t sa_len_t = *sa_len;
> -  int n = sl_RecvFrom(nc->sock, buf, MG_UDP_RECV_BUFFER_SIZE, 0,
> -                      (SlSockAddr_t *) sa, &sa_len_t);
> -  *sa_len = sa_len_t;
> -  if (n < 0 && !mg_is_error(n)) n = 0;
> -  return n;
> +static long mg_sock_send(struct mg_connection *c, const void *buf, size_t len) {
> +  long n = send(FD(c), (char *) buf, len, MSG_NONBLOCKING);
> +  return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n;
>   }
>   
> -static int mg_sl_if_create_conn(struct mg_connection *nc) {
> -  (void) nc;
> -  return 1;
> +bool mg_send(struct mg_connection *c, const void *buf, size_t len) {
> +  return c->is_udp ? mg_sock_send(c, buf, len) > 0
> +                   : mg_iobuf_add(&c->send, c->send.len, buf, len, MG_IO_SIZE);
>   }
>   
> -void mg_sl_if_destroy_conn(struct mg_connection *nc) {
> -  if (nc->sock == INVALID_SOCKET) return;
> -  /* For UDP, only close outgoing sockets or listeners. */
> -  if (!(nc->flags & MG_F_UDP) || nc->listener == NULL) {
> -    sl_Close(nc->sock);
> -  }
> -  nc->sock = INVALID_SOCKET;
> +static void mg_set_non_blocking_mode(SOCKET fd) {
> +#if defined(_WIN32) && MG_ENABLE_WINSOCK
> +  unsigned long on = 1;
> +  ioctlsocket(fd, FIONBIO, &on);
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
> +  const BaseType_t off = 0;
> +  setsockopt(fd, 0, FREERTOS_SO_RCVTIMEO, &off, sizeof(off));
> +  setsockopt(fd, 0, FREERTOS_SO_SNDTIMEO, &off, sizeof(off));
> +#elif MG_ARCH == MG_ARCH_FREERTOS_LWIP
> +  lwip_fcntl(fd, F_SETFL, O_NONBLOCK);
> +#elif MG_ARCH == MG_ARCH_AZURERTOS
> +  fcntl(fd, F_SETFL, O_NONBLOCK);
> +#else
> +  fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK, FD_CLOEXEC);
> +#endif
>   }
>   
> -static int mg_accept_conn(struct mg_connection *lc) {
> -  struct mg_connection *nc;
> -  union socket_address sa;
> -  socklen_t sa_len = sizeof(sa);
> -  sock_t sock = sl_Accept(lc->sock, &sa.sa, &sa_len);
> -  if (sock < 0) {
> -    DBG(("%p: failed to accept: %d", lc, sock));
> -    return 0;
> -  }
> -  nc = mg_if_accept_new_conn(lc);
> -  if (nc == NULL) {
> -    sl_Close(sock);
> -    return 0;
> -  }
> -  DBG(("%p conn from %s:%d", nc, inet_ntoa(sa.sin.sin_addr),
> -       ntohs(sa.sin.sin_port)));
> -  mg_sock_set(nc, sock);
> -  mg_if_accept_tcp_cb(nc, &sa, sa_len);
> -  return 1;
> -}
> -
> -/* 'sa' must be an initialized address to bind to */
> -static sock_t mg_open_listening_socket(struct mg_connection *nc,
> -                                       union socket_address *sa, int type,
> -                                       int proto) {
> -  int r;
> -  socklen_t sa_len =
> -      (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6);
> -  sock_t sock = sl_Socket(sa->sa.sa_family, type, proto);
> -  if (sock < 0) return sock;
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
> -  if ((r = sl_set_ssl_opts(sock, nc)) < 0) goto clean;
> +SOCKET mg_open_listener(const char *url, struct mg_addr *addr) {
> +  SOCKET fd = INVALID_SOCKET;
> +  int s_err = 0;  // Memoized socket error, in case closesocket() overrides it
> +  memset(addr, 0, sizeof(*addr));
> +  addr->port = mg_htons(mg_url_port(url));
> +  if (!mg_aton(mg_url_host(url), addr)) {
> +    LOG(LL_ERROR, ("invalid listening URL: %s", url));
> +  } else {
> +    union usa usa;
> +    socklen_t slen = tousa(addr, &usa);
> +    int on = 1, af = addr->is_ip6 ? AF_INET6 : AF_INET;
> +    int type = strncmp(url, "udp:", 4) == 0 ? SOCK_DGRAM : SOCK_STREAM;
> +    int proto = type == SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP;
> +    (void) on;
> +
> +    if ((fd = socket(af, type, proto)) != INVALID_SOCKET &&
> +#if (!defined(_WIN32) || !defined(SO_EXCLUSIVEADDRUSE)) && \
> +    (!defined(LWIP_SOCKET) || (defined(LWIP_SOCKET) && SO_REUSE == 1))
> +        // 1. SO_RESUSEADDR is not enabled on Windows because the semantics of
> +        //    SO_REUSEADDR on UNIX and Windows is different. On Windows,
> +        //    SO_REUSEADDR allows to bind a socket to a port without error even
> +        //    if the port is already open by another program. This is not the
> +        //    behavior SO_REUSEADDR was designed for, and leads to hard-to-track
> +        //    failure scenarios. Therefore, SO_REUSEADDR was disabled on Windows
> +        //    unless SO_EXCLUSIVEADDRUSE is supported and set on a socket.
> +        // 2. In case of LWIP, SO_REUSEADDR should be explicitly enabled, by
> +        // defining
> +        //    SO_REUSE (in lwipopts.h), otherwise the code below will compile
> +        //    but won't work! (setsockopt will return EINVAL)
> +        !setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on)) &&
> +#endif
> +#if defined(_WIN32) && defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE)
> +        // "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE"
> +        //! setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *) &on, sizeof(on))
> +        //! &&
> +        !setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *) &on,
> +                    sizeof(on)) &&
> +#endif
> +        bind(fd, &usa.sa, slen) == 0 &&
> +        // NOTE(lsm): FreeRTOS uses backlog value as a connection limit
> +        (type == SOCK_DGRAM || listen(fd, MG_SOCK_LISTEN_BACKLOG_SIZE) == 0)) {
> +      // In case port was set to 0, get the real port number
> +      if (getsockname(fd, &usa.sa, &slen) == 0) {
> +        addr->port = usa.sin.sin_port;
> +#if MG_ENABLE_IPV6
> +        if (addr->is_ip6) addr->port = usa.sin6.sin6_port;
>   #endif
> -  if ((r = sl_Bind(sock, &sa->sa, sa_len)) < 0) goto clean;
> -  if (type != SOCK_DGRAM) {
> -    if ((r = sl_Listen(sock, SOMAXCONN)) < 0) goto clean;
> +      }
> +      mg_set_non_blocking_mode(fd);
> +    } else if (fd != INVALID_SOCKET) {
> +      s_err = MG_SOCK_ERRNO;
> +      closesocket(fd);
> +      fd = INVALID_SOCKET;
> +    }
>     }
> -  mg_set_non_blocking_mode(sock);
> -clean:
> -  if (r < 0) {
> -    sl_Close(sock);
> -    sock = r;
> +  if (fd == INVALID_SOCKET) {
> +    if (s_err == 0) s_err = MG_SOCK_ERRNO;
> +    LOG(LL_ERROR, ("Failed to listen on %s, errno %d", url, s_err));
>     }
> -  return sock;
> -}
>   
> -#define _MG_F_FD_CAN_READ 1
> -#define _MG_F_FD_CAN_WRITE 1 << 1
> -#define _MG_F_FD_ERROR 1 << 2
> +  return fd;
> +}
>   
> -void mg_mgr_handle_conn(struct mg_connection *nc, int fd_flags, double now) {
> -  DBG(("%p fd=%d fd_flags=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc, nc->sock,
> -       fd_flags, nc->flags, (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
> +static long mg_sock_recv(struct mg_connection *c, void *buf, size_t len) {
> +  long n = 0;
> +  if (c->is_udp) {
> +    union usa usa;
> +    socklen_t slen = tousa(&c->peer, &usa);
> +    n = recvfrom(FD(c), (char *) buf, len, 0, &usa.sa, &slen);
> +    if (n > 0) tomgaddr(&usa, &c->peer, slen != sizeof(usa.sin));
> +  } else {
> +    n = recv(FD(c), (char *) buf, len, MSG_NONBLOCKING);
> +  }
> +  return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n;
> +}
>   
> -  if (!mg_if_poll(nc, now)) return;
> +// NOTE(lsm): do only one iteration of reads, cause some systems
> +// (e.g. FreeRTOS stack) return 0 instead of -1/EWOULDBLOCK when no data
> +static void read_conn(struct mg_connection *c) {
> +  if (c->recv.len >= MG_MAX_RECV_BUF_SIZE) {
> +    mg_error(c, "max_recv_buf_size reached");
> +  } else if (c->recv.size - c->recv.len < MG_IO_SIZE &&
> +             !mg_iobuf_resize(&c->recv, c->recv.size + MG_IO_SIZE)) {
> +    mg_error(c, "oom");
> +  } else {
> +    char *buf = (char *) &c->recv.buf[c->recv.len];
> +    size_t len = c->recv.size - c->recv.len;
> +    long n = c->is_tls ? mg_tls_recv(c, buf, len) : mg_sock_recv(c, buf, len);
> +    LOG(n > 0 ? LL_VERBOSE_DEBUG : LL_DEBUG,
> +        ("%-3lu %d%d%d%d%d%d%d%d%d%d%d%d%d%d %7ld %ld/%ld err %d", c->id,
> +         c->is_listening, c->is_client, c->is_accepted, c->is_resolving,
> +         c->is_connecting, c->is_tls, c->is_tls_hs, c->is_udp, c->is_websocket,
> +         c->is_hexdumping, c->is_draining, c->is_closing, c->is_readable,
> +         c->is_writable, (long) c->recv.len, n, (long) len, MG_SOCK_ERRNO));
> +    if (n == 0) {
> +      // Do nothing
> +    } else if (n < 0) {
> +      c->is_closing = 1;  // Error, or normal termination
> +    } else if (n > 0) {
> +      struct mg_str evd = mg_str_n(buf, (size_t) n);
> +      if (c->is_hexdumping) {
> +        char *s = mg_hexdump(buf, (size_t) n);
> +        LOG(LL_INFO, ("\n-- %lu %s %s %ld\n%s", c->id, c->label, "<-", n, s));
> +        free(s);
> +      }
> +      c->recv.len += (size_t) n;
> +      mg_call(c, MG_EV_READ, &evd);
> +    }
> +  }
> +}
> +
> +static void write_conn(struct mg_connection *c) {
> +  char *buf = (char *) c->send.buf;
> +  size_t len = c->send.len;
> +  long n = c->is_tls ? mg_tls_send(c, buf, len) : mg_sock_send(c, buf, len);
> +
> +  LOG(n > 0 ? LL_VERBOSE_DEBUG : LL_DEBUG,
> +      ("%-3lu %d%d%d%d%d%d%d%d%d%d%d%d%d%d %7ld %ld err %d", c->id,
> +       c->is_listening, c->is_client, c->is_accepted, c->is_resolving,
> +       c->is_connecting, c->is_tls, c->is_tls_hs, c->is_udp, c->is_websocket,
> +       c->is_hexdumping, c->is_draining, c->is_closing, c->is_readable,
> +       c->is_writable, (long) c->send.len, n, MG_SOCK_ERRNO));
>   
> -  if (nc->flags & MG_F_CONNECTING) {
> -    if ((nc->flags & MG_F_UDP) || nc->err != SL_ERROR_BSD_EALREADY) {
> -      mg_if_connect_cb(nc, nc->err);
> -    } else {
> -      /* In SimpleLink, to get status of non-blocking connect() we need to wait
> -       * until socket is writable and repeat the call to sl_Connect again,
> -       * which will now return the real status. */
> -      if (fd_flags & _MG_F_FD_CAN_WRITE) {
> -        nc->err = sl_Connect(nc->sock, &nc->sa.sa, sizeof(nc->sa.sin));
> -        DBG(("%p conn res=%d", nc, nc->err));
> -        if (nc->err == SL_ERROR_BSD_ESECSNOVERIFY ||
> -            /* TODO(rojer): Provide API to set the date for verification. */
> -            nc->err == SL_ERROR_BSD_ESECDATEERROR
> -#if SL_MAJOR_VERSION_NUM >= 2
> -            /* Per SWRU455, this error does not mean verification failed,
> -             * it only means that the cert used is not present in the trusted
> -             * root CA catalog. Which is perfectly fine. */
> -            ||
> -            nc->err == SL_ERROR_BSD_ESECUNKNOWNROOTCA
> +  if (n == 0) {
> +    // Do nothing
> +  } else if (n < 0) {
> +    c->is_closing = 1;  // Error, or normal termination
> +  } else if (n > 0) {
> +    // Hexdump before deleting
> +    if (c->is_hexdumping) {
> +      char *s = mg_hexdump(buf, (size_t) n);
> +      LOG(LL_INFO, ("\n-- %lu %s %s %ld\n%s", c->id, c->label, "<-", n, s));
> +      free(s);
> +    }
> +    mg_iobuf_del(&c->send, 0, (size_t) n);
> +    if (c->send.len == 0) mg_iobuf_resize(&c->send, 0);
> +    mg_call(c, MG_EV_WRITE, &n);
> +    // if (c->send.len == 0) mg_iobuf_resize(&c->send, 0);
> +  }
> +}
> +
> +static void close_conn(struct mg_connection *c) {
> +  mg_resolve_cancel(c);  // Close any pending DNS query
> +  LIST_DELETE(struct mg_connection, &c->mgr->conns, c);
> +  if (c == c->mgr->dns4.c) c->mgr->dns4.c = NULL;
> +  if (c == c->mgr->dns6.c) c->mgr->dns6.c = NULL;
> +  // Order of operations is important. `MG_EV_CLOSE` event must be fired
> +  // before we deallocate received data, see #1331
> +  mg_call(c, MG_EV_CLOSE, NULL);
> +  LOG(LL_DEBUG, ("%lu closed", c->id));
> +  if (FD(c) != INVALID_SOCKET) {
> +    closesocket(FD(c));
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP
> +    FreeRTOS_FD_CLR(c->fd, c->mgr->ss, eSELECT_ALL);
> +#endif
> +    c->fd = S2PTR(INVALID_SOCKET);
> +  }
> +  mg_tls_free(c);
> +  mg_iobuf_free(&c->recv);
> +  mg_iobuf_free(&c->send);
> +  memset(c, 0, sizeof(*c));
> +  free(c);
> +}
> +
> +static void setsockopts(struct mg_connection *c) {
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_AZURERTOS
> +  (void) c;
> +#else
> +  int on = 1;
> +#if !defined(SOL_TCP)
> +#define SOL_TCP IPPROTO_TCP
>   #endif
> -            ) {
> -          nc->err = 0;
> -        }
> -        mg_if_connect_cb(nc, nc->err);
> -      }
> -    }
> -    /* Ignore read/write in further processing, we've handled it. */
> -    fd_flags &= ~(_MG_F_FD_CAN_READ | _MG_F_FD_CAN_WRITE);
> +  setsockopt(FD(c), SOL_TCP, TCP_NODELAY, (char *) &on, sizeof(on));
> +#if defined(TCP_QUICKACK)
> +  setsockopt(FD(c), SOL_TCP, TCP_QUICKACK, (char *) &on, sizeof(on));
> +#endif
> +  setsockopt(FD(c), SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof(on));
> +#if ESP32 || ESP8266 || defined(__linux__)
> +  int idle = 60;
> +  setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
> +#endif
> +#if !defined(_WIN32) && !defined(__QNX__)
> +  {
> +    int cnt = 3, intvl = 20;
> +    setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));
> +    setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
>     }
> +#endif
> +#endif
> +}
>   
> -  if (fd_flags & _MG_F_FD_CAN_READ) {
> -    if (nc->flags & MG_F_UDP) {
> -      mg_if_can_recv_cb(nc);
> +void mg_connect_resolved(struct mg_connection *c) {
> +  char buf[40];
> +  int type = c->is_udp ? SOCK_DGRAM : SOCK_STREAM;
> +  int rc, af = c->peer.is_ip6 ? AF_INET6 : AF_INET;
> +  mg_straddr(c, buf, sizeof(buf));
> +  c->fd = S2PTR(socket(af, type, 0));
> +  if (FD(c) == INVALID_SOCKET) {
> +    mg_error(c, "socket(): %d", MG_SOCK_ERRNO);
> +  } else {
> +    union usa usa;
> +    socklen_t slen = tousa(&c->peer, &usa);
> +    if (c->is_udp == 0) mg_set_non_blocking_mode(FD(c));
> +    if (c->is_udp == 0) setsockopts(c);
> +    mg_call(c, MG_EV_RESOLVE, NULL);
> +    if ((rc = connect(FD(c), &usa.sa, slen)) == 0) {
> +      mg_call(c, MG_EV_CONNECT, NULL);
> +    } else if (mg_sock_would_block()) {
> +      c->is_connecting = 1;
>       } else {
> -      if (nc->flags & MG_F_LISTENING) {
> -        mg_accept_conn(nc);
> -      } else {
> -        mg_if_can_recv_cb(nc);
> -      }
> +      mg_error(c, "connect: %d", MG_SOCK_ERRNO);
>       }
>     }
> +}
>   
> -  if (fd_flags & _MG_F_FD_CAN_WRITE) {
> -    mg_if_can_send_cb(nc);
> +struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *url,
> +                                 mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = NULL;
> +  if ((c = alloc_conn(mgr, 1, INVALID_SOCKET)) == NULL) {
> +    LOG(LL_ERROR, ("OOM"));
> +  } else {
> +    struct mg_str host = mg_url_host(url);
> +    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
> +    c->is_udp = (strncmp(url, "udp:", 4) == 0);
> +    c->peer.port = mg_htons(mg_url_port(url));
> +    c->fn = fn;
> +    c->fn_data = fn_data;
> +    LOG(LL_DEBUG, ("%lu -> %s", c->id, url));
> +    mg_resolve(c, &host, mgr->dnstimeout);
>     }
> -
> -  DBG(("%p after fd=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc, nc->sock, nc->flags,
> -       (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
> +  return c;
>   }
>   
> -/* Associate a socket to a connection. */
> -void mg_sl_if_sock_set(struct mg_connection *nc, sock_t sock) {
> -  mg_set_non_blocking_mode(sock);
> -  nc->sock = sock;
> -  DBG(("%p %d", nc, sock));
> +static void accept_conn(struct mg_mgr *mgr, struct mg_connection *lsn) {
> +  struct mg_connection *c = NULL;
> +  union usa usa;
> +  socklen_t sa_len = sizeof(usa);
> +  SOCKET fd = accept(FD(lsn), &usa.sa, &sa_len);
> +  if (fd == INVALID_SOCKET) {
> +#if MG_ARCH == MG_ARCH_AZURERTOS
> +  // AzureRTOS, in non-block socket mode can mark listening socket readable
> +  // even it is not. See comment for 'select' func implementation in nx_bsd.c
> +  // That's not an error, just should try later
> +	if (MG_SOCK_ERRNO != EAGAIN)
> +#endif
> +    LOG(LL_ERROR, ("%lu accept failed, errno %d", lsn->id, MG_SOCK_ERRNO));
> +#if (!defined(_WIN32) && (MG_ARCH != MG_ARCH_FREERTOS_TCP))
> +  } else if ((long) fd >= FD_SETSIZE) {
> +    LOG(LL_ERROR, ("%ld > %ld", (long) fd, (long) FD_SETSIZE));
> +    closesocket(fd);
> +#endif
> +  } else if ((c = alloc_conn(mgr, 0, fd)) == NULL) {
> +    LOG(LL_ERROR, ("%lu OOM", lsn->id));
> +    closesocket(fd);
> +  } else {
> +    char buf[40];
> +    tomgaddr(&usa, &c->peer, sa_len != sizeof(usa.sin));
> +    mg_straddr(c, buf, sizeof(buf));
> +    LOG(LL_DEBUG, ("%lu accepted %s", c->id, buf));
> +    mg_set_non_blocking_mode(FD(c));
> +    setsockopts(c);
> +    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
> +    c->is_accepted = 1;
> +    c->is_hexdumping = lsn->is_hexdumping;
> +    c->pfn = lsn->pfn;
> +    c->pfn_data = lsn->pfn_data;
> +    c->fn = lsn->fn;
> +    c->fn_data = lsn->fn_data;
> +    mg_call(c, MG_EV_ACCEPT, NULL);
> +  }
> +}
> +
> +static bool mg_socketpair(SOCKET sp[2], union usa usa[2]) {
> +  socklen_t n = sizeof(usa[0].sin);
> +  bool result = false;
> +
> +  (void) memset(&usa[0], 0, sizeof(usa[0]));
> +  usa[0].sin.sin_family = AF_INET;
> +  *(uint32_t *) &usa->sin.sin_addr = mg_htonl(0x7f000001);  // 127.0.0.1
> +  usa[1] = usa[0];
> +
> +  if ((sp[0] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET &&
> +      (sp[1] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET &&
> +      bind(sp[0], &usa[0].sa, n) == 0 && bind(sp[1], &usa[1].sa, n) == 0 &&
> +      getsockname(sp[0], &usa[0].sa, &n) == 0 &&
> +      getsockname(sp[1], &usa[1].sa, &n) == 0 &&
> +      connect(sp[0], &usa[1].sa, n) == 0 &&
> +      connect(sp[1], &usa[0].sa, n) == 0) {
> +    mg_set_non_blocking_mode(sp[1]);  // Set close-on-exec
> +    result = true;
> +  } else {
> +    if (sp[0] != INVALID_SOCKET) closesocket(sp[0]);
> +    if (sp[1] != INVALID_SOCKET) closesocket(sp[1]);
> +    sp[0] = sp[1] = INVALID_SOCKET;
> +  }
> +
> +  return result;
>   }
>   
> -void mg_sl_if_init(struct mg_iface *iface) {
> -  (void) iface;
> -  DBG(("%p using sl_Select()", iface->mgr));
> +void mg_mgr_wakeup(struct mg_connection *c) {
> +  LOG(LL_INFO, ("skt: %p", c->pfn_data));
> +  send((SOCKET) (size_t) c->pfn_data, "\x01", 1, MSG_NONBLOCKING);
>   }
>   
> -void mg_sl_if_free(struct mg_iface *iface) {
> -  (void) iface;
> +static void pf1(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
> +  if (ev == MG_EV_READ) mg_iobuf_free(&c->recv);
> +  (void) ev_data, (void) fn_data;
>   }
>   
> -void mg_sl_if_add_conn(struct mg_connection *nc) {
> -  (void) nc;
> +struct mg_connection *mg_mkpipe(struct mg_mgr *mgr, mg_event_handler_t fn,
> +                                void *fn_data) {
> +  union usa usa[2];
> +  SOCKET sp[2] = {INVALID_SOCKET, INVALID_SOCKET};
> +  struct mg_connection *c = NULL;
> +  if (!mg_socketpair(sp, usa)) {
> +    LOG(LL_ERROR, ("Cannot create socket pair"));
> +  } else if ((c = alloc_conn(mgr, false, sp[1])) == NULL) {
> +    closesocket(sp[0]);
> +    closesocket(sp[1]);
> +    LOG(LL_ERROR, ("OOM"));
> +  } else {
> +    LOG(LL_INFO, ("pipe %lu", (unsigned long) sp[0]));
> +    tomgaddr(&usa[0], &c->peer, false);
> +    c->is_udp = 1;
> +    c->pfn = pf1;
> +    c->pfn_data = (void *) (size_t) sp[0];
> +    c->fn = fn;
> +    c->fn_data = fn_data;
> +    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
> +  }
> +  return c;
>   }
>   
> -void mg_sl_if_remove_conn(struct mg_connection *nc) {
> -  (void) nc;
> +struct mg_connection *mg_listen(struct mg_mgr *mgr, const char *url,
> +                                mg_event_handler_t fn, void *fn_data) {
> +  struct mg_connection *c = NULL;
> +  bool is_udp = strncmp(url, "udp:", 4) == 0;
> +  struct mg_addr addr;
> +  SOCKET fd = mg_open_listener(url, &addr);
> +  if (fd == INVALID_SOCKET) {
> +    LOG(LL_ERROR, ("Failed: %s, errno %d", url, MG_SOCK_ERRNO));
> +  } else if ((c = alloc_conn(mgr, 0, fd)) == NULL) {
> +    LOG(LL_ERROR, ("OOM %s", url));
> +    closesocket(fd);
> +  } else {
> +    memcpy(&c->peer, &addr, sizeof(struct mg_addr));
> +    c->fd = S2PTR(fd);
> +    c->is_listening = 1;
> +    c->is_udp = is_udp;
> +    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
> +    c->fn = fn;
> +    c->fn_data = fn_data;
> +    LOG(LL_INFO,
> +        ("%lu accepting on %s (port %u)", c->id, url, mg_ntohs(c->peer.port)));
> +  }
> +  return c;
>   }
>   
> -time_t mg_sl_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  struct mg_mgr *mgr = iface->mgr;
> -  double now = mg_time();
> -  double min_timer;
> -  struct mg_connection *nc, *tmp;
> -  struct SlTimeval_t tv;
> -  SlFdSet_t read_set, write_set, err_set;
> -  sock_t max_fd = INVALID_SOCKET;
> -  int num_fds, num_ev = 0, num_timers = 0;
> +static void mg_iotest(struct mg_mgr *mgr, int ms) {
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP
> +  struct mg_connection *c;
> +  for (c = mgr->conns; c != NULL; c = c->next) {
> +    if (c->is_closing || c->is_resolving || FD(c) == INVALID_SOCKET) continue;
> +    FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_READ | eSELECT_EXCEPT);
> +    if (c->is_connecting || (c->send.len > 0 && c->is_tls_hs == 0))
> +      FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_WRITE);
> +  }
> +  FreeRTOS_select(mgr->ss, pdMS_TO_TICKS(ms));
> +  for (c = mgr->conns; c != NULL; c = c->next) {
> +    EventBits_t bits = FreeRTOS_FD_ISSET(c->fd, mgr->ss);
> +    c->is_readable = bits & (eSELECT_READ | eSELECT_EXCEPT) ? 1 : 0;
> +    c->is_writable = bits & eSELECT_WRITE ? 1 : 0;
> +    FreeRTOS_FD_CLR(c->fd, mgr->ss,
> +                    eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE);
> +  }
> +#else
> +  struct timeval tv = {ms / 1000, (ms % 1000) * 1000};
> +  struct mg_connection *c;
> +  fd_set rset, wset;
> +  SOCKET maxfd = 0;
> +  int rc;
>   
> -  SL_SOCKET_FD_ZERO(&read_set);
> -  SL_SOCKET_FD_ZERO(&write_set);
> -  SL_SOCKET_FD_ZERO(&err_set);
> +  FD_ZERO(&rset);
> +  FD_ZERO(&wset);
>   
> -  /*
> -   * Note: it is ok to have connections with sock == INVALID_SOCKET in the list,
> -   * e.g. timer-only "connections".
> -   */
> -  min_timer = 0;
> -  for (nc = mgr->active_connections, num_fds = 0; nc != NULL; nc = tmp) {
> -    tmp = nc->next;
> -
> -    if (nc->sock != INVALID_SOCKET) {
> -      num_fds++;
> -
> -      if (!(nc->flags & MG_F_WANT_WRITE) &&
> -          nc->recv_mbuf.len < nc->recv_mbuf_limit &&
> -          (!(nc->flags & MG_F_UDP) || nc->listener == NULL)) {
> -        SL_SOCKET_FD_SET(nc->sock, &read_set);
> -        if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock;
> -      }
> +  for (c = mgr->conns; c != NULL; c = c->next) {
> +    if (c->is_closing || c->is_resolving || FD(c) == INVALID_SOCKET) continue;
> +    FD_SET(FD(c), &rset);
> +    if (FD(c) > maxfd) maxfd = FD(c);
> +    if (c->is_connecting || (c->send.len > 0 && c->is_tls_hs == 0))
> +      FD_SET(FD(c), &wset);
> +  }
>   
> -      if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) ||
> -          (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) {
> -        SL_SOCKET_FD_SET(nc->sock, &write_set);
> -        SL_SOCKET_FD_SET(nc->sock, &err_set);
> -        if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock;
> -      }
> -    }
> +  if ((rc = select((int) maxfd + 1, &rset, &wset, NULL, &tv)) < 0) {
> +    LOG(LL_DEBUG, ("select: %d %d", rc, MG_SOCK_ERRNO));
> +    FD_ZERO(&rset);
> +    FD_ZERO(&wset);
> +  }
>   
> -    if (nc->ev_timer_time > 0) {
> -      if (num_timers == 0 || nc->ev_timer_time < min_timer) {
> -        min_timer = nc->ev_timer_time;
> -      }
> -      num_timers++;
> -    }
> +  for (c = mgr->conns; c != NULL; c = c->next) {
> +    // TLS might have stuff buffered, so dig everything
> +    c->is_readable = c->is_tls && c->is_readable
> +                         ? 1
> +                         : FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &rset);
> +    c->is_writable = FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &wset);
>     }
> +#endif
> +}
>   
> -  /*
> -   * If there is a timer to be fired earlier than the requested timeout,
> -   * adjust the timeout.
> -   */
> -  if (num_timers > 0) {
> -    double timer_timeout_ms = (min_timer - mg_time()) * 1000 + 1 /* rounding */;
> -    if (timer_timeout_ms < timeout_ms) {
> -      timeout_ms = timer_timeout_ms;
> +static void connect_conn(struct mg_connection *c) {
> +  int rc = 0;
> +#if MG_ARCH != MG_ARCH_FREERTOS_TCP
> +  socklen_t len = sizeof(rc);
> +  if (getsockopt(FD(c), SOL_SOCKET, SO_ERROR, (char *) &rc, &len)) rc = 1;
> +#endif
> +  if (rc == EAGAIN || rc == EWOULDBLOCK) rc = 0;
> +  c->is_connecting = 0;
> +  if (rc) {
> +    char buf[40];
> +    mg_error(c, "error connecting to %s", mg_straddr(c, buf, sizeof(buf)));
> +  } else {
> +    if (c->is_tls_hs) mg_tls_handshake(c);
> +    mg_call(c, MG_EV_CONNECT, NULL);
> +  }
> +}
> +
> +void mg_mgr_poll(struct mg_mgr *mgr, int ms) {
> +  struct mg_connection *c, *tmp;
> +  unsigned long now;
> +
> +  mg_iotest(mgr, ms);
> +  now = mg_millis();
> +  mg_timer_poll(now);
> +
> +  for (c = mgr->conns; c != NULL; c = tmp) {
> +    tmp = c->next;
> +    mg_call(c, MG_EV_POLL, &now);
> +    LOG(LL_VERBOSE_DEBUG,
> +        ("%lu %c%c %c%c%c%c%c", c->id, c->is_readable ? 'r' : '-',
> +         c->is_writable ? 'w' : '-', c->is_tls ? 'T' : 't',
> +         c->is_connecting ? 'C' : 'c', c->is_tls_hs ? 'H' : 'h',
> +         c->is_resolving ? 'R' : 'r', c->is_closing ? 'C' : 'c'));
> +    if (c->is_resolving || c->is_closing) {
> +      // Do nothing
> +    } else if (c->is_listening && c->is_udp == 0) {
> +      if (c->is_readable) accept_conn(mgr, c);
> +    } else if (c->is_connecting) {
> +      if (c->is_readable || c->is_writable) connect_conn(c);
> +    } else if (c->is_tls_hs) {
> +      if ((c->is_readable || c->is_writable)) mg_tls_handshake(c);
> +    } else {
> +      if (c->is_readable) read_conn(c);
> +      if (c->is_writable) write_conn(c);
>       }
> +
> +    if (c->is_draining && c->send.len == 0) c->is_closing = 1;
> +    if (c->is_closing) close_conn(c);
>     }
> -  if (timeout_ms < 0) timeout_ms = 0;
> +}
> +#endif
>   
> -  tv.tv_sec = timeout_ms / 1000;
> -  tv.tv_usec = (timeout_ms % 1000) * 1000;
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/ssi.c"
> +#endif
>   
> -  if (num_fds > 0) {
> -    num_ev = sl_Select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv);
> -  }
>   
> -  now = mg_time();
> -  DBG(("sl_Select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev,
> -       num_fds, timeout_ms));
>   
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    int fd_flags = 0;
> -    if (nc->sock != INVALID_SOCKET) {
> -      if (num_ev > 0) {
> -        fd_flags =
> -            (SL_SOCKET_FD_ISSET(nc->sock, &read_set) &&
> -                     (!(nc->flags & MG_F_UDP) || nc->listener == NULL)
> -                 ? _MG_F_FD_CAN_READ
> -                 : 0) |
> -            (SL_SOCKET_FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE
> -                                                      : 0) |
> -            (SL_SOCKET_FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0);
> -      }
> -      /* SimpleLink does not report UDP sockets as writable. */
> -      if (nc->flags & MG_F_UDP && nc->send_mbuf.len > 0) {
> -        fd_flags |= _MG_F_FD_CAN_WRITE;
> +
> +#ifndef MG_MAX_SSI_DEPTH
> +#define MG_MAX_SSI_DEPTH 5
> +#endif
> +
> +#if MG_ENABLE_SSI
> +static char *mg_ssi(const char *path, const char *root, int depth) {
> +  struct mg_iobuf b = {NULL, 0, 0};
> +  FILE *fp = fopen(path, "rb");
> +  if (fp != NULL) {
> +    char buf[BUFSIZ], arg[sizeof(buf)];
> +    int ch, intag = 0;
> +    size_t len = 0, align = MG_IO_SIZE;
> +    while ((ch = fgetc(fp)) != EOF) {
> +      if (intag && ch == '>' && buf[len - 1] == '-' && buf[len - 2] == '-') {
> +        buf[len++] = (char) (ch & 0xff);
> +        if (sscanf(buf, "<!--#include file=\"%[^\"]", arg)) {
> +          char tmp[MG_PATH_MAX + BUFSIZ + 10],
> +              *p = (char *) path + strlen(path), *data;
> +          while (p > path && p[-1] != MG_DIRSEP && p[-1] != '/') p--;
> +          snprintf(tmp, sizeof(tmp), "%.*s%s", (int) (p - path), path, arg);
> +          if (depth < MG_MAX_SSI_DEPTH &&
> +              (data = mg_ssi(tmp, root, depth + 1)) != NULL) {
> +            mg_iobuf_add(&b, b.len, data, strlen(data), align);
> +            free(data);
> +          } else {
> +            LOG(LL_ERROR, ("%s: file=%s error or too deep", path, arg));
> +          }
> +        } else if (sscanf(buf, "<!--#include virtual=\"%[^\"]", arg)) {
> +          char tmp[MG_PATH_MAX + BUFSIZ + 10], *data;
> +          snprintf(tmp, sizeof(tmp), "%s%s", root, arg);
> +          if (depth < MG_MAX_SSI_DEPTH &&
> +              (data = mg_ssi(tmp, root, depth + 1)) != NULL) {
> +            mg_iobuf_add(&b, b.len, data, strlen(data), align);
> +            free(data);
> +          } else {
> +            LOG(LL_ERROR, ("%s: virtual=%s error or too deep", path, arg));
> +          }
> +        } else {
> +          // Unknown SSI tag
> +          LOG(LL_INFO, ("Unknown SSI tag: %.*s", (int) len, buf));
> +          mg_iobuf_add(&b, b.len, buf, len, align);
> +        }
> +        intag = 0;
> +        len = 0;
> +      } else if (ch == '<') {
> +        intag = 1;
> +        if (len > 0) mg_iobuf_add(&b, b.len, buf, len, align);
> +        len = 0;
> +        buf[len++] = (char) (ch & 0xff);
> +      } else if (intag) {
> +        if (len == 5 && strncmp(buf, "<!--#", 5) != 0) {
> +          intag = 0;
> +        } else if (len >= sizeof(buf) - 2) {
> +          LOG(LL_ERROR, ("%s: SSI tag is too large", path));
> +          len = 0;
> +        }
> +        buf[len++] = (char) (ch & 0xff);
> +      } else {
> +        buf[len++] = (char) (ch & 0xff);
> +        if (len >= sizeof(buf)) {
> +          mg_iobuf_add(&b, b.len, buf, len, align);
> +          len = 0;
> +        }
>         }
>       }
> -    tmp = nc->next;
> -    mg_mgr_handle_conn(nc, fd_flags, now);
> +    if (len > 0) mg_iobuf_add(&b, b.len, buf, len, align);
> +    if (b.len > 0) mg_iobuf_add(&b, b.len, "", 1, align);  // nul-terminate
> +    fclose(fp);
>     }
> -
> -  return now;
> +  (void) depth;
> +  (void) root;
> +  return (char *) b.buf;
>   }
>   
> -void mg_sl_if_get_conn_addr(struct mg_connection *nc, int remote,
> -                            union socket_address *sa) {
> -  /* SimpleLink does not provide a way to get socket's peer address after
> -   * accept or connect. Address should have been preserved in the connection,
> -   * so we do our best here by using it. */
> -  if (remote) memcpy(sa, &nc->sa, sizeof(*sa));
> +void mg_http_serve_ssi(struct mg_connection *c, const char *root,
> +                       const char *fullpath) {
> +  const char *headers = "Content-Type: text/html; charset=utf-8\r\n";
> +  char *data = mg_ssi(fullpath, root, 0);
> +  mg_http_reply(c, 200, headers, "%s", data == NULL ? "" : data);
> +  free(data);
> +}
> +#else
> +void mg_http_serve_ssi(struct mg_connection *c, const char *root,
> +                       const char *fullpath) {
> +  mg_http_reply(c, 501, NULL, "SSI not enabled");
> +  (void) root, (void) fullpath;
>   }
> -
> -void sl_restart_cb(struct mg_mgr *mgr) {
> -  /*
> -   * SimpleLink has been restarted, meaning all sockets have been invalidated.
> -   * We try our best - we'll restart the listeners, but for outgoing
> -   * connections we have no option but to terminate.
> -   */
> -  struct mg_connection *nc;
> -  for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
> -    if (nc->sock == INVALID_SOCKET) continue; /* Could be a timer */
> -    if (nc->flags & MG_F_LISTENING) {
> -      DBG(("restarting %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr),
> -           ntohs(nc->sa.sin.sin_port)));
> -      int res = (nc->flags & MG_F_UDP ? mg_sl_if_listen_udp(nc, &nc->sa)
> -                                      : mg_sl_if_listen_tcp(nc, &nc->sa));
> -      if (res == 0) continue;
> -      /* Well, we tried and failed. Fall through to closing. */
> -    }
> -    nc->sock = INVALID_SOCKET;
> -    DBG(("terminating %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr),
> -         ntohs(nc->sa.sin.sin_port)));
> -    /* TODO(rojer): Outgoing UDP? */
> -    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -  }
> -}
> -
> -/* clang-format off */
> -#define MG_SL_IFACE_VTABLE                                              \
> -  {                                                                     \
> -    mg_sl_if_init,                                                      \
> -    mg_sl_if_free,                                                      \
> -    mg_sl_if_add_conn,                                                  \
> -    mg_sl_if_remove_conn,                                               \
> -    mg_sl_if_poll,                                                      \
> -    mg_sl_if_listen_tcp,                                                \
> -    mg_sl_if_listen_udp,                                                \
> -    mg_sl_if_connect_tcp,                                               \
> -    mg_sl_if_connect_udp,                                               \
> -    mg_sl_if_tcp_send,                                                  \
> -    mg_sl_if_udp_send,                                                  \
> -    mg_sl_if_tcp_recv,                                                  \
> -    mg_sl_if_udp_recv,                                                  \
> -    mg_sl_if_create_conn,                                               \
> -    mg_sl_if_destroy_conn,                                              \
> -    mg_sl_if_sock_set,                                                  \
> -    mg_sl_if_get_conn_addr,                                             \
> -  }
> -/* clang-format on */
> -
> -const struct mg_iface_vtable mg_simplelink_iface_vtable = MG_SL_IFACE_VTABLE;
> -#if MG_NET_IF == MG_NET_IF_SIMPLELINK
> -const struct mg_iface_vtable mg_default_iface_vtable = MG_SL_IFACE_VTABLE;
> -#endif
> -
> -#endif /* MG_ENABLE_NET_IF_SIMPLELINK */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/sl_ssl_if.c"
>   #endif
>   
> -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
> -
> -/* Amalgamated: #include "common/mg_mem.h" */
> -
> -#ifndef MG_SSL_IF_SIMPLELINK_SLFS_PREFIX
> -#define MG_SSL_IF_SIMPLELINK_SLFS_PREFIX "SL:"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/str.c"
>   #endif
>   
> -#define MG_SSL_IF_SIMPLELINK_SLFS_PREFIX_LEN \
> -  (sizeof(MG_SSL_IF_SIMPLELINK_SLFS_PREFIX) - 1)
> +#include <stdlib.h>
>   
> -struct mg_ssl_if_ctx {
> -  char *ssl_cert;
> -  char *ssl_key;
> -  char *ssl_ca_cert;
> -  char *ssl_server_name;
> -};
> +struct mg_str mg_str_s(const char *s) {
> +  struct mg_str str = {s, s == NULL ? 0 : strlen(s)};
> +  return str;
> +}
>   
> -void mg_ssl_if_init(void) {
> +struct mg_str mg_str_n(const char *s, size_t n) {
> +  struct mg_str str = {s, n};
> +  return str;
>   }
>   
> -enum mg_ssl_if_result mg_ssl_if_conn_init(
> -    struct mg_connection *nc, const struct mg_ssl_if_conn_params *params,
> -    const char **err_msg) {
> -  struct mg_ssl_if_ctx *ctx =
> -      (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx));
> -  if (ctx == NULL) {
> -    MG_SET_PTRPTR(err_msg, "Out of memory");
> -    return MG_SSL_ERROR;
> -  }
> -  nc->ssl_if_data = ctx;
> +int mg_lower(const char *s) {
> +  return tolower(*(const unsigned char *) s);
> +}
>   
> -  if (params->cert != NULL || params->key != NULL) {
> -    if (params->cert != NULL && params->key != NULL) {
> -      ctx->ssl_cert = strdup(params->cert);
> -      ctx->ssl_key = strdup(params->key);
> -    } else {
> -      MG_SET_PTRPTR(err_msg, "Both cert and key are required.");
> -      return MG_SSL_ERROR;
> -    }
> -  }
> -  if (params->ca_cert != NULL && strcmp(params->ca_cert, "*") != 0) {
> -    ctx->ssl_ca_cert = strdup(params->ca_cert);
> -  }
> -  /* TODO(rojer): cipher_suites. */
> -  if (params->server_name != NULL) {
> -    ctx->ssl_server_name = strdup(params->server_name);
> -  }
> -  return MG_SSL_OK;
> +int mg_ncasecmp(const char *s1, const char *s2, size_t len) {
> +  int diff = 0;
> +  if (len > 0) do {
> +      diff = mg_lower(s1++) - mg_lower(s2++);
> +    } while (diff == 0 && s1[-1] != '\0' && --len > 0);
> +  return diff;
>   }
>   
> -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc,
> -                                            struct mg_connection *lc) {
> -  /* SimpleLink does everything for us, nothing for us to do. */
> -  (void) nc;
> -  (void) lc;
> -  return MG_SSL_OK;
> +int mg_casecmp(const char *s1, const char *s2) {
> +  return mg_ncasecmp(s1, s2, (size_t) ~0);
>   }
>   
> -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc) {
> -  /* SimpleLink has already performed the handshake, nothing to do. */
> -  return MG_SSL_OK;
> +int mg_vcmp(const struct mg_str *s1, const char *s2) {
> +  size_t n2 = strlen(s2), n1 = s1->len;
> +  int r = strncmp(s1->ptr, s2, (n1 < n2) ? n1 : n2);
> +  if (r == 0) return (int) (n1 - n2);
> +  return r;
>   }
>   
> -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t len) {
> -  /* SimpelLink handles TLS, so this is just a pass-through. */
> -  int n = nc->iface->vtable->tcp_recv(nc, buf, len);
> -  if (n == 0) nc->flags |= MG_F_WANT_READ;
> -  return n;
> +int mg_vcasecmp(const struct mg_str *str1, const char *str2) {
> +  size_t n2 = strlen(str2), n1 = str1->len;
> +  int r = mg_ncasecmp(str1->ptr, str2, (n1 < n2) ? n1 : n2);
> +  if (r == 0) return (int) (n1 - n2);
> +  return r;
>   }
>   
> -int mg_ssl_if_write(struct mg_connection *nc, const void *buf, size_t len) {
> -  /* SimpelLink handles TLS, so this is just a pass-through. */
> -  return nc->iface->vtable->tcp_send(nc, buf, len);
> -}
> -
> -void mg_ssl_if_conn_close_notify(struct mg_connection *nc) {
> -  /* Nothing to do */
> -  (void) nc;
> -}
> -
> -void mg_ssl_if_conn_free(struct mg_connection *nc) {
> -  struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  if (ctx == NULL) return;
> -  nc->ssl_if_data = NULL;
> -  MG_FREE(ctx->ssl_cert);
> -  MG_FREE(ctx->ssl_key);
> -  MG_FREE(ctx->ssl_ca_cert);
> -  MG_FREE(ctx->ssl_server_name);
> -  memset(ctx, 0, sizeof(*ctx));
> -  MG_FREE(ctx);
> -}
> -
> -bool pem_to_der(const char *pem_file, const char *der_file) {
> -  bool ret = false;
> -  FILE *pf = NULL, *df = NULL;
> -  bool writing = false;
> -  pf = fopen(pem_file, "r");
> -  if (pf == NULL) goto clean;
> -  remove(der_file);
> -  fs_slfs_set_file_size(der_file + MG_SSL_IF_SIMPLELINK_SLFS_PREFIX_LEN, 2048);
> -  df = fopen(der_file, "w");
> -  fs_slfs_unset_file_flags(der_file + MG_SSL_IF_SIMPLELINK_SLFS_PREFIX_LEN);
> -  if (df == NULL) goto clean;
> -  while (1) {
> -    char pem_buf[70];
> -    char der_buf[48];
> -    if (!fgets(pem_buf, sizeof(pem_buf), pf)) break;
> -    if (writing) {
> -      if (strstr(pem_buf, "-----END ") != NULL) {
> -        ret = true;
> -        break;
> -      }
> -      int l = 0;
> -      while (!isspace((unsigned int) pem_buf[l])) l++;
> -      int der_len = 0;
> -      cs_base64_decode((const unsigned char *) pem_buf, sizeof(pem_buf),
> -                       der_buf, &der_len);
> -      if (der_len <= 0) break;
> -      if (fwrite(der_buf, 1, der_len, df) != der_len) break;
> -    } else if (strstr(pem_buf, "-----BEGIN ") != NULL) {
> -      writing = true;
> +struct mg_str mg_strdup(const struct mg_str s) {
> +  struct mg_str r = {NULL, 0};
> +  if (s.len > 0 && s.ptr != NULL) {
> +    char *sc = (char *) calloc(1, s.len + 1);
> +    if (sc != NULL) {
> +      memcpy(sc, s.ptr, s.len);
> +      sc[s.len] = '\0';
> +      r.ptr = sc;
> +      r.len = s.len;
>       }
>     }
> -
> -clean:
> -  if (pf != NULL) fclose(pf);
> -  if (df != NULL) {
> -    fclose(df);
> -    if (!ret) remove(der_file);
> -  }
> -  return ret;
> +  return r;
>   }
>   
> -#if MG_ENABLE_FILESYSTEM && defined(MG_FS_SLFS)
> -/* If the file's extension is .pem, convert it to DER format and put on SLFS. */
> -static char *sl_pem2der(const char *pem_file) {
> -  const char *pem_ext = strstr(pem_file, ".pem");
> -  if (pem_ext == NULL || *(pem_ext + 4) != '\0') {
> -    return strdup(pem_file);
> -  }
> -  char *der_file = NULL;
> -  /* DER file must be located on SLFS, add prefix. */
> -  int l = mg_asprintf(&der_file, 0, MG_SSL_IF_SIMPLELINK_SLFS_PREFIX "%.*s.der",
> -                      (int) (pem_ext - pem_file), pem_file);
> -  if (der_file == NULL) return NULL;
> -  bool result = false;
> -  cs_stat_t st;
> -  if (mg_stat(der_file, &st) != 0) {
> -    result = pem_to_der(pem_file, der_file);
> -    LOG(LL_DEBUG, ("%s -> %s = %d", pem_file, der_file, result));
> -  } else {
> -    /* File exists, assume it's already been converted. */
> -    result = true;
> -  }
> -  if (result) {
> -    /* Strip the SL: prefix we added since NWP does not expect it. */
> -    memmove(der_file, der_file + MG_SSL_IF_SIMPLELINK_SLFS_PREFIX_LEN,
> -            l - 2 /* including \0 */);
> -  } else {
> -    MG_FREE(der_file);
> -    der_file = NULL;
> +int mg_strcmp(const struct mg_str str1, const struct mg_str str2) {
> +  size_t i = 0;
> +  while (i < str1.len && i < str2.len) {
> +    int c1 = str1.ptr[i];
> +    int c2 = str2.ptr[i];
> +    if (c1 < c2) return -1;
> +    if (c1 > c2) return 1;
> +    i++;
>     }
> -  return der_file;
> -}
> -#else
> -static char *sl_pem2der(const char *pem_file) {
> -  return strdup(pem_file);
> +  if (i < str1.len) return 1;
> +  if (i < str2.len) return -1;
> +  return 0;
>   }
> -#endif
>   
> -int sl_set_ssl_opts(int sock, struct mg_connection *nc) {
> -  int err;
> -  const struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data;
> -  DBG(("%p ssl ctx: %p", nc, ctx));
> -
> -  if (ctx == NULL) return 0;
> -  DBG(("%p %s,%s,%s,%s", nc, (ctx->ssl_cert ? ctx->ssl_cert : "-"),
> -       (ctx->ssl_key ? ctx->ssl_cert : "-"),
> -       (ctx->ssl_ca_cert ? ctx->ssl_ca_cert : "-"),
> -       (ctx->ssl_server_name ? ctx->ssl_server_name : "-")));
> -  if (ctx->ssl_cert != NULL && ctx->ssl_key != NULL) {
> -    char *ssl_cert = sl_pem2der(ctx->ssl_cert), *ssl_key = NULL;
> -    if (ssl_cert != NULL) {
> -      err = sl_SetSockOpt(sock, SL_SOL_SOCKET,
> -                          SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME, ssl_cert,
> -                          strlen(ssl_cert));
> -      MG_FREE(ssl_cert);
> -      LOG(LL_DEBUG, ("CERTIFICATE_FILE_NAME %s -> %d", ssl_cert, err));
> -      ssl_key = sl_pem2der(ctx->ssl_key);
> -      if (ssl_key != NULL) {
> -        err = sl_SetSockOpt(sock, SL_SOL_SOCKET,
> -                            SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME, ssl_key,
> -                            strlen(ssl_key));
> -        MG_FREE(ssl_key);
> -        LOG(LL_DEBUG, ("PRIVATE_KEY_FILE_NAME %s -> %d", ssl_key, err));
> -      } else {
> -        err = -1;
> -      }
> -    } else {
> -      err = -1;
> -    }
> -    if (err != 0) return err;
> -  }
> -  if (ctx->ssl_ca_cert != NULL) {
> -    if (ctx->ssl_ca_cert[0] != '\0') {
> -      char *ssl_ca_cert = sl_pem2der(ctx->ssl_ca_cert);
> -      if (ssl_ca_cert != NULL) {
> -        err =
> -            sl_SetSockOpt(sock, SL_SOL_SOCKET, SL_SO_SECURE_FILES_CA_FILE_NAME,
> -                          ssl_ca_cert, strlen(ssl_ca_cert));
> -        LOG(LL_DEBUG, ("CA_FILE_NAME %s -> %d", ssl_ca_cert, err));
> -      } else {
> -        err = -1;
> -      }
> -      MG_FREE(ssl_ca_cert);
> -      if (err != 0) return err;
> +const char *mg_strstr(const struct mg_str haystack,
> +                      const struct mg_str needle) {
> +  size_t i;
> +  if (needle.len > haystack.len) return NULL;
> +  for (i = 0; i <= haystack.len - needle.len; i++) {
> +    if (memcmp(haystack.ptr + i, needle.ptr, needle.len) == 0) {
> +      return haystack.ptr + i;
>       }
>     }
> -  if (ctx->ssl_server_name != NULL) {
> -    err = sl_SetSockOpt(sock, SL_SOL_SOCKET,
> -                        SL_SO_SECURE_DOMAIN_NAME_VERIFICATION,
> -                        ctx->ssl_server_name, strlen(ctx->ssl_server_name));
> -    DBG(("DOMAIN_NAME_VERIFICATION %s -> %d", ctx->ssl_server_name, err));
> -    /* Domain name verificationw as added in a NWP service pack, older
> -     * versions return SL_ERROR_BSD_ENOPROTOOPT. There isn't much we can do
> -     * about it,
> -     * so we ignore the error. */
> -    if (err != 0 && err != SL_ERROR_BSD_ENOPROTOOPT) return err;
> -  }
> -  return 0;
> +  return NULL;
>   }
>   
> -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/lwip/mg_lwip_net_if.h"
> +struct mg_str mg_strstrip(struct mg_str s) {
> +  while (s.len > 0 && isspace((int) *s.ptr)) s.ptr++, s.len--;
> +  while (s.len > 0 && isspace((int) *(s.ptr + s.len - 1))) s.len--;
> +  return s;
> +}
> +
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/timer.c"
>   #endif
> +// Copyright (c) Cesanta Software Limited
> +// All rights reserved
>   
> -#ifndef CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_
> -#define CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_
>   
> -#ifndef MG_ENABLE_NET_IF_LWIP_LOW_LEVEL
> -#define MG_ENABLE_NET_IF_LWIP_LOW_LEVEL MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL
> -#endif
>   
> -#if MG_ENABLE_NET_IF_LWIP_LOW_LEVEL
> -
> -#include <stdint.h>
> -
> -extern const struct mg_iface_vtable mg_lwip_iface_vtable;
> -
> -struct mg_lwip_conn_state {
> -  struct mg_connection *nc;
> -  struct mg_connection *lc;
> -  union {
> -    struct tcp_pcb *tcp;
> -    struct udp_pcb *udp;
> -  } pcb;
> -  err_t err;
> -  size_t num_sent; /* Number of acknowledged bytes to be reported to the core */
> -  struct pbuf *rx_chain; /* Chain of incoming data segments. */
> -  size_t rx_offset; /* Offset within the first pbuf (if partially consumed) */
> -  /* Last SSL write size, for retries. */
> -  int last_ssl_write_size;
> -  /* Whether MG_SIG_RECV is already pending for this connection */
> -  int recv_pending;
> -  /* Whether the connection is about to close, just `rx_chain` needs to drain */
> -  int draining_rx_chain;
> -};
>   
> -enum mg_sig_type {
> -  MG_SIG_CONNECT_RESULT = 1,
> -  MG_SIG_RECV = 2,
> -  MG_SIG_CLOSE_CONN = 3,
> -  MG_SIG_TOMBSTONE = 4,
> -  MG_SIG_ACCEPT = 5,
> -};
> +struct mg_timer *g_timers;
> +
> +void mg_timer_init(struct mg_timer *t, unsigned long ms, unsigned flags,
> +                   void (*fn)(void *), void *arg) {
> +  struct mg_timer tmp = {ms, flags, fn, arg, 0UL, g_timers};
> +  *t = tmp;
> +  g_timers = t;
> +  if (flags & MG_TIMER_RUN_NOW) fn(arg);
> +}
>   
> -void mg_lwip_post_signal(enum mg_sig_type sig, struct mg_connection *nc);
> +void mg_timer_free(struct mg_timer *t) {
> +  struct mg_timer **head = &g_timers;
> +  while (*head && *head != t) head = &(*head)->next;
> +  if (*head) *head = t->next;
> +}
>   
> -/* To be implemented by the platform. */
> -void mg_lwip_mgr_schedule_poll(struct mg_mgr *mgr);
> +void mg_timer_poll(unsigned long now_ms) {
> +  // If time goes back (wrapped around), reset timers
> +  struct mg_timer *t, *tmp;
> +  static unsigned long oldnow;  // Timestamp in a previous invocation
> +  if (oldnow > now_ms) {        // If it is wrapped, reset timers
> +    for (t = g_timers; t != NULL; t = t->next) t->expire = 0;
> +  }
> +  oldnow = now_ms;
>   
> -#endif /* MG_ENABLE_NET_IF_LWIP_LOW_LEVEL */
> +  for (t = g_timers; t != NULL; t = tmp) {
> +    tmp = t->next;
> +    if (t->expire == 0) t->expire = now_ms + t->period_ms;
> +    if (t->expire > now_ms) continue;
> +    t->fn(t->arg);
> +    // Try to tick timers with the given period as accurate as possible,
> +    // even if this polling function is called with some random period.
> +    t->expire = now_ms - t->expire > (unsigned long) t->period_ms
> +                    ? now_ms + t->period_ms
> +                    : t->expire + t->period_ms;
> +    if (!(t->flags & MG_TIMER_REPEAT)) mg_timer_free(t);
> +  }
> +}
>   
> -#endif /* CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/lwip/mg_lwip_net_if.c"
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/tls.c"
>   #endif
>   
> -#if MG_ENABLE_NET_IF_LWIP_LOW_LEVEL
>   
> -/* Amalgamated: #include "common/mg_mem.h" */
> +#if MG_ENABLE_MBEDTLS  ///////////////////////////////////////// MBEDTLS
>   
> -#include <lwip/init.h>
> -#include <lwip/pbuf.h>
> -#include <lwip/tcp.h>
> -#include <lwip/tcpip.h>
> -#if ((LWIP_VERSION_MAJOR << 8) | LWIP_VERSION_MINOR) >= 0x0105
> -#include <lwip/priv/tcp_priv.h>   /* For tcp_seg */
> -#include <lwip/priv/tcpip_priv.h> /* For tcpip_api_call */
> -#else
> -#include <lwip/tcp_impl.h>
> -#endif
> -#include <lwip/udp.h>
>   
> -/* Amalgamated: #include "common/cs_dbg.h" */
>   
> -/*
> - * Newest versions of LWIP have ip_2_ip4, older have ipX_2_ip,
> - * even older have nothing.
> - */
> -#ifndef ip_2_ip4
> -#ifdef ipX_2_ip
> -#define ip_2_ip4(addr) ipX_2_ip(addr)
> -#else
> -#define ip_2_ip4(addr) (addr)
> -#endif
> -#endif
>   
> -/*
> - * Depending on whether Mongoose is compiled with ipv6 support, use right
> - * lwip functions
> - */
> -#if MG_ENABLE_IPV6
> -#define TCP_NEW tcp_new_ip6
> -#define TCP_BIND tcp_bind_ip6
> -#define UDP_BIND udp_bind_ip6
> -#define IPADDR_NTOA(x) ip6addr_ntoa((const ip6_addr_t *)(x))
> -#define SET_ADDR(dst, src)                               \
> -  memcpy((dst)->sin6.sin6_addr.s6_addr, (src)->ip6.addr, \
> -         sizeof((dst)->sin6.sin6_addr.s6_addr))
> -#else
> -#define TCP_NEW tcp_new
> -#define TCP_BIND tcp_bind
> -#define UDP_BIND udp_bind
> -#define IPADDR_NTOA ipaddr_ntoa
> -#define SET_ADDR(dst, src) (dst)->sin.sin_addr.s_addr = ip_2_ip4(src)->addr
> -#endif
> +#include <mbedtls/debug.h>
> +#include <mbedtls/ssl.h>
>   
> -#if !NO_SYS
> -#if LWIP_TCPIP_CORE_LOCKING
> -/* With locking tcpip_api_call is just a function call wrapped in lock/unlock,
> - * so we can get away with just casting. */
> -void mg_lwip_netif_run_on_tcpip(void (*fn)(void *), void *arg) {
> -  tcpip_api_call((tcpip_api_call_fn) fn, (struct tcpip_api_call_data *) arg);
> -}
> +#ifndef EXTERN_C
> +#ifdef __cplusplus
> +#define EXTERN_C extern "C"
>   #else
> -static sys_sem_t s_tcpip_call_lock_sem = NULL;
> -static sys_sem_t s_tcpip_call_sync_sem = NULL;
> -struct mg_lwip_netif_tcpip_call_ctx {
> -  void (*fn)(void *);
> -  void *arg;
> -};
> -static void xxx_tcpip(void *arg) {
> -  struct mg_lwip_netif_tcpip_call_ctx *ctx =
> -      (struct mg_lwip_netif_tcpip_call_ctx *) arg;
> -  ctx->fn(ctx->arg);
> -  sys_sem_signal(&s_tcpip_call_sync_sem);
> -}
> -void mg_lwip_netif_run_on_tcpip(void (*fn)(void *), void *arg) {
> -  struct mg_lwip_netif_tcpip_call_ctx ctx = {.fn = fn, .arg = arg};
> -  sys_arch_sem_wait(&s_tcpip_call_lock_sem, 0);
> -  tcpip_send_msg_wait_sem(xxx_tcpip, &ctx, &s_tcpip_call_sync_sem);
> -  sys_sem_signal(&s_tcpip_call_lock_sem);
> -}
> +#define EXTERN_C
>   #endif
> -#else
> -#define mg_lwip_netif_run_on_tcpip(fn, arg) (fn)(arg)
>   #endif
>   
> -void mg_lwip_if_init(struct mg_iface *iface);
> -void mg_lwip_if_free(struct mg_iface *iface);
> -void mg_lwip_if_add_conn(struct mg_connection *nc);
> -void mg_lwip_if_remove_conn(struct mg_connection *nc);
> -time_t mg_lwip_if_poll(struct mg_iface *iface, int timeout_ms);
> -
> -// If compiling for Mongoose OS.
> -#ifdef MGOS
> -extern void mgos_lock();
> -extern void mgos_unlock();
> +#if MBEDTLS_VERSION_NUMBER >= 0x03000000
> +#define RNG , rng_get, NULL
>   #else
> -#define mgos_lock()
> -#define mgos_unlock()
> +#define RNG
>   #endif
>   
> -static void mg_lwip_recv_common(struct mg_connection *nc, struct pbuf *p);
> -
> -#if LWIP_TCP_KEEPALIVE
> -void mg_lwip_set_keepalive_params(struct mg_connection *nc, int idle,
> -                                  int interval, int count) {
> -  if (nc->sock == INVALID_SOCKET || nc->flags & MG_F_UDP) {
> -    return;
> -  }
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct tcp_pcb *tpcb = cs->pcb.tcp;
> -  if (idle > 0 && interval > 0 && count > 0) {
> -    tpcb->keep_idle = idle * 1000;
> -    tpcb->keep_intvl = interval * 1000;
> -    tpcb->keep_cnt = count;
> -    tpcb->so_options |= SOF_KEEPALIVE;
> -  } else {
> -    tpcb->so_options &= ~SOF_KEEPALIVE;
> -  }
> -}
> -#elif !defined(MG_NO_LWIP_TCP_KEEPALIVE)
> -#warning LWIP TCP keepalive is disabled. Please consider enabling it.
> -#endif /* LWIP_TCP_KEEPALIVE */
> +// Different versions have those in different files, so declare here
> +EXTERN_C int mbedtls_net_recv(void *, unsigned char *, size_t);
> +EXTERN_C int mbedtls_net_send(void *, const unsigned char *, size_t);
>   
> -static err_t mg_lwip_tcp_conn_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  DBG(("%p connect to %s:%u = %d", nc, IPADDR_NTOA(ipX_2_ip(&tpcb->remote_ip)),
> -       tpcb->remote_port, err));
> -  if (nc == NULL) {
> -    tcp_abort(tpcb);
> -    return ERR_ARG;
> -  }
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  cs->err = err;
> -#if LWIP_TCP_KEEPALIVE
> -  if (err == 0) mg_lwip_set_keepalive_params(nc, 60, 10, 6);
> -#endif
> -  mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
> -  return ERR_OK;
> -}
> -
> -static void mg_lwip_tcp_error_cb(void *arg, err_t err) {
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  DBG(("%p conn error %d", nc, err));
> -  if (nc == NULL || (nc->flags & MG_F_CLOSE_IMMEDIATELY)) return;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  cs->pcb.tcp = NULL; /* Has already been deallocated */
> -  if (nc->flags & MG_F_CONNECTING) {
> -    cs->err = err;
> -    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
> +struct mg_tls {
> +  char *cafile;             // CA certificate path
> +  mbedtls_x509_crt ca;      // Parsed CA certificate
> +  mbedtls_x509_crt cert;    // Parsed certificate
> +  mbedtls_ssl_context ssl;  // SSL/TLS context
> +  mbedtls_ssl_config conf;  // SSL-TLS config
> +  mbedtls_pk_context pk;    // Private key context
> +};
> +
> +void mg_tls_handshake(struct mg_connection *c) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  int rc;
> +  mbedtls_ssl_set_bio(&tls->ssl, &c->fd, mbedtls_net_send, mbedtls_net_recv, 0);
> +  rc = mbedtls_ssl_handshake(&tls->ssl);
> +  if (rc == 0) {  // Success
> +    LOG(LL_DEBUG, ("%lu success", c->id));
> +    c->is_tls_hs = 0;
> +  } else if (rc == MBEDTLS_ERR_SSL_WANT_READ ||
> +             rc == MBEDTLS_ERR_SSL_WANT_WRITE) {  // Still pending
> +    LOG(LL_VERBOSE_DEBUG, ("%lu pending, %d%d %d (-%#x)", c->id,
> +                           c->is_connecting, c->is_tls_hs, rc, -rc));
>     } else {
> -    mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
> -  }
> -}
> -
> -static err_t mg_lwip_tcp_recv_cb(void *arg, struct tcp_pcb *tpcb,
> -                                 struct pbuf *p, err_t err) {
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  struct mg_lwip_conn_state *cs =
> -      (nc ? (struct mg_lwip_conn_state *) nc->sock : NULL);
> -  DBG(("%p %p %p %p %u %d", nc, cs, tpcb, p, (p != NULL ? p->tot_len : 0),
> -       err));
> -  if (p == NULL) {
> -    if (nc != NULL && !(nc->flags & MG_F_CLOSE_IMMEDIATELY)) {
> -      if (cs->rx_chain != NULL) {
> -        /*
> -         * rx_chain still contains non-consumed data, don't close the
> -         * connection
> -         */
> -        cs->draining_rx_chain = 1;
> -      } else {
> -        mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
> -      }
> -    } else {
> -      /* Tombstoned connection, do nothing. */
> -    }
> -    return ERR_OK;
> -  } else if (nc == NULL) {
> -    tcp_abort(tpcb);
> -    return ERR_ARG;
> -  }
> -  /*
> -   * If we get a chain of more than one segment at once, we need to bump
> -   * refcount on the subsequent bufs to make them independent.
> -   */
> -  if (p->next != NULL) {
> -    struct pbuf *q = p->next;
> -    for (; q != NULL; q = q->next) pbuf_ref(q);
> -  }
> -  mgos_lock();
> -  if (cs->rx_chain == NULL) {
> -    cs->rx_offset = 0;
> -  } else if (pbuf_clen(cs->rx_chain) >= 4) {
> -    /* ESP SDK has a limited pool of 5 pbufs. We must not hog them all or RX
> -     * will be completely blocked. We already have at least 4 in the chain,
> -     * this one is the last, so we have to make a copy and release this one. */
> -    struct pbuf *np = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
> -    if (np != NULL) {
> -      pbuf_copy(np, p);
> -      pbuf_free(p);
> -      p = np;
> -    }
> +    mg_error(c, "TLS handshake: -%#x", -rc);  // Error
>     }
> -  mg_lwip_recv_common(nc, p);
> -  mgos_unlock();
> -  (void) err;
> -  return ERR_OK;
>   }
>   
> -static err_t mg_lwip_tcp_sent_cb(void *arg, struct tcp_pcb *tpcb,
> -                                 u16_t num_sent) {
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  DBG(("%p %p %u %p %p", nc, tpcb, num_sent, tpcb->unsent, tpcb->unacked));
> -  if (nc == NULL) return ERR_OK;
> -  if ((nc->flags & MG_F_SEND_AND_CLOSE) && !(nc->flags & MG_F_WANT_WRITE) &&
> -      nc->send_mbuf.len == 0 && tpcb->unsent == NULL && tpcb->unacked == NULL) {
> -    mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
> -  }
> -  if (nc->send_mbuf.len > 0 || (nc->flags & MG_F_WANT_WRITE)) {
> -    mg_lwip_mgr_schedule_poll(nc->mgr);
> -  }
> -  (void) num_sent;
> -  return ERR_OK;
> +static int mbed_rng(void *ctx, unsigned char *buf, size_t len) {
> +  mg_random(buf, len);
> +  (void) ctx;
> +  return 0;
>   }
>   
> -struct mg_lwip_if_connect_tcp_ctx {
> -  struct mg_connection *nc;
> -  const union socket_address *sa;
> -};
> -
> -static void mg_lwip_if_connect_tcp_tcpip(void *arg) {
> -  struct mg_lwip_if_connect_tcp_ctx *ctx =
> -      (struct mg_lwip_if_connect_tcp_ctx *) arg;
> -  struct mg_connection *nc = ctx->nc;
> -  const union socket_address *sa = ctx->sa;
> -
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct tcp_pcb *tpcb = TCP_NEW();
> -  cs->pcb.tcp = tpcb;
> -  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
> -  u16_t port = ntohs(sa->sin.sin_port);
> -  tcp_arg(tpcb, nc);
> -  tcp_err(tpcb, mg_lwip_tcp_error_cb);
> -  tcp_sent(tpcb, mg_lwip_tcp_sent_cb);
> -  tcp_recv(tpcb, mg_lwip_tcp_recv_cb);
> -  cs->err = TCP_BIND(tpcb, IP_ADDR_ANY, 0 /* any port */);
> -  DBG(("%p tcp_bind = %d", nc, cs->err));
> -  if (cs->err != ERR_OK) {
> -    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
> -    return;
> -  }
> -  cs->err = tcp_connect(tpcb, ip, port, mg_lwip_tcp_conn_cb);
> -  DBG(("%p tcp_connect %p = %d", nc, tpcb, cs->err));
> -  if (cs->err != ERR_OK) {
> -    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
> -    return;
> -  }
> -}
> -
> -void mg_lwip_if_connect_tcp(struct mg_connection *nc,
> -                            const union socket_address *sa) {
> -  struct mg_lwip_if_connect_tcp_ctx ctx = {.nc = nc, .sa = sa};
> -  mg_lwip_netif_run_on_tcpip(mg_lwip_if_connect_tcp_tcpip, &ctx);
> +static void debug_cb(void *c, int lev, const char *s, int n, const char *s2) {
> +  n = (int) strlen(s2) - 1;
> +  LOG(LL_VERBOSE_DEBUG, ("%p %.*s", ((struct mg_connection *) c)->fd, n, s2));
> +  (void) s;
> +  (void) c;
> +  (void) lev;
>   }
>   
> -/*
> - * Lwip included in the SDKs for nRF5x chips has different type for the
> - * callback of `udp_recv()`
> - */
> -#if ((LWIP_VERSION_MAJOR << 8) | LWIP_VERSION_MINOR) >= 0x0105
> -static void mg_lwip_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p,
> -                                const ip_addr_t *addr, u16_t port)
> -#else
> -static void mg_lwip_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p,
> -                                ip_addr_t *addr, u16_t port)
> +#if MBEDTLS_VERSION_NUMBER >= 0x03000000
> +static int rng_get(void *p_rng, unsigned char *buf, size_t len) {
> +  (void) p_rng;
> +  mg_random(buf, len);
> +  return 0;
> +}
>   #endif
> -{
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  DBG(("%p %s:%u %p %u %u", nc, IPADDR_NTOA(addr), port, p, p->ref, p->len));
> -  /* Put address in a separate pbuf and tack it onto the packet. */
> -  struct pbuf *sap =
> -      pbuf_alloc(PBUF_RAW, sizeof(union socket_address), PBUF_RAM);
> -  if (sap == NULL) {
> -    pbuf_free(p);
> -    return;
> -  }
> -  union socket_address *sa = (union socket_address *) sap->payload;
> -#if ((LWIP_VERSION_MAJOR << 8) | LWIP_VERSION_MINOR) >= 0x0105
> -  sa->sin.sin_addr.s_addr = ip_2_ip4(addr)->addr;
> +
> +void mg_tls_init(struct mg_connection *c, struct mg_tls_opts *opts) {
> +  struct mg_tls *tls = (struct mg_tls *) calloc(1, sizeof(*tls));
> +  int rc = 0;
> +  const char *ca = opts->ca == NULL     ? "-"
> +                   : opts->ca[0] == '-' ? "(emb)"
> +                                        : opts->ca;
> +  const char *cert = opts->cert == NULL     ? "-"
> +                     : opts->cert[0] == '-' ? "(emb)"
> +                                            : opts->cert;
> +  const char *certkey = opts->certkey == NULL     ? "-"
> +                        : opts->certkey[0] == '-' ? "(emb)"
> +                                                  : opts->certkey;
> +  if (tls == NULL) {
> +    mg_error(c, "TLS OOM");
> +    goto fail;
> +  }
> +  LOG(LL_DEBUG,
> +      ("%lu Setting TLS, CA: %s, cert: %s, key: %s", c->id, ca, cert, certkey));
> +  mbedtls_ssl_init(&tls->ssl);
> +  mbedtls_ssl_config_init(&tls->conf);
> +  mbedtls_x509_crt_init(&tls->ca);
> +  mbedtls_x509_crt_init(&tls->cert);
> +  mbedtls_pk_init(&tls->pk);
> +  mbedtls_ssl_conf_dbg(&tls->conf, debug_cb, c);
> +  //#if !defined(ESP_PLATFORM)
> +  // mbedtls_debug_set_threshold(5);
> +  //#endif
> +  if ((rc = mbedtls_ssl_config_defaults(
> +           &tls->conf,
> +           c->is_client ? MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
> +           MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
> +    mg_error(c, "tls defaults %#x", -rc);
> +    goto fail;
> +  }
> +  mbedtls_ssl_conf_rng(&tls->conf, mbed_rng, c);
> +  if (opts->ca == NULL || strcmp(opts->ca, "*") == 0) {
> +    mbedtls_ssl_conf_authmode(&tls->conf, MBEDTLS_SSL_VERIFY_NONE);
> +  }
> +  if (opts->ca != NULL && opts->ca[0] != '\0') {
> +#if defined(MBEDTLS_X509_CA_CHAIN_ON_DISK)
> +    tls->cafile = strdup(opts->ca);
> +    rc = mbedtls_ssl_conf_ca_chain_file(&tls->conf, tls->cafile, NULL);
> +    if (rc != 0) {
> +      mg_error(c, "parse on-disk chain(%s) err %#x", ca, -rc);
> +      goto fail;
> +    }
>   #else
> -  sa->sin.sin_addr.s_addr = addr->addr;
> +    rc = opts->ca[0] == '-'
> +             ? mbedtls_x509_crt_parse(&tls->ca, (uint8_t *) opts->ca,
> +                                      strlen(opts->ca) + 1)
> +             : mbedtls_x509_crt_parse_file(&tls->ca, opts->ca);
> +    if (rc != 0) {
> +      mg_error(c, "parse(%s) err %#x", ca, -rc);
> +      goto fail;
> +    }
> +    mbedtls_ssl_conf_ca_chain(&tls->conf, &tls->ca, NULL);
> +#endif
> +    if (opts->srvname.len > 0) {
> +      char mem[128], *buf = mem;
> +      mg_asprintf(&buf, sizeof(mem), "%.*s", (int) opts->srvname.len,
> +                  opts->srvname.ptr);
> +      mbedtls_ssl_set_hostname(&tls->ssl, buf);
> +      if (buf != mem) free(buf);
> +    }
> +    mbedtls_ssl_conf_authmode(&tls->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
> +  }
> +  if (opts->cert != NULL && opts->cert[0] != '\0') {
> +    const char *key = opts->certkey;
> +    if (key == NULL) {
> +      key = opts->cert;
> +      certkey = cert;
> +    }
> +    rc = opts->cert[0] == '-'
> +             ? mbedtls_x509_crt_parse(&tls->cert, (uint8_t *) opts->cert,
> +                                      strlen(opts->cert) + 1)
> +             : mbedtls_x509_crt_parse_file(&tls->cert, opts->cert);
> +    if (rc != 0) {
> +      mg_error(c, "parse(%s) err %#x", cert, -rc);
> +      goto fail;
> +    }
> +    rc = key[0] == '-' ? mbedtls_pk_parse_key(&tls->pk, (uint8_t *) key,
> +                                              strlen(key) + 1, NULL, 0 RNG)
> +                       : mbedtls_pk_parse_keyfile(&tls->pk, key, NULL RNG);
> +    if (rc != 0) {
> +      mg_error(c, "tls key(%s) %#x", certkey, -rc);
> +      goto fail;
> +    }
> +    rc = mbedtls_ssl_conf_own_cert(&tls->conf, &tls->cert, &tls->pk);
> +    if (rc != 0) {
> +      mg_error(c, "own cert %#x", -rc);
> +      goto fail;
> +    }
> +  }
> +  if ((rc = mbedtls_ssl_setup(&tls->ssl, &tls->conf)) != 0) {
> +    mg_error(c, "setup err %#x", -rc);
> +    goto fail;
> +  }
> +  c->tls = tls;
> +  c->is_tls = 1;
> +  c->is_tls_hs = 1;
> +  if (c->is_client && c->is_resolving == 0 && c->is_connecting == 0) {
> +    mg_tls_handshake(c);
> +  }
> +  return;
> +fail:
> +  c->is_closing = 1;
> +  free(tls);
> +}
> +
> +long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  long n = mbedtls_ssl_read(&tls->ssl, (unsigned char *) buf, len);
> +  return n == 0 ? -1 : n == MBEDTLS_ERR_SSL_WANT_READ ? 0 : n;
> +}
> +
> +long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  long n = mbedtls_ssl_write(&tls->ssl, (unsigned char *) buf, len);
> +  return n == 0 ? -1 : n == MBEDTLS_ERR_SSL_WANT_WRITE ? 0 : n;
> +}
> +
> +void mg_tls_free(struct mg_connection *c) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  if (tls == NULL) return;
> +  free(tls->cafile);
> +  mbedtls_ssl_free(&tls->ssl);
> +  mbedtls_pk_free(&tls->pk);
> +  mbedtls_x509_crt_free(&tls->ca);
> +  mbedtls_x509_crt_free(&tls->cert);
> +  mbedtls_ssl_config_free(&tls->conf);
> +  free(tls);
> +  c->tls = NULL;
> +}
> +#elif MG_ENABLE_OPENSSL  ///////////////////////////////////////// OPENSSL
> +
> +#include <openssl/err.h>
> +#include <openssl/ssl.h>
> +
> +struct mg_tls {
> +  SSL_CTX *ctx;
> +  SSL *ssl;
> +};
> +
> +static int mg_tls_err(struct mg_tls *tls, int res) {
> +  int err = SSL_get_error(tls->ssl, res);
> +  // We've just fetched the last error from the queue.
> +  // Now we need to clear the error queue. If we do not, then the following
> +  // can happen (actually reported):
> +  //  - A new connection is accept()-ed with cert error (e.g. self-signed cert)
> +  //  - Since all accept()-ed connections share listener's context,
> +  //  - *ALL* SSL accepted connection report read error on the next poll cycle.
> +  //    Thus a single errored connection can close all the rest, unrelated ones.
> +  // Clearing the error keeps the shared SSL_CTX in an OK state.
> +
> +  if (err != 0) ERR_print_errors_fp(stderr);
> +  ERR_clear_error();
> +  if (err == SSL_ERROR_WANT_READ) return 0;
> +  if (err == SSL_ERROR_WANT_WRITE) return 0;
> +  return err;
> +}
> +
> +void mg_tls_init(struct mg_connection *c, struct mg_tls_opts *opts) {
> +  struct mg_tls *tls = (struct mg_tls *) calloc(1, sizeof(*tls));
> +  const char *id = "mongoose";
> +  static unsigned char s_initialised = 0;
> +  int rc;
> +
> +  if (tls == NULL) {
> +    mg_error(c, "TLS OOM");
> +    goto fail;
> +  }
> +
> +  if (!s_initialised) {
> +    SSL_library_init();
> +    s_initialised++;
> +  }
> +  LOG(LL_DEBUG, ("%lu Setting TLS, CA: %s, cert: %s, key: %s", c->id,
> +                 opts->ca == NULL ? "null" : opts->ca,
> +                 opts->cert == NULL ? "null" : opts->cert,
> +                 opts->certkey == NULL ? "null" : opts->certkey));
> +  tls->ctx = c->is_client ? SSL_CTX_new(SSLv23_client_method())
> +                          : SSL_CTX_new(SSLv23_server_method());
> +  if ((tls->ssl = SSL_new(tls->ctx)) == NULL) {
> +    mg_error(c, "SSL_new");
> +    goto fail;
> +  }
> +  SSL_set_session_id_context(tls->ssl, (const uint8_t *) id,
> +                             (unsigned) strlen(id));
> +  // Disable deprecated protocols
> +  SSL_set_options(tls->ssl, SSL_OP_NO_SSLv2);
> +  SSL_set_options(tls->ssl, SSL_OP_NO_SSLv3);
> +  SSL_set_options(tls->ssl, SSL_OP_NO_TLSv1);
> +  SSL_set_options(tls->ssl, SSL_OP_NO_TLSv1_1);
> +#ifdef MG_ENABLE_OPENSSL_NO_COMPRESSION
> +  SSL_set_options(tls->ssl, SSL_OP_NO_COMPRESSION);
> +#endif
> +#ifdef MG_ENABLE_OPENSSL_CIPHER_SERVER_PREFERENCE
> +  SSL_set_options(tls->ssl, SSL_OP_CIPHER_SERVER_PREFERENCE);
> +#endif
> +
> +  if (opts->ca != NULL && opts->ca[0] != '\0') {
> +    SSL_set_verify(tls->ssl, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
> +                   NULL);
> +    if ((rc = SSL_CTX_load_verify_locations(tls->ctx, opts->ca, NULL)) != 1) {
> +      mg_error(c, "parse(%s): err %d", opts->ca, mg_tls_err(tls, rc));
> +      goto fail;
> +    }
> +  }
> +  if (opts->cert != NULL && opts->cert[0] != '\0') {
> +    const char *key = opts->certkey;
> +    if (key == NULL) key = opts->cert;
> +    if ((rc = SSL_use_certificate_file(tls->ssl, opts->cert, 1)) != 1) {
> +      mg_error(c, "Invalid SSL cert, err %d", mg_tls_err(tls, rc));
> +      goto fail;
> +    } else if ((rc = SSL_use_PrivateKey_file(tls->ssl, key, 1)) != 1) {
> +      mg_error(c, "Invalid SSL key, err %d", mg_tls_err(tls, rc));
> +      goto fail;
> +#if OPENSSL_VERSION_NUMBER > 0x10100000L
> +    } else if ((rc = SSL_use_certificate_chain_file(tls->ssl, opts->cert)) !=
> +               1) {
> +      mg_error(c, "Invalid CA, err %d", mg_tls_err(tls, rc));
> +      goto fail;
>   #endif
> -  sa->sin.sin_port = htons(port);
> -  /* Logic in the recv handler requires that there be exactly one data pbuf. */
> -  p = pbuf_coalesce(p, PBUF_RAW);
> -  pbuf_chain(sap, p);
> -  mgos_lock();
> -  mg_lwip_recv_common(nc, sap);
> -  mgos_unlock();
> -  (void) pcb;
> -}
> -
> -static void mg_lwip_recv_common(struct mg_connection *nc, struct pbuf *p) {
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (cs->rx_chain == NULL) {
> -    cs->rx_chain = p;
> +    } else {
> +      SSL_set_mode(tls->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
> +#if OPENSSL_VERSION_NUMBER > 0x10002000L
> +      SSL_set_ecdh_auto(tls->ssl, 1);
> +#endif
> +    }
> +  }
> +  if (opts->ciphers != NULL) SSL_set_cipher_list(tls->ssl, opts->ciphers);
> +  if (opts->srvname.len > 0) {
> +    char mem[128], *buf = mem;
> +    mg_asprintf(&buf, sizeof(mem), "%.*s", (int) opts->srvname.len,
> +                opts->srvname.ptr);
> +    SSL_set_tlsext_host_name(tls->ssl, buf);
> +    if (buf != mem) free(buf);
> +  }
> +  c->tls = tls;
> +  c->is_tls = 1;
> +  c->is_tls_hs = 1;
> +  if (c->is_client && c->is_resolving == 0 && c->is_connecting == 0) {
> +    mg_tls_handshake(c);
> +  }
> +  c->is_hexdumping = 1;
> +  LOG(LL_DEBUG, ("%lu SSL %s OK", c->id, c->is_accepted ? "accept" : "client"));
> +  return;
> +fail:
> +  c->is_closing = 1;
> +  free(tls);
> +}
> +
> +void mg_tls_handshake(struct mg_connection *c) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  int rc;
> +  SSL_set_fd(tls->ssl, (int) (size_t) c->fd);
> +  rc = c->is_client ? SSL_connect(tls->ssl) : SSL_accept(tls->ssl);
> +  if (rc == 1) {
> +    LOG(LL_DEBUG, ("%lu success", c->id));
> +    c->is_tls_hs = 0;
>     } else {
> -    pbuf_chain(cs->rx_chain, p);
> -  }
> -  if (!cs->recv_pending) {
> -    cs->recv_pending = 1;
> -    mg_lwip_post_signal(MG_SIG_RECV, nc);
> +    int code = mg_tls_err(tls, rc);
> +    if (code != 0) mg_error(c, "tls hs: rc %d, err %d", rc, code);
>     }
>   }
>   
> -static int mg_lwip_if_udp_recv(struct mg_connection *nc, void *buf, size_t len,
> -                               union socket_address *sa, size_t *sa_len) {
> -  /*
> -   * For UDP, RX chain consists of interleaved address and packet bufs:
> -   * Address pbuf followed by exactly one data pbuf (recv_cb took care of that).
> -   */
> -  int res = 0;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (nc->sock == INVALID_SOCKET) return -1;
> -  mgos_lock();
> -  if (cs->rx_chain != NULL) {
> -    struct pbuf *ap = cs->rx_chain;
> -    struct pbuf *dp = ap->next;
> -    cs->rx_chain = pbuf_dechain(dp);
> -    res = MIN(dp->len, len);
> -    pbuf_copy_partial(dp, buf, res, 0);
> -    pbuf_free(dp);
> -    pbuf_copy_partial(ap, sa, MIN(*sa_len, ap->len), 0);
> -    pbuf_free(ap);
> -  }
> -  mgos_unlock();
> -  return res;
> +void mg_tls_free(struct mg_connection *c) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  if (tls == NULL) return;
> +  SSL_free(tls->ssl);
> +  SSL_CTX_free(tls->ctx);
> +  free(tls);
> +  c->tls = NULL;
>   }
>   
> -static void mg_lwip_if_connect_udp_tcpip(void *arg) {
> -  struct mg_connection *nc = (struct mg_connection *) arg;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct udp_pcb *upcb = udp_new();
> -  cs->err = UDP_BIND(upcb, IP_ADDR_ANY, 0 /* any port */);
> -  DBG(("%p udp_bind %p = %d", nc, upcb, cs->err));
> -  if (cs->err == ERR_OK) {
> -    udp_recv(upcb, mg_lwip_udp_recv_cb, nc);
> -    cs->pcb.udp = upcb;
> -  } else {
> -    udp_remove(upcb);
> -  }
> -  mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
> +long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  int n = SSL_read(tls->ssl, buf, (int) len);
> +  return n == 0 ? -1 : n < 0 && mg_tls_err(tls, n) == 0 ? 0 : n;
>   }
>   
> -void mg_lwip_if_connect_udp(struct mg_connection *nc) {
> -  mg_lwip_netif_run_on_tcpip(mg_lwip_if_connect_udp_tcpip, nc);
> +long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
> +  struct mg_tls *tls = (struct mg_tls *) c->tls;
> +  int n = SSL_write(tls->ssl, buf, (int) len);
> +  return n == 0 ? -1 : n < 0 && mg_tls_err(tls, n) == 0 ? 0 : n;
>   }
>   
> -static void tcp_close_tcpip(void *arg) {
> -  tcp_close((struct tcp_pcb *) arg);
> -}
> +#else  //////////////////////////////////////////   NO TLS
>   
> -void mg_lwip_handle_accept(struct mg_connection *nc) {
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (cs->pcb.tcp == NULL) return;
> -  union socket_address sa;
> -  struct tcp_pcb *tpcb = cs->pcb.tcp;
> -  SET_ADDR(&sa, &tpcb->remote_ip);
> -  sa.sin.sin_port = htons(tpcb->remote_port);
> -  mg_if_accept_tcp_cb(nc, &sa, sizeof(sa.sin));
> +void mg_tls_init(struct mg_connection *c, struct mg_tls_opts *opts) {
> +  (void) opts;
> +  mg_error(c, "TLS is not enabled");
>   }
> -
> -static err_t mg_lwip_accept_cb(void *arg, struct tcp_pcb *newtpcb, err_t err) {
> -  struct mg_connection *lc = (struct mg_connection *) arg, *nc;
> -  struct mg_lwip_conn_state *lcs, *cs;
> -  struct tcp_pcb_listen *lpcb;
> -  LOG(LL_DEBUG,
> -      ("%p conn %p from %s:%u", lc, newtpcb,
> -       IPADDR_NTOA(ipX_2_ip(&newtpcb->remote_ip)), newtpcb->remote_port));
> -  if (lc == NULL) {
> -    tcp_abort(newtpcb);
> -    return ERR_ABRT;
> -  }
> -  lcs = (struct mg_lwip_conn_state *) lc->sock;
> -  lpcb = (struct tcp_pcb_listen *) lcs->pcb.tcp;
> -#if TCP_LISTEN_BACKLOG
> -  tcp_accepted(lpcb);
> -#endif
> -  nc = mg_if_accept_new_conn(lc);
> -  if (nc == NULL) {
> -    tcp_abort(newtpcb);
> -    return ERR_ABRT;
> -  }
> -  cs = (struct mg_lwip_conn_state *) nc->sock;
> -  cs->lc = lc;
> -  cs->pcb.tcp = newtpcb;
> -  /* We need to set up callbacks before returning because data may start
> -   * arriving immediately. */
> -  tcp_arg(newtpcb, nc);
> -  tcp_err(newtpcb, mg_lwip_tcp_error_cb);
> -  tcp_sent(newtpcb, mg_lwip_tcp_sent_cb);
> -  tcp_recv(newtpcb, mg_lwip_tcp_recv_cb);
> -#if LWIP_TCP_KEEPALIVE
> -  mg_lwip_set_keepalive_params(nc, 60, 10, 6);
> -#endif
> -  mg_lwip_post_signal(MG_SIG_ACCEPT, nc);
> -  (void) err;
> -  (void) lpcb;
> -  return ERR_OK;
> +void mg_tls_handshake(struct mg_connection *c) {
> +  (void) c;
>   }
> -
> -struct mg_lwip_if_listen_ctx {
> -  struct mg_connection *nc;
> -  union socket_address *sa;
> -  int ret;
> -};
> -
> -static void mg_lwip_if_listen_tcp_tcpip(void *arg) {
> -  struct mg_lwip_if_listen_ctx *ctx = (struct mg_lwip_if_listen_ctx *) arg;
> -  struct mg_connection *nc = ctx->nc;
> -  union socket_address *sa = ctx->sa;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct tcp_pcb *tpcb = TCP_NEW();
> -  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
> -  u16_t port = ntohs(sa->sin.sin_port);
> -  cs->err = TCP_BIND(tpcb, ip, port);
> -  DBG(("%p tcp_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err));
> -  if (cs->err != ERR_OK) {
> -    tcp_close(tpcb);
> -    ctx->ret = -1;
> -    return;
> -  }
> -  tcp_arg(tpcb, nc);
> -  tpcb = tcp_listen(tpcb);
> -  cs->pcb.tcp = tpcb;
> -  tcp_accept(tpcb, mg_lwip_accept_cb);
> -  ctx->ret = 0;
> -}
> -
> -int mg_lwip_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) {
> -  struct mg_lwip_if_listen_ctx ctx = {.nc = nc, .sa = sa};
> -  mg_lwip_netif_run_on_tcpip(mg_lwip_if_listen_tcp_tcpip, &ctx);
> -  return ctx.ret;
> -}
> -
> -static void mg_lwip_if_listen_udp_tcpip(void *arg) {
> -  struct mg_lwip_if_listen_ctx *ctx = (struct mg_lwip_if_listen_ctx *) arg;
> -  struct mg_connection *nc = ctx->nc;
> -  union socket_address *sa = ctx->sa;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct udp_pcb *upcb = udp_new();
> -  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
> -  u16_t port = ntohs(sa->sin.sin_port);
> -  cs->err = UDP_BIND(upcb, ip, port);
> -  DBG(("%p udb_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err));
> -  if (cs->err != ERR_OK) {
> -    udp_remove(upcb);
> -    ctx->ret = -1;
> -  } else {
> -    udp_recv(upcb, mg_lwip_udp_recv_cb, nc);
> -    cs->pcb.udp = upcb;
> -    ctx->ret = 0;
> -  }
> +void mg_tls_free(struct mg_connection *c) {
> +  (void) c;
>   }
> -
> -int mg_lwip_if_listen_udp(struct mg_connection *nc, union socket_address *sa) {
> -  struct mg_lwip_if_listen_ctx ctx = {.nc = nc, .sa = sa};
> -  mg_lwip_netif_run_on_tcpip(mg_lwip_if_listen_udp_tcpip, &ctx);
> -  return ctx.ret;
> +long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
> +  return c == NULL || buf == NULL || len == 0 ? 0 : -1;
>   }
> -
> -struct mg_lwip_tcp_write_ctx {
> -  struct mg_connection *nc;
> -  const void *data;
> -  uint16_t len;
> -  int ret;
> -};
> -
> -static void tcp_output_tcpip(void *arg) {
> -  tcp_output((struct tcp_pcb *) arg);
> -}
> -
> -static void mg_lwip_tcp_write_tcpip(void *arg) {
> -  struct mg_lwip_tcp_write_ctx *ctx = (struct mg_lwip_tcp_write_ctx *) arg;
> -  struct mg_connection *nc = ctx->nc;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  struct tcp_pcb *tpcb = cs->pcb.tcp;
> -  size_t len = MIN(tpcb->mss, MIN(ctx->len, tpcb->snd_buf));
> -  size_t unsent, unacked;
> -  if (len == 0) {
> -    DBG(("%p no buf avail %u %u %p %p", tpcb, tpcb->snd_buf, tpcb->snd_queuelen,
> -         tpcb->unsent, tpcb->unacked));
> -    mg_lwip_netif_run_on_tcpip(tcp_output_tcpip, tpcb);
> -    ctx->ret = 0;
> -    return;
> -  }
> -  unsent = (tpcb->unsent != NULL ? tpcb->unsent->len : 0);
> -  unacked = (tpcb->unacked != NULL ? tpcb->unacked->len : 0);
> -/*
> - * On ESP8266 we only allow one TCP segment in flight at any given time.
> - * This may increase latency and reduce efficiency of tcp windowing,
> - * but memory is scarce and precious on that platform so we do this to
> - * reduce footprint.
> - */
> -#if CS_PLATFORM == CS_P_ESP8266
> -  if (unacked > 0) {
> -    ctx->ret = 0;
> -    return;
> -  }
> -  len = MIN(len, (TCP_MSS - unsent));
> -#endif
> -  cs->err = tcp_write(tpcb, ctx->data, len, TCP_WRITE_FLAG_COPY);
> -  unsent = (tpcb->unsent != NULL ? tpcb->unsent->len : 0);
> -  unacked = (tpcb->unacked != NULL ? tpcb->unacked->len : 0);
> -  DBG(("%p tcp_write %u = %d, %u %u", tpcb, len, cs->err, unsent, unacked));
> -  if (cs->err != ERR_OK) {
> -    /*
> -     * We ignore ERR_MEM because memory will be freed up when the data is sent
> -     * and we'll retry.
> -     */
> -    ctx->ret = (cs->err == ERR_MEM ? 0 : -1);
> -    return;
> -  }
> -  ctx->ret = len;
> -  (void) unsent;
> -  (void) unacked;
> -}
> -
> -int mg_lwip_if_tcp_send(struct mg_connection *nc, const void *buf, size_t len) {
> -  struct mg_lwip_tcp_write_ctx ctx = {.nc = nc, .data = buf, .len = len};
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (nc->sock == INVALID_SOCKET) return -1;
> -  struct tcp_pcb *tpcb = cs->pcb.tcp;
> -  if (tpcb == NULL) return -1;
> -  if (tpcb->snd_buf <= 0) return 0;
> -  mg_lwip_netif_run_on_tcpip(mg_lwip_tcp_write_tcpip, &ctx);
> -  return ctx.ret;
> -}
> -
> -struct udp_sendto_ctx {
> -  struct udp_pcb *upcb;
> -  struct pbuf *p;
> -  ip_addr_t *ip;
> -  uint16_t port;
> -  int ret;
> -};
> -
> -static void udp_sendto_tcpip(void *arg) {
> -  struct udp_sendto_ctx *ctx = (struct udp_sendto_ctx *) arg;
> -  ctx->ret = udp_sendto(ctx->upcb, ctx->p, ctx->ip, ctx->port);
> +long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
> +  return c == NULL || buf == NULL || len == 0 ? 0 : -1;
>   }
>   
> -static int mg_lwip_if_udp_send(struct mg_connection *nc, const void *data,
> -                               size_t len) {
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (nc->sock == INVALID_SOCKET || cs->pcb.udp == NULL) return -1;
> -  struct udp_pcb *upcb = cs->pcb.udp;
> -  struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
> -#if defined(LWIP_IPV4) && LWIP_IPV4 && defined(LWIP_IPV6) && LWIP_IPV6
> -  ip_addr_t ip = {.u_addr.ip4.addr = nc->sa.sin.sin_addr.s_addr, .type = 0};
> -#else
> -  ip_addr_t ip = {.addr = nc->sa.sin.sin_addr.s_addr};
>   #endif
> -  u16_t port = ntohs(nc->sa.sin.sin_port);
> -  if (p == NULL) return 0;
> -  memcpy(p->payload, data, len);
> -  struct udp_sendto_ctx ctx = {.upcb = upcb, .p = p, .ip = &ip, .port = port};
> -  mg_lwip_netif_run_on_tcpip(udp_sendto_tcpip, &ctx);
> -  cs->err = ctx.ret;
> -  pbuf_free(p);
> -  return (cs->err == ERR_OK ? (int) len : -2);
> -}
> -
> -static int mg_lwip_if_can_send(struct mg_connection *nc,
> -                               struct mg_lwip_conn_state *cs) {
> -  int can_send = 0;
> -  if (nc->send_mbuf.len > 0 || (nc->flags & MG_F_WANT_WRITE)) {
> -    /* We have stuff to send, but can we? */
> -    if (nc->flags & MG_F_UDP) {
> -      /* UDP is always ready for sending. */
> -      can_send = (cs->pcb.udp != NULL);
> -    } else {
> -      can_send = (cs->pcb.tcp != NULL && cs->pcb.tcp->snd_buf > 0);
> -/* See comment above. */
> -#if CS_PLATFORM == CS_P_ESP8266
> -      if (cs->pcb.tcp->unacked != NULL) can_send = 0;
> +
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/url.c"
>   #endif
> -    }
> -  }
> -  return can_send;
> -}
>   
> -struct tcp_recved_ctx {
> -  struct tcp_pcb *tpcb;
> -  size_t len;
> +#include <stdlib.h>
> +
> +struct url {
> +  size_t key, user, pass, host, port, uri, end;
>   };
>   
> -void tcp_recved_tcpip(void *arg) {
> -  struct tcp_recved_ctx *ctx = (struct tcp_recved_ctx *) arg;
> -  if (ctx->tpcb != NULL) tcp_recved(ctx->tpcb, ctx->len);
> -}
> -
> -static int mg_lwip_if_tcp_recv(struct mg_connection *nc, void *buf,
> -                               size_t len) {
> -  int res = 0;
> -  char *bufp = buf;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (nc->sock == INVALID_SOCKET) return -1;
> -  mgos_lock();
> -  while (cs->rx_chain != NULL && len > 0) {
> -    struct pbuf *seg = cs->rx_chain;
> -    size_t seg_len = (seg->len - cs->rx_offset);
> -    size_t copy_len = MIN(len, seg_len);
> -
> -    pbuf_copy_partial(seg, bufp, copy_len, cs->rx_offset);
> -    len -= copy_len;
> -    res += copy_len;
> -    bufp += copy_len;
> -    cs->rx_offset += copy_len;
> -    if (cs->rx_offset == cs->rx_chain->len) {
> -      cs->rx_chain = pbuf_dechain(cs->rx_chain);
> -      pbuf_free(seg);
> -      cs->rx_offset = 0;
> -    }
> -  }
> -  mgos_unlock();
> -  if (res > 0) {
> -    struct tcp_recved_ctx ctx = {.tpcb = cs->pcb.tcp, .len = res};
> -    mg_lwip_netif_run_on_tcpip(tcp_recved_tcpip, &ctx);
> -  }
> -  return res;
> +int mg_url_is_ssl(const char *url) {
> +  return strncmp(url, "wss:", 4) == 0 || strncmp(url, "https:", 6) == 0 ||
> +         strncmp(url, "mqtts:", 6) == 0 || strncmp(url, "ssl:", 4) == 0 ||
> +         strncmp(url, "tls:", 4) == 0;
>   }
>   
> -int mg_lwip_if_create_conn(struct mg_connection *nc) {
> -  struct mg_lwip_conn_state *cs =
> -      (struct mg_lwip_conn_state *) MG_CALLOC(1, sizeof(*cs));
> -  if (cs == NULL) return 0;
> -  cs->nc = nc;
> -  nc->sock = (intptr_t) cs;
> -  return 1;
> +static struct url urlparse(const char *url) {
> +  size_t i;
> +  struct url u;
> +  memset(&u, 0, sizeof(u));
> +  for (i = 0; url[i] != '\0'; i++) {
> +    if (i > 0 && u.host == 0 && url[i - 1] == '/' && url[i] == '/') {
> +      u.host = i + 1;
> +      u.port = 0;
> +    } else if (url[i] == ']') {
> +      u.port = 0;  // IPv6 URLs, like http://[::1]/bar
> +    } else if (url[i] == ':' && u.port == 0 && u.uri == 0) {
> +      u.port = i + 1;
> +    } else if (url[i] == '@' && u.user == 0 && u.pass == 0) {
> +      u.user = u.host;
> +      u.pass = u.port;
> +      u.host = i + 1;
> +      u.port = 0;
> +    } else if (u.host && u.uri == 0 && url[i] == '/') {
> +      u.uri = i;
> +    }
> +  }
> +  u.end = i;
> +#if 0
> +  printf("[%s] %d %d %d %d %d\n", url, u.user, u.pass, u.host, u.port, u.uri);
> +#endif
> +  return u;
>   }
>   
> -static void udp_remove_tcpip(void *arg) {
> -  udp_remove((struct udp_pcb *) arg);
> +struct mg_str mg_url_host(const char *url) {
> +  struct url u = urlparse(url);
> +  size_t n = u.port  ? u.port - u.host - 1
> +             : u.uri ? u.uri - u.host
> +                     : u.end - u.host;
> +  struct mg_str s = mg_str_n(url + u.host, n);
> +  return s;
>   }
>   
> -void mg_lwip_if_destroy_conn(struct mg_connection *nc) {
> -  if (nc->sock == INVALID_SOCKET) return;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (!(nc->flags & MG_F_UDP)) {
> -    struct tcp_pcb *tpcb = cs->pcb.tcp;
> -    if (tpcb != NULL) {
> -      tcp_arg(tpcb, NULL);
> -      DBG(("%p tcp_close %p", nc, tpcb));
> -      tcp_arg(tpcb, NULL);
> -      mg_lwip_netif_run_on_tcpip(tcp_close_tcpip, tpcb);
> -    }
> -    while (cs->rx_chain != NULL) {
> -      struct pbuf *seg = cs->rx_chain;
> -      cs->rx_chain = pbuf_dechain(cs->rx_chain);
> -      pbuf_free(seg);
> -    }
> -    memset(cs, 0, sizeof(*cs));
> -    MG_FREE(cs);
> -  } else if (nc->listener == NULL) {
> -    /* Only close outgoing UDP pcb or listeners. */
> -    struct udp_pcb *upcb = cs->pcb.udp;
> -    if (upcb != NULL) {
> -      DBG(("%p udp_remove %p", nc, upcb));
> -      mg_lwip_netif_run_on_tcpip(udp_remove_tcpip, upcb);
> -    }
> -    memset(cs, 0, sizeof(*cs));
> -    MG_FREE(cs);
> -  }
> -  nc->sock = INVALID_SOCKET;
> -}
> -
> -void mg_lwip_if_get_conn_addr(struct mg_connection *nc, int remote,
> -                              union socket_address *sa) {
> -  memset(sa, 0, sizeof(*sa));
> -  if (nc == NULL || nc->sock == INVALID_SOCKET) return;
> -  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -  if (nc->flags & MG_F_UDP) {
> -    struct udp_pcb *upcb = cs->pcb.udp;
> -    if (remote) {
> -      memcpy(sa, &nc->sa, sizeof(*sa));
> -    } else if (upcb != NULL) {
> -      sa->sin.sin_port = htons(upcb->local_port);
> -      SET_ADDR(sa, &upcb->local_ip);
> -    }
> -  } else {
> -    struct tcp_pcb *tpcb = cs->pcb.tcp;
> -    if (remote) {
> -      memcpy(sa, &nc->sa, sizeof(*sa));
> -    } else if (tpcb != NULL) {
> -      sa->sin.sin_port = htons(tpcb->local_port);
> -      SET_ADDR(sa, &tpcb->local_ip);
> -    }
> -  }
> +const char *mg_url_uri(const char *url) {
> +  struct url u = urlparse(url);
> +  return u.uri ? url + u.uri : "/";
>   }
>   
> -void mg_lwip_if_sock_set(struct mg_connection *nc, sock_t sock) {
> -  nc->sock = sock;
> -}
> -
> -/* clang-format off */
> -#define MG_LWIP_IFACE_VTABLE                                          \
> -  {                                                                   \
> -    mg_lwip_if_init,                                                  \
> -    mg_lwip_if_free,                                                  \
> -    mg_lwip_if_add_conn,                                              \
> -    mg_lwip_if_remove_conn,                                           \
> -    mg_lwip_if_poll,                                                  \
> -    mg_lwip_if_listen_tcp,                                            \
> -    mg_lwip_if_listen_udp,                                            \
> -    mg_lwip_if_connect_tcp,                                           \
> -    mg_lwip_if_connect_udp,                                           \
> -    mg_lwip_if_tcp_send,                                              \
> -    mg_lwip_if_udp_send,                                              \
> -    mg_lwip_if_tcp_recv,                                              \
> -    mg_lwip_if_udp_recv,                                              \
> -    mg_lwip_if_create_conn,                                           \
> -    mg_lwip_if_destroy_conn,                                          \
> -    mg_lwip_if_sock_set,                                              \
> -    mg_lwip_if_get_conn_addr,                                         \
> -  }
> -/* clang-format on */
> -
> -const struct mg_iface_vtable mg_lwip_iface_vtable = MG_LWIP_IFACE_VTABLE;
> -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL
> -const struct mg_iface_vtable mg_default_iface_vtable = MG_LWIP_IFACE_VTABLE;
> -#endif
> +unsigned short mg_url_port(const char *url) {
> +  struct url u = urlparse(url);
> +  unsigned short port = 0;
> +  if (memcmp(url, "http:", 5) == 0 || memcmp(url, "ws:", 3) == 0) port = 80;
> +  if (memcmp(url, "wss:", 4) == 0 || memcmp(url, "https:", 6) == 0) port = 443;
> +  if (memcmp(url, "mqtt:", 5) == 0) port = 1883;
> +  if (memcmp(url, "mqtts:", 6) == 0) port = 8883;
> +  if (u.port) port = (unsigned short) atoi(url + u.port);
> +  return port;
> +}
>   
> -#endif /* MG_ENABLE_NET_IF_LWIP_LOW_LEVEL */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/lwip/mg_lwip_ev_mgr.c"
> -#endif
> +struct mg_str mg_url_user(const char *url) {
> +  struct url u = urlparse(url);
> +  struct mg_str s = mg_str("");
> +  if (u.user && (u.pass || u.host)) {
> +    size_t n = u.pass ? u.pass - u.user - 1 : u.host - u.user - 1;
> +    s = mg_str_n(url + u.user, n);
> +  }
> +  return s;
> +}
>   
> -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL
> +struct mg_str mg_url_pass(const char *url) {
> +  struct url u = urlparse(url);
> +  struct mg_str s = mg_str_n("", 0UL);
> +  if (u.pass && u.host) {
> +    size_t n = u.host - u.pass - 1;
> +    s = mg_str_n(url + u.pass, n);
> +  }
> +  return s;
> +}
>   
> -#ifndef MG_SIG_QUEUE_LEN
> -#define MG_SIG_QUEUE_LEN 32
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/util.c"
>   #endif
>   
> -struct mg_ev_mgr_lwip_signal {
> -  int sig;
> -  struct mg_connection *nc;
> -};
>   
> -struct mg_ev_mgr_lwip_data {
> -  struct mg_ev_mgr_lwip_signal sig_queue[MG_SIG_QUEUE_LEN];
> -  int sig_queue_len;
> -  int start_index;
> -};
>   
> -void mg_lwip_post_signal(enum mg_sig_type sig, struct mg_connection *nc) {
> -  struct mg_ev_mgr_lwip_data *md =
> -      (struct mg_ev_mgr_lwip_data *) nc->iface->data;
> -  mgos_lock();
> -  if (md->sig_queue_len >= MG_SIG_QUEUE_LEN) {
> -    mgos_unlock();
> -    return;
> -  }
> -  int end_index = (md->start_index + md->sig_queue_len) % MG_SIG_QUEUE_LEN;
> -  md->sig_queue[end_index].sig = sig;
> -  md->sig_queue[end_index].nc = nc;
> -  md->sig_queue_len++;
> -  mg_lwip_mgr_schedule_poll(nc->mgr);
> -  mgos_unlock();
> -}
> -
> -void mg_ev_mgr_lwip_process_signals(struct mg_mgr *mgr) {
> -  struct mg_ev_mgr_lwip_data *md =
> -      (struct mg_ev_mgr_lwip_data *) mgr->ifaces[MG_MAIN_IFACE]->data;
> -  while (md->sig_queue_len > 0) {
> -    mgos_lock();
> -    int i = md->start_index;
> -    int sig = md->sig_queue[i].sig;
> -    struct mg_connection *nc = md->sig_queue[i].nc;
> -    struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -    md->start_index = (i + 1) % MG_SIG_QUEUE_LEN;
> -    md->sig_queue_len--;
> -    mgos_unlock();
> -    if (nc->iface == NULL || nc->mgr == NULL) continue;
> -    switch (sig) {
> -      case MG_SIG_CONNECT_RESULT: {
> -        mg_if_connect_cb(nc, cs->err);
> -        break;
> -      }
> -      case MG_SIG_CLOSE_CONN: {
> -        mg_close_conn(nc);
> -        break;
> -      }
> -      case MG_SIG_RECV: {
> -        cs->recv_pending = 0;
> -        mg_if_can_recv_cb(nc);
> -        mbuf_trim(&nc->recv_mbuf);
> -        break;
> -      }
> -      case MG_SIG_TOMBSTONE: {
> -        break;
> -      }
> -      case MG_SIG_ACCEPT: {
> -        mg_lwip_handle_accept(nc);
> -        break;
> +
> +char *mg_file_read(const char *path, size_t *sizep) {
> +  FILE *fp;
> +  char *data = NULL;
> +  size_t size = 0;
> +  if ((fp = fopen(path, "rb")) != NULL) {
> +    fseek(fp, 0, SEEK_END);
> +    size = (size_t) ftell(fp);
> +    rewind(fp);
> +    data = (char *) calloc(1, size + 1);
> +    if (data != NULL) {
> +      if (fread(data, 1, size, fp) != size) {
> +        free(data);
> +        data = NULL;
> +      } else {
> +        data[size] = '\0';
> +        if (sizep != NULL) *sizep = size;
>         }
>       }
> +    fclose(fp);
>     }
> +  return data;
>   }
>   
> -void mg_lwip_if_init(struct mg_iface *iface) {
> -  LOG(LL_INFO, ("Mongoose %s, LwIP %u.%u.%u", MG_VERSION, LWIP_VERSION_MAJOR,
> -                LWIP_VERSION_MINOR, LWIP_VERSION_REVISION));
> -  iface->data = MG_CALLOC(1, sizeof(struct mg_ev_mgr_lwip_data));
> -#if !NO_SYS && !LWIP_TCPIP_CORE_LOCKING
> -  sys_sem_new(&s_tcpip_call_lock_sem, 1);
> -  sys_sem_new(&s_tcpip_call_sync_sem, 0);
> -#endif
> -}
> -
> -void mg_lwip_if_free(struct mg_iface *iface) {
> -  MG_FREE(iface->data);
> -  iface->data = NULL;
> +bool mg_file_write(const char *path, const void *buf, size_t len) {
> +  bool result = false;
> +  FILE *fp;
> +  char tmp[MG_PATH_MAX];
> +  snprintf(tmp, sizeof(tmp), "%s.%d", path, rand());
> +  fp = fopen(tmp, "wb");
> +  if (fp != NULL) {
> +    result = fwrite(buf, 1, len, fp) == len;
> +    fclose(fp);
> +    if (result) {
> +      remove(path);
> +      rename(tmp, path);
> +    } else {
> +      remove(tmp);
> +    }
> +  }
> +  return result;
>   }
>   
> -void mg_lwip_if_add_conn(struct mg_connection *nc) {
> -  (void) nc;
> +bool mg_file_printf(const char *path, const char *fmt, ...) {
> +  char tmp[256], *buf = tmp;
> +  bool result;
> +  int len;
> +  va_list ap;
> +  va_start(ap, fmt);
> +  len = mg_vasprintf(&buf, sizeof(tmp), fmt, ap);
> +  va_end(ap);
> +  result = mg_file_write(path, buf, len > 0 ? (size_t) len : 0);
> +  if (buf != tmp) free(buf);
> +  return result;
>   }
>   
> -void mg_lwip_if_remove_conn(struct mg_connection *nc) {
> -  struct mg_ev_mgr_lwip_data *md =
> -      (struct mg_ev_mgr_lwip_data *) nc->iface->data;
> -  /* Walk the queue and null-out further signals for this conn. */
> -  for (int i = 0; i < MG_SIG_QUEUE_LEN; i++) {
> -    if (md->sig_queue[i].nc == nc) {
> -      md->sig_queue[i].sig = MG_SIG_TOMBSTONE;
> -    }
> +#if MG_ENABLE_CUSTOM_RANDOM
> +#else
> +void mg_random(void *buf, size_t len) {
> +  bool done = false;
> +  unsigned char *p = (unsigned char *) buf;
> +#if MG_ARCH == MG_ARCH_ESP32
> +  while (len--) *p++ = (unsigned char) (esp_random() & 255);
> +#elif MG_ARCH == MG_ARCH_WIN32
> +#elif MG_ARCH_UNIX
> +  FILE *fp = fopen("/dev/urandom", "rb");
> +  if (fp != NULL) {
> +    if (fread(buf, 1, len, fp) == len) done = true;
> +    fclose(fp);
> +  }
> +#endif
> +  // Fallback to a pseudo random gen
> +  if (!done) {
> +    while (len--) *p++ = (unsigned char) (rand() & 255);
>     }
>   }
> -
> -time_t mg_lwip_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  struct mg_mgr *mgr = iface->mgr;
> -  int n = 0;
> -  double now = mg_time();
> -  struct mg_connection *nc, *tmp;
> -  double min_timer = 0;
> -  int num_timers = 0;
> -#if 0
> -  DBG(("begin poll @%u", (unsigned int) (now * 1000)));
>   #endif
> -  mg_ev_mgr_lwip_process_signals(mgr);
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
> -    tmp = nc->next;
> -    n++;
> -    if (!mg_if_poll(nc, now)) continue;
> -    if (nc->sock != INVALID_SOCKET &&
> -        !(nc->flags & (MG_F_UDP | MG_F_LISTENING)) && cs->pcb.tcp != NULL &&
> -        cs->pcb.tcp->unsent != NULL) {
> -      mg_lwip_netif_run_on_tcpip(tcp_output_tcpip, cs->pcb.tcp);
> -    }
> -    if (nc->ev_timer_time > 0) {
> -      if (num_timers == 0 || nc->ev_timer_time < min_timer) {
> -        min_timer = nc->ev_timer_time;
> -      }
> -      num_timers++;
> -    }
>   
> -    if (nc->sock != INVALID_SOCKET) {
> -      if (mg_lwip_if_can_send(nc, cs)) {
> -        mg_if_can_send_cb(nc);
> -        mbuf_trim(&nc->send_mbuf);
> -      }
> -      if (cs->rx_chain != NULL) {
> -        mg_if_can_recv_cb(nc);
> -      } else if (cs->draining_rx_chain) {
> -        /*
> -         * If the connection is about to close, and rx_chain is finally empty,
> -         * send the MG_SIG_CLOSE_CONN signal
> -         */
> -        mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
> -      }
> +bool mg_globmatch(const char *s1, size_t n1, const char *s2, size_t n2) {
> +  size_t i = 0, j = 0, ni = 0, nj = 0;
> +  while (i < n1 || j < n2) {
> +    if (i < n1 && j < n2 && (s1[i] == '?' || s2[j] == s1[i])) {
> +      i++, j++;
> +    } else if (i < n1 && (s1[i] == '*' || s1[i] == '#')) {
> +      ni = i, nj = j + 1, i++;
> +    } else if (nj > 0 && nj <= n2 && (s1[ni] == '#' || s2[j] != '/')) {
> +      i = ni, j = nj;
> +    } else {
> +      // printf(">>: [%s] [%s] %d %d %d %d\n", s1, s2, i, j, ni, nj);
> +      return false;
>       }
>     }
> -#if 0
> -  DBG(("end poll @%u, %d conns, %d timers (min %u), next in %d ms",
> -       (unsigned int) (now * 1000), n, num_timers,
> -       (unsigned int) (min_timer * 1000), timeout_ms));
> -#endif
> -  (void) timeout_ms;
> -  return now;
> +  return true;
>   }
>   
> -#endif /* MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/wince/wince_libc.c"
> -#endif
> +static size_t mg_nce(const char *s, size_t n, size_t ofs, size_t *koff,
> +                     size_t *klen, size_t *voff, size_t *vlen) {
> +  size_t kvlen, kl;
> +  for (kvlen = 0; ofs + kvlen < n && s[ofs + kvlen] != ',';) kvlen++;
> +  for (kl = 0; kl < kvlen && s[ofs + kl] != '=';) kl++;
> +  if (koff != NULL) *koff = ofs;
> +  if (klen != NULL) *klen = kl;
> +  if (voff != NULL) *voff = kl < kvlen ? ofs + kl + 1 : 0;
> +  if (vlen != NULL) *vlen = kl < kvlen ? kvlen - kl - 1 : 0;
> +  ofs += kvlen + 1;
> +  return ofs > n ? n : ofs;
> +}
>   
> -#ifdef WINCE
> +bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v) {
> +  size_t koff = 0, klen = 0, voff = 0, vlen = 0;
> +  size_t off = mg_nce(s->ptr, s->len, 0, &koff, &klen, &voff, &vlen);
> +  if (k != NULL) *k = mg_str_n(s->ptr + koff, klen);
> +  if (v != NULL) *v = mg_str_n(s->ptr + voff, vlen);
> +  *s = mg_str_n(s->ptr + off, s->len - off);
> +  return off > 0;
> +}
>   
> -const char *strerror(int err) {
> -  /*
> -   * TODO(alashkin): there is no strerror on WinCE;
> -   * look for similar wce_xxxx function
> -   */
> -  static char buf[10];
> -  snprintf(buf, sizeof(buf), "%d", err);
> -  return buf;
> +uint32_t mg_ntohl(uint32_t net) {
> +  uint8_t data[4] = {0, 0, 0, 0};
> +  memcpy(&data, &net, sizeof(data));
> +  return (((uint32_t) data[3]) << 0) | (((uint32_t) data[2]) << 8) |
> +         (((uint32_t) data[1]) << 16) | (((uint32_t) data[0]) << 24);
>   }
>   
> -int open(const char *filename, int oflag, int pmode) {
> -  /*
> -   * TODO(alashkin): mg_open function is not used in mongoose
> -   * but exists in documentation as utility function
> -   * Shall we delete it at all or implement for WinCE as well?
> -   */
> -  DebugBreak();
> -  return 0; /* for compiler */
> +uint16_t mg_ntohs(uint16_t net) {
> +  uint8_t data[2] = {0, 0};
> +  memcpy(&data, &net, sizeof(data));
> +  return (uint16_t) ((uint16_t) data[1] | (((uint16_t) data[0]) << 8));
>   }
>   
> -int _wstati64(const wchar_t *path, cs_stat_t *st) {
> -  DWORD fa = GetFileAttributesW(path);
> -  if (fa == INVALID_FILE_ATTRIBUTES) {
> -    return -1;
> +char *mg_hexdump(const void *buf, size_t len) {
> +  const unsigned char *p = (const unsigned char *) buf;
> +  size_t i, idx, n = 0, ofs = 0, dlen = len * 5 + 100;
> +  char ascii[17] = "", *dst = (char *) calloc(1, dlen);
> +  if (dst == NULL) return dst;
> +  for (i = 0; i < len; i++) {
> +    idx = i % 16;
> +    if (idx == 0) {
> +      if (i > 0 && dlen > n)
> +        n += (size_t) snprintf(dst + n, dlen - n, "  %s\n", ascii);
> +      if (dlen > n)
> +        n += (size_t) snprintf(dst + n, dlen - n, "%04x ", (int) (i + ofs));
> +    }
> +    if (dlen < n) break;
> +    n += (size_t) snprintf(dst + n, dlen - n, " %02x", p[i]);
> +    ascii[idx] = (char) (p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i]);
> +    ascii[idx + 1] = '\0';
>     }
> -  memset(st, 0, sizeof(*st));
> -  if ((fa & FILE_ATTRIBUTE_DIRECTORY) == 0) {
> -    HANDLE h;
> -    FILETIME ftime;
> -    st->st_mode |= _S_IFREG;
> -    h = CreateFileW(path, GENERIC_READ, 0, NULL, OPEN_EXISTING,
> -                    FILE_ATTRIBUTE_NORMAL, NULL);
> -    if (h == INVALID_HANDLE_VALUE) {
> -      return -1;
> -    }
> -    st->st_size = GetFileSize(h, NULL);
> -    GetFileTime(h, NULL, NULL, &ftime);
> -    st->st_mtime = (uint32_t)((((uint64_t) ftime.dwLowDateTime +
> -                                ((uint64_t) ftime.dwHighDateTime << 32)) /
> -                               10000000.0) -
> -                              11644473600);
> -    CloseHandle(h);
> -  } else {
> -    st->st_mode |= _S_IFDIR;
> +  while (i++ % 16) {
> +    if (n < dlen) n += (size_t) snprintf(dst + n, dlen - n, "%s", "   ");
>     }
> -  return 0;
> +  if (n < dlen) n += (size_t) snprintf(dst + n, dlen - n, "  %s\n", ascii);
> +  if (n > dlen - 1) n = dlen - 1;
> +  dst[n] = '\0';
> +  return dst;
>   }
>   
> -/* Windows CE doesn't have neither gmtime nor strftime */
> -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t) {
> -  FILETIME ft;
> -  SYSTEMTIME systime;
> -  if (t != NULL) {
> -    uint64_t filetime = (*t + 11644473600) * 10000000;
> -    ft.dwLowDateTime = filetime & 0xFFFFFFFF;
> -    ft.dwHighDateTime = (filetime & 0xFFFFFFFF00000000) >> 32;
> -    FileTimeToSystemTime(&ft, &systime);
> -  } else {
> -    GetSystemTime(&systime);
> +char *mg_hex(const void *buf, size_t len, char *to) {
> +  const unsigned char *p = (const unsigned char *) buf;
> +  static const char *hex = "0123456789abcdef";
> +  size_t i = 0;
> +  for (; len--; p++) {
> +    to[i++] = hex[p[0] >> 4];
> +    to[i++] = hex[p[0] & 0x0f];
>     }
> -  /* There is no PRIu16 in WinCE SDK */
> -  snprintf(buf, buf_len, "%d.%d.%d %d:%d:%d GMT", (int) systime.wYear,
> -           (int) systime.wMonth, (int) systime.wDay, (int) systime.wHour,
> -           (int) systime.wMinute, (int) systime.wSecond);
> +  to[i] = '\0';
> +  return to;
>   }
>   
> -#endif
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/pic32/pic32_net_if.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PIC32_NET_IF_H_
> -#define CS_COMMON_PLATFORMS_PIC32_NET_IF_H_
> -
> -/* Amalgamated: #include "mongoose/src/net_if.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -#ifndef MG_ENABLE_NET_IF_PIC32
> -#define MG_ENABLE_NET_IF_PIC32 MG_NET_IF == MG_NET_IF_PIC32
> -#endif
> +static unsigned char mg_unhex_nimble(unsigned char c) {
> +  return (c >= '0' && c <= '9')   ? (unsigned char) (c - '0')
> +         : (c >= 'A' && c <= 'F') ? (unsigned char) (c - '7')
> +                                  : (unsigned char) (c - 'W');
> +}
>   
> -extern const struct mg_iface_vtable mg_pic32_iface_vtable;
> +unsigned long mg_unhexn(const char *s, size_t len) {
> +  unsigned long i = 0, v = 0;
> +  for (i = 0; i < len; i++) v <<= 4, v |= mg_unhex_nimble(((uint8_t *) s)[i]);
> +  return v;
> +}
>   
> -#ifdef __cplusplus
> +void mg_unhex(const char *buf, size_t len, unsigned char *to) {
> +  size_t i;
> +  for (i = 0; i < len; i += 2) {
> +    to[i >> 1] = (unsigned char) mg_unhexn(&buf[i], 2);
> +  }
>   }
> -#endif /* __cplusplus */
>   
> -#endif /* CS_COMMON_PLATFORMS_PIC32_NET_IF_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/pic32/pic32_net_if.c"
> -#endif
> +int mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap) {
> +  va_list ap_copy;
> +  int len;
>   
> -#if MG_ENABLE_NET_IF_PIC32
> +  va_copy(ap_copy, ap);
> +  len = vsnprintf(*buf, size, fmt, ap_copy);
> +  va_end(ap_copy);
>   
> -int mg_pic32_if_create_conn(struct mg_connection *nc) {
> -  (void) nc;
> -  return 1;
> -}
> +  if (len < 0) {
> +    // eCos and Windows are not standard-compliant and return -1 when
> +    // the buffer is too small. Keep allocating larger buffers until we
> +    // succeed or out of memory.
> +    // LCOV_EXCL_START
> +    *buf = NULL;
> +    while (len < 0) {
> +      free(*buf);
> +      if (size == 0) size = 5;
> +      size *= 2;
> +      if ((*buf = (char *) calloc(1, size)) == NULL) {
> +        len = -1;
> +        break;
> +      }
> +      va_copy(ap_copy, ap);
> +      len = vsnprintf(*buf, size - 1, fmt, ap_copy);
> +      va_end(ap_copy);
> +    }
> +    // Microsoft version of vsnprintf() is not always null-terminated, so put
> +    // the terminator manually
> +    if (*buf != NULL) (*buf)[len] = 0;
> +    // LCOV_EXCL_STOP
> +  } else if (len >= (int) size) {
> +    /// Standard-compliant code path. Allocate a buffer that is large enough
> +    if ((*buf = (char *) calloc(1, (size_t) len + 1)) == NULL) {
> +      len = -1;  // LCOV_EXCL_LINE
> +    } else {     // LCOV_EXCL_LINE
> +      va_copy(ap_copy, ap);
> +      len = vsnprintf(*buf, (size_t) len + 1, fmt, ap_copy);
> +      va_end(ap_copy);
> +    }
> +  }
>   
> -void mg_pic32_if_recved(struct mg_connection *nc, size_t len) {
> -  (void) nc;
> -  (void) len;
> +  return len;
>   }
>   
> -void mg_pic32_if_add_conn(struct mg_connection *nc) {
> -  (void) nc;
> +int mg_asprintf(char **buf, size_t size, const char *fmt, ...) {
> +  int ret;
> +  va_list ap;
> +  va_start(ap, fmt);
> +  ret = mg_vasprintf(buf, size, fmt, ap);
> +  va_end(ap);
> +  return ret;
>   }
>   
> -void mg_pic32_if_init(struct mg_iface *iface) {
> -  (void) iface;
> -  (void) mg_get_errno(); /* Shutup compiler */
> +int64_t mg_to64(struct mg_str str) {
> +  int64_t result = 0, neg = 1, max = 922337203685477570 /* INT64_MAX/10-10 */;
> +  size_t i = 0;
> +  while (i < str.len && (str.ptr[i] == ' ' || str.ptr[i] == '\t')) i++;
> +  if (i < str.len && str.ptr[i] == '-') neg = -1, i++;
> +  while (i < str.len && str.ptr[i] >= '0' && str.ptr[i] <= '9') {
> +    if (result > max) return 0;
> +    result *= 10;
> +    result += (str.ptr[i] - '0');
> +    i++;
> +  }
> +  return result * neg;
>   }
>   
> -void mg_pic32_if_free(struct mg_iface *iface) {
> -  (void) iface;
> +uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len) {
> +  int i;
> +  crc = ~crc;
> +  while (len--) {
> +    crc ^= *(unsigned char *) buf++;
> +    for (i = 0; i < 8; i++) crc = crc & 1 ? (crc >> 1) ^ 0xedb88320 : crc >> 1;
> +  }
> +  return ~crc;
>   }
>   
> -void mg_pic32_if_remove_conn(struct mg_connection *nc) {
> -  (void) nc;
> +static int isbyte(int n) {
> +  return n >= 0 && n <= 255;
>   }
>   
> -void mg_pic32_if_destroy_conn(struct mg_connection *nc) {
> -  if (nc->sock == INVALID_SOCKET) return;
> -  /* For UDP, only close outgoing sockets or listeners. */
> -  if (!(nc->flags & MG_F_UDP)) {
> -    /* Close TCP */
> -    TCPIP_TCP_Close((TCP_SOCKET) nc->sock);
> -  } else if (nc->listener == NULL) {
> -    /* Only close outgoing UDP or listeners. */
> -    TCPIP_UDP_Close((UDP_SOCKET) nc->sock);
> +static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) {
> +  int n, a, b, c, d, slash = 32, len = 0;
> +  if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
> +       sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
> +      isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 &&
> +      slash < 33) {
> +    len = n;
> +    *net = ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) |
> +           (uint32_t) d;
> +    *mask = slash ? (uint32_t) (0xffffffffU << (32 - slash)) : (uint32_t) 0;
>     }
> -
> -  nc->sock = INVALID_SOCKET;
> +  return len;
>   }
>   
> -int mg_pic32_if_listen_udp(struct mg_connection *nc, union socket_address *sa) {
> -  nc->sock = TCPIP_UDP_ServerOpen(
> -      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
> -                                    : IP_ADDRESS_TYPE_IPV6,
> -      ntohs(sa->sin.sin_port),
> -      sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin);
> -  if (nc->sock == INVALID_SOCKET) {
> -    return -1;
> +int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip) {
> +  struct mg_str k, v;
> +  int allowed = acl.len == 0 ? '+' : '-';  // If any ACL is set, deny by default
> +  while (mg_commalist(&acl, &k, &v)) {
> +    uint32_t net, mask;
> +    if (k.ptr[0] != '+' && k.ptr[0] != '-') return -1;
> +    if (parse_net(&k.ptr[1], &net, &mask) == 0) return -2;
> +    if ((remote_ip & mask) == net) allowed = k.ptr[0];
>     }
> -  return 0;
> +  return allowed == '+';
>   }
>   
> -void mg_pic32_if_udp_send(struct mg_connection *nc, const void *buf,
> -                          size_t len) {
> -  mbuf_append(&nc->send_mbuf, buf, len);
> +double mg_time(void) {
> +#if MG_ARCH == MG_ARCH_WIN32
> +  SYSTEMTIME sysnow;
> +  FILETIME ftime;
> +  GetLocalTime(&sysnow);
> +  SystemTimeToFileTime(&sysnow, &ftime);
> +  /*
> +   * 1. VC 6.0 doesn't support conversion uint64 -> double, so, using int64
> +   * This should not cause a problems in this (21th) century
> +   * 2. Windows FILETIME is a number of 100-nanosecond intervals since January
> +   * 1, 1601 while time_t is a number of _seconds_ since January 1, 1970 UTC,
> +   * thus, we need to convert to seconds and adjust amount (subtract 11644473600
> +   * seconds)
> +   */
> +  return (double) (((int64_t) ftime.dwLowDateTime +
> +                    ((int64_t) ftime.dwHighDateTime << 32)) /
> +                   10000000.0) -
> +         11644473600;
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_AZURERTOS
> +  return mg_millis() / 1000.0;
> +#else
> +  struct timeval tv;
> +  if (gettimeofday(&tv, NULL /* tz */) != 0) return 0;
> +  return (double) tv.tv_sec + (((double) tv.tv_usec) / 1000000.0);
> +#endif /* _WIN32 */
>   }
>   
> -void mg_pic32_if_tcp_send(struct mg_connection *nc, const void *buf,
> -                          size_t len) {
> -  mbuf_append(&nc->send_mbuf, buf, len);
> +void mg_usleep(unsigned long usecs) {
> +#if MG_ARCH == MG_ARCH_WIN32
> +  Sleep(usecs / 1000);
> +#elif MG_ARCH == MG_ARCH_ESP8266
> +  ets_delay_us(usecs);
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_FREERTOS_LWIP
> +  vTaskDelay(pdMS_TO_TICKS(usecs / 1000));
> +#elif MG_ARCH == MG_ARCH_AZURERTOS
> +  tx_thread_sleep((usecs / 1000) * TX_TIMER_TICKS_PER_SECOND);
> +#else
> +  usleep((useconds_t) usecs);
> +#endif
>   }
>   
> -int mg_pic32_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) {
> -  nc->sock = TCPIP_TCP_ServerOpen(
> -      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
> -                                    : IP_ADDRESS_TYPE_IPV6,
> -      ntohs(sa->sin.sin_port),
> -      sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin);
> -  memcpy(&nc->sa, sa, sizeof(*sa));
> -  if (nc->sock == INVALID_SOCKET) {
> -    return -1;
> -  }
> -  return 0;
> +unsigned long mg_millis(void) {
> +#if MG_ARCH == MG_ARCH_WIN32
> +  return GetTickCount();
> +#elif MG_ARCH == MG_ARCH_ESP32
> +  return esp_timer_get_time() / 1000;
> +#elif MG_ARCH == MG_ARCH_ESP8266
> +  return xTaskGetTickCount() * portTICK_PERIOD_MS;
> +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_FREERTOS_LWIP
> +  return xTaskGetTickCount() * portTICK_PERIOD_MS;
> +#elif MG_ARCH == MG_ARCH_AZURERTOS
> +  return tx_time_get() * (1000 /* MS per SEC */ / TX_TIMER_TICKS_PER_SECOND);
> +#else
> +  struct timespec ts;
> +  clock_gettime(CLOCK_REALTIME, &ts);
> +  return (unsigned long) ((uint64_t) ts.tv_sec * 1000 +
> +                          (uint64_t) ts.tv_nsec / 1000000);
> +#endif
>   }
>   
> -static int mg_accept_conn(struct mg_connection *lc) {
> -  struct mg_connection *nc;
> -  TCP_SOCKET_INFO si;
> -  union socket_address sa;
> +#ifdef MG_ENABLE_LINES
> +#line 1 "src/ws.c"
> +#endif
>   
> -  nc = mg_if_accept_new_conn(lc);
>   
> -  if (nc == NULL) {
> -    return 0;
> -  }
>   
> -  nc->sock = lc->sock;
> -  nc->flags &= ~MG_F_LISTENING;
>   
> -  if (!TCPIP_TCP_SocketInfoGet((TCP_SOCKET) nc->sock, &si)) {
> -    return 0;
> -  }
>   
> -  if (si.addressType == IP_ADDRESS_TYPE_IPV4) {
> -    sa.sin.sin_family = AF_INET;
> -    sa.sin.sin_port = htons(si.remotePort);
> -    sa.sin.sin_addr.s_addr = si.remoteIPaddress.v4Add.Val;
> -  } else {
> -    /* TODO(alashkin): do something with _potential_ IPv6 */
> -    memset(&sa, 0, sizeof(sa));
> -  }
>   
> -  mg_if_accept_tcp_cb(nc, (union socket_address *) &sa, sizeof(sa));
>   
> -  return mg_pic32_if_listen_tcp(lc, &lc->sa) >= 0;
> -}
>   
> -char *inet_ntoa(struct in_addr in) {
> -  static char addr[17];
> -  snprintf(addr, sizeof(addr), "%d.%d.%d.%d", (int) in.S_un.S_un_b.s_b1,
> -           (int) in.S_un.S_un_b.s_b2, (int) in.S_un.S_un_b.s_b3,
> -           (int) in.S_un.S_un_b.s_b4);
> -  return addr;
> -}
>   
> -static void mg_handle_send(struct mg_connection *nc) {
> -  uint16_t bytes_written = 0;
> -  if (nc->flags & MG_F_UDP) {
> -    if (!TCPIP_UDP_RemoteBind(
> -            (UDP_SOCKET) nc->sock,
> -            nc->sa.sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
> -                                             : IP_ADDRESS_TYPE_IPV6,
> -            ntohs(nc->sa.sin.sin_port), (IP_MULTI_ADDRESS *) &nc->sa.sin)) {
> -      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -      return;
> -    }
> -    bytes_written = TCPIP_UDP_TxPutIsReady((UDP_SOCKET) nc->sock, 0);
> -    if (bytes_written >= nc->send_mbuf.len) {
> -      if (TCPIP_UDP_ArrayPut((UDP_SOCKET) nc->sock,
> -                             (uint8_t *) nc->send_mbuf.buf,
> -                             nc->send_mbuf.len) != nc->send_mbuf.len) {
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        bytes_written = 0;
> -      }
> -    }
> -  } else {
> -    bytes_written = TCPIP_TCP_FifoTxFreeGet((TCP_SOCKET) nc->sock);
> -    if (bytes_written != 0) {
> -      if (bytes_written > nc->send_mbuf.len) {
> -        bytes_written = nc->send_mbuf.len;
> -      }
> -      if (TCPIP_TCP_ArrayPut((TCP_SOCKET) nc->sock,
> -                             (uint8_t *) nc->send_mbuf.buf,
> -                             bytes_written) != bytes_written) {
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        bytes_written = 0;
> -      }
> -    }
> -  }
>   
> -  mg_if_sent_cb(nc, bytes_written);
> +struct ws_msg {
> +  uint8_t flags;
> +  size_t header_len;
> +  size_t data_len;
> +};
> +
> +static void ws_handshake(struct mg_connection *c, const struct mg_str *wskey,
> +                         const struct mg_str *wsproto, const char *fmt,
> +                         va_list ap) {
> +  const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
> +  unsigned char sha[20], b64_sha[30];
> +  char mem[128], *buf = mem;
> +
> +  mg_sha1_ctx sha_ctx;
> +  mg_sha1_init(&sha_ctx);
> +  mg_sha1_update(&sha_ctx, (unsigned char *) wskey->ptr, wskey->len);
> +  mg_sha1_update(&sha_ctx, (unsigned char *) magic, 36);
> +  mg_sha1_final(sha, &sha_ctx);
> +  mg_base64_encode(sha, sizeof(sha), (char *) b64_sha);
> +  buf[0] = '\0';
> +  if (fmt != NULL) mg_vasprintf(&buf, sizeof(mem), fmt, ap);
> +  mg_printf(c,
> +            "HTTP/1.1 101 Switching Protocols\r\n"
> +            "Upgrade: websocket\r\n"
> +            "Connection: Upgrade\r\n"
> +            "Sec-WebSocket-Accept: %s\r\n"
> +            "%s",
> +            b64_sha, buf);
> +  if (buf != mem) free(buf);
> +  if (wsproto != NULL) {
> +    mg_printf(c, "Sec-WebSocket-Protocol: %.*s\r\n", (int) wsproto->len,
> +              wsproto->ptr);
> +  }
> +  mg_send(c, "\r\n", 2);
>   }
>   
> -static void mg_handle_recv(struct mg_connection *nc) {
> -  uint16_t bytes_read = 0;
> -  uint8_t *buf = NULL;
> -  if (nc->flags & MG_F_UDP) {
> -    bytes_read = TCPIP_UDP_GetIsReady((UDP_SOCKET) nc->sock);
> -    if (bytes_read != 0 &&
> -        (nc->recv_mbuf_limit == -1 ||
> -         nc->recv_mbuf.len + bytes_read < nc->recv_mbuf_limit)) {
> -      buf = (uint8_t *) MG_MALLOC(bytes_read);
> -      if (TCPIP_UDP_ArrayGet((UDP_SOCKET) nc->sock, buf, bytes_read) !=
> -          bytes_read) {
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        bytes_read = 0;
> -        MG_FREE(buf);
> -      }
> -    }
> +static size_t ws_process(uint8_t *buf, size_t len, struct ws_msg *msg) {
> +  size_t i, n = 0, mask_len = 0;
> +  memset(msg, 0, sizeof(*msg));
> +  if (len >= 2) {
> +    n = buf[1] & 0x7f;                // Frame length
> +    mask_len = buf[1] & 128 ? 4 : 0;  // last bit is a mask bit
> +    msg->flags = buf[0];
> +    if (n < 126 && len >= mask_len) {
> +      msg->data_len = n;
> +      msg->header_len = 2 + mask_len;
> +    } else if (n == 126 && len >= 4 + mask_len) {
> +      msg->header_len = 4 + mask_len;
> +      msg->data_len = mg_ntohs(*(uint16_t *) &buf[2]);
> +    } else if (len >= 10 + mask_len) {
> +      msg->header_len = 10 + mask_len;
> +      msg->data_len =
> +          (size_t) (((uint64_t) mg_ntohl(*(uint32_t *) &buf[2])) << 32) +
> +          mg_ntohl(*(uint32_t *) &buf[6]);
> +    }
> +  }
> +  // Sanity check, and integer overflow protection for the boundary check below
> +  // data_len should not be larger than 1 Gb
> +  if (msg->data_len > 1024 * 1024 * 1024) return 0;
> +  if (msg->header_len + msg->data_len > len) return 0;
> +  if (mask_len > 0) {
> +    uint8_t *p = buf + msg->header_len, *m = p - mask_len;
> +    for (i = 0; i < msg->data_len; i++) p[i] ^= m[i & 3];
> +  }
> +  return msg->header_len + msg->data_len;
> +}
> +
> +static size_t mkhdr(size_t len, int op, bool is_client, uint8_t *buf) {
> +  size_t n = 0;
> +  buf[0] = (uint8_t) (op | 128);
> +  if (len < 126) {
> +    buf[1] = (unsigned char) len;
> +    n = 2;
> +  } else if (len < 65536) {
> +    uint16_t tmp = mg_htons((uint16_t) len);
> +    buf[1] = 126;
> +    memcpy(&buf[2], &tmp, sizeof(tmp));
> +    n = 4;
>     } else {
> -    bytes_read = TCPIP_TCP_GetIsReady((TCP_SOCKET) nc->sock);
> -    if (bytes_read != 0) {
> -      if (nc->recv_mbuf_limit != -1 &&
> -          nc->recv_mbuf_limit - nc->recv_mbuf.len > bytes_read) {
> -        bytes_read = nc->recv_mbuf_limit - nc->recv_mbuf.len;
> -      }
> -      buf = (uint8_t *) MG_MALLOC(bytes_read);
> -      if (TCPIP_TCP_ArrayGet((TCP_SOCKET) nc->sock, buf, bytes_read) !=
> -          bytes_read) {
> -        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
> -        MG_FREE(buf);
> -        bytes_read = 0;
> -      }
> -    }
> +    uint32_t tmp;
> +    buf[1] = 127;
> +    tmp = mg_htonl((uint32_t) ((uint64_t) len >> 32));
> +    memcpy(&buf[2], &tmp, sizeof(tmp));
> +    tmp = mg_htonl((uint32_t) (len & 0xffffffff));
> +    memcpy(&buf[6], &tmp, sizeof(tmp));
> +    n = 10;
> +  }
> +  if (is_client) {
> +    buf[1] |= 1 << 7;  // Set masking flag
> +    mg_random(&buf[n], 4);
> +    n += 4;
>     }
> +  return n;
> +}
>   
> -  if (bytes_read != 0) {
> -    mg_if_recv_tcp_cb(nc, buf, bytes_read, 1 /* own */);
> +static void mg_ws_mask(struct mg_connection *c, size_t len) {
> +  if (c->is_client && c->send.buf != NULL) {
> +    size_t i;
> +    uint8_t *p = c->send.buf + c->send.len - len, *mask = p - 4;
> +    for (i = 0; i < len; i++) p[i] ^= mask[i & 3];
>     }
>   }
>   
> -time_t mg_pic32_if_poll(struct mg_iface *iface, int timeout_ms) {
> -  struct mg_mgr *mgr = iface->mgr;
> -  double now = mg_time();
> -  struct mg_connection *nc, *tmp;
> +size_t mg_ws_send(struct mg_connection *c, const char *buf, size_t len,
> +                  int op) {
> +  uint8_t header[14];
> +  size_t header_len = mkhdr(len, op, c->is_client, header);
> +  mg_send(c, header, header_len);
> +  LOG(LL_VERBOSE_DEBUG, ("WS out: %d [%.*s]", (int) len, (int) len, buf));
> +  mg_send(c, buf, len);
> +  mg_ws_mask(c, len);
> +  return header_len + len;
> +}
>   
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    tmp = nc->next;
> +static void mg_ws_cb(struct mg_connection *c, int ev, void *ev_data,
> +                     void *fn_data) {
> +  struct ws_msg msg;
> +  size_t ofs = (size_t) c->pfn_data;
>   
> -    if (nc->flags & MG_F_CONNECTING) {
> -      /* processing connections */
> -      if (nc->flags & MG_F_UDP ||
> -          TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) {
> -        mg_if_connect_cb(nc, 0);
> -      }
> -    } else if (nc->flags & MG_F_LISTENING) {
> -      if (TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) {
> -        /* accept new connections */
> -        mg_accept_conn(nc);
> -      }
> -    } else {
> -      if (nc->send_mbuf.len != 0) {
> -        mg_handle_send(nc);
> +  // assert(ofs < c->recv.len);
> +  if (ev == MG_EV_READ) {
> +    if (!c->is_websocket && c->is_client) {
> +      int n = mg_http_get_request_len(c->recv.buf, c->recv.len);
> +      if (n < 0) {
> +        c->is_closing = 1;  // Some just, not an HTTP request
> +      } else if (n > 0) {
> +        if (n < 15 || memcmp(c->recv.buf + 9, "101", 3) != 0) {
> +          LOG(LL_ERROR,
> +              ("%lu WS handshake error: %.*s", c->id, 15, c->recv.buf));
> +          c->is_closing = 1;
> +        } else {
> +          struct mg_http_message hm;
> +          mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
> +          c->is_websocket = 1;
> +          mg_call(c, MG_EV_WS_OPEN, &hm);
> +        }
> +        mg_iobuf_del(&c->recv, 0, (size_t) n);
> +      } else {
> +        return;  // A request is not yet received
>         }
> +    }
>   
> -      if (nc->recv_mbuf_limit == -1 ||
> -          nc->recv_mbuf.len < nc->recv_mbuf_limit) {
> -        mg_handle_recv(nc);
> +    while (ws_process(c->recv.buf + ofs, c->recv.len - ofs, &msg) > 0) {
> +      char *s = (char *) c->recv.buf + ofs + msg.header_len;
> +      struct mg_ws_message m = {{s, msg.data_len}, msg.flags};
> +      size_t len = msg.header_len + msg.data_len;
> +      uint8_t final = msg.flags & 128, op = msg.flags & 15;
> +      // LOG(LL_VERBOSE_DEBUG, ("fin %d op %d len %d [%.*s]", final, op,
> +      //                       (int) m.data.len, (int) m.data.len, m.data.ptr));
> +      switch (op) {
> +        case WEBSOCKET_OP_CONTINUE:
> +          mg_call(c, MG_EV_WS_CTL, &m);
> +          break;
> +        case WEBSOCKET_OP_PING:
> +          LOG(LL_DEBUG, ("%s", "WS PONG"));
> +          mg_ws_send(c, s, msg.data_len, WEBSOCKET_OP_PONG);
> +          mg_call(c, MG_EV_WS_CTL, &m);
> +          break;
> +        case WEBSOCKET_OP_PONG:
> +          mg_call(c, MG_EV_WS_CTL, &m);
> +          break;
> +        case WEBSOCKET_OP_TEXT:
> +        case WEBSOCKET_OP_BINARY:
> +          if (final) mg_call(c, MG_EV_WS_MSG, &m);
> +          break;
> +        case WEBSOCKET_OP_CLOSE:
> +          LOG(LL_ERROR, ("%lu Got WS CLOSE", c->id));
> +          mg_call(c, MG_EV_WS_CTL, &m);
> +          c->is_closing = 1;
> +          break;
> +        default:
> +          // Per RFC6455, close conn when an unknown op is recvd
> +          mg_error(c, "unknown WS op %d", op);
> +          break;
>         }
> -    }
> -  }
>   
> -  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
> -    tmp = nc->next;
> -    if ((nc->flags & MG_F_CLOSE_IMMEDIATELY) ||
> -        (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE))) {
> -      mg_close_conn(nc);
> +      // Handle fragmented frames: strip header, keep in c->recv
> +      if (final == 0 || op == 0) {
> +        if (op) ofs++, len--, msg.header_len--;       // First frame
> +        mg_iobuf_del(&c->recv, ofs, msg.header_len);  // Strip header
> +        len -= msg.header_len;
> +        ofs += len;
> +        c->pfn_data = (void *) ofs;
> +        // LOG(LL_INFO, ("FRAG %d [%.*s]", (int) ofs, (int) ofs, c->recv.buf));
> +      }
> +      // Remove non-fragmented frame
> +      if (final && op) mg_iobuf_del(&c->recv, ofs, len);
> +      // Last chunk of the fragmented frame
> +      if (final && !op) {
> +        m.flags = c->recv.buf[0];
> +        m.data = mg_str_n((char *) &c->recv.buf[1], (size_t) (ofs - 1));
> +        mg_call(c, MG_EV_WS_MSG, &m);
> +        mg_iobuf_del(&c->recv, 0, ofs);
> +        ofs = 0;
> +        c->pfn_data = NULL;
> +      }
>       }
>     }
> -
> -  return now;
> -}
> -
> -void mg_pic32_if_sock_set(struct mg_connection *nc, sock_t sock) {
> -  nc->sock = sock;
> -}
> -
> -void mg_pic32_if_get_conn_addr(struct mg_connection *nc, int remote,
> -                               union socket_address *sa) {
> -  /* TODO(alaskin): not implemented yet */
> -}
> -
> -void mg_pic32_if_connect_tcp(struct mg_connection *nc,
> -                             const union socket_address *sa) {
> -  nc->sock = TCPIP_TCP_ClientOpen(
> -      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
> -                                    : IP_ADDRESS_TYPE_IPV6,
> -      ntohs(sa->sin.sin_port), (IP_MULTI_ADDRESS *) &sa->sin);
> -  nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0;
> +  (void) fn_data;
> +  (void) ev_data;
>   }
>   
> -void mg_pic32_if_connect_udp(struct mg_connection *nc) {
> -  nc->sock = TCPIP_UDP_ClientOpen(IP_ADDRESS_TYPE_ANY, 0, NULL);
> -  nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0;
> +struct mg_connection *mg_ws_connect(struct mg_mgr *mgr, const char *url,
> +                                    mg_event_handler_t fn, void *fn_data,
> +                                    const char *fmt, ...) {
> +  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
> +  if (c != NULL) {
> +    char nonce[16], key[30], mem1[128], mem2[256], *buf1 = mem1, *buf2 = mem2;
> +    struct mg_str host = mg_url_host(url);
> +    int n1 = 0, n2 = 0;
> +    if (fmt != NULL) {
> +      va_list ap;
> +      va_start(ap, fmt);
> +      n1 = mg_vasprintf(&buf1, sizeof(mem1), fmt, ap);
> +      va_end(ap);
> +    }
> +    // Send handshake request
> +    // mg_url_host(url, host, sizeof(host));
> +    mg_random(nonce, sizeof(nonce));
> +    mg_base64_encode((unsigned char *) nonce, sizeof(nonce), key);
> +    // LOG(LL_DEBUG, "%p [%s]", uri, uri == NULL ? "???" : uri);
> +    n2 = mg_asprintf(&buf2, sizeof(mem2),
> +                     "GET %s HTTP/1.1\r\n"
> +                     "Upgrade: websocket\r\n"
> +                     "Host: %.*s\r\n"
> +                     "Connection: Upgrade\r\n"
> +                     "%.*s"
> +                     "Sec-WebSocket-Version: 13\r\n"
> +                     "Sec-WebSocket-Key: %s\r\n"
> +                     "\r\n",
> +                     mg_url_uri(url), (int) host.len, host.ptr, n1, buf1, key);
> +    mg_send(c, buf2, n2 > 0 ? (size_t) n2 : 0);
> +    if (buf1 != mem1) free(buf1);
> +    if (buf2 != mem2) free(buf2);
> +    c->pfn = mg_ws_cb;
> +    c->pfn_data = NULL;
> +  }
> +  return c;
>   }
>   
> -/* clang-format off */
> -#define MG_PIC32_IFACE_VTABLE                                   \
> -  {                                                             \
> -    mg_pic32_if_init,                                           \
> -    mg_pic32_if_free,                                           \
> -    mg_pic32_if_add_conn,                                       \
> -    mg_pic32_if_remove_conn,                                    \
> -    mg_pic32_if_poll,                                           \
> -    mg_pic32_if_listen_tcp,                                     \
> -    mg_pic32_if_listen_udp,                                     \
> -    mg_pic32_if_connect_tcp,                                    \
> -    mg_pic32_if_connect_udp,                                    \
> -    mg_pic32_if_tcp_send,                                       \
> -    mg_pic32_if_udp_send,                                       \
> -    mg_pic32_if_recved,                                         \
> -    mg_pic32_if_create_conn,                                    \
> -    mg_pic32_if_destroy_conn,                                   \
> -    mg_pic32_if_sock_set,                                       \
> -    mg_pic32_if_get_conn_addr,                                  \
> +void mg_ws_upgrade(struct mg_connection *c, struct mg_http_message *hm,
> +                   const char *fmt, ...) {
> +  struct mg_str *wskey = mg_http_get_header(hm, "Sec-WebSocket-Key");
> +  c->pfn = mg_ws_cb;
> +  c->pfn_data = NULL;
> +  if (wskey == NULL) {
> +    mg_http_reply(c, 426, "", "WS upgrade expected\n");
> +    c->is_draining = 1;
> +  } else {
> +    struct mg_str *wsproto = mg_http_get_header(hm, "Sec-WebSocket-Protocol");
> +    va_list ap;
> +    va_start(ap, fmt);
> +    ws_handshake(c, wskey, wsproto, fmt, ap);
> +    va_end(ap);
> +    c->is_websocket = 1;
> +    mg_call(c, MG_EV_WS_OPEN, hm);
>     }
> -/* clang-format on */
> -
> -const struct mg_iface_vtable mg_pic32_iface_vtable = MG_PIC32_IFACE_VTABLE;
> -#if MG_NET_IF == MG_NET_IF_PIC32
> -const struct mg_iface_vtable mg_default_iface_vtable = MG_PIC32_IFACE_VTABLE;
> -#endif
> -
> -#endif /* MG_ENABLE_NET_IF_PIC32 */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/windows/windows_direct.c"
> -#endif
> +}
>   
> -#ifdef _WIN32
> +size_t mg_ws_wrap(struct mg_connection *c, size_t len, int op) {
> +  uint8_t header[14], *p;
> +  size_t header_len = mkhdr(len, op, c->is_client, header);
>   
> -int rmdir(const char *dirname) {
> -  return _rmdir(dirname);
> -}
> +  // NOTE: order of operations is important!
> +  mg_iobuf_add(&c->send, c->send.len, NULL, header_len, MG_IO_SIZE);
> +  p = &c->send.buf[c->send.len - len];         // p points to data
> +  memmove(p, p - header_len, len);             // Shift data
> +  memcpy(p - header_len, header, header_len);  // Prepend header
> +  mg_ws_mask(c, len);                          // Mask data
>   
> -unsigned int sleep(unsigned int seconds) {
> -  Sleep(seconds * 1000);
> -  return 0;
> +  return c->send.len;
>   }
> -
> -#endif /* _WIN32 */
> diff --git a/mongoose/mongoose.h b/mongoose/mongoose.h
> index 6a095cb..55a828c 100644
> --- a/mongoose/mongoose.h
> +++ b/mongoose/mongoose.h
> @@ -1,6279 +1,1051 @@
> -/*
> - * Copyright (c) 2004-2013 Sergey Lyubka
> - * Copyright (c) 2013-2020 Cesanta Software Limited
> - * All rights reserved
> - *
> - * SPDX-License-Identifier: GPL-2.0-only
> - *
> - * This software is dual-licensed: you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License version 2 as
> - * published by the Free Software Foundation. For the terms of this
> - * license, see <http://www.gnu.org/licenses/>.
> - *
> - * You are free to use this software under the terms of the GNU General
> - * Public License, but WITHOUT ANY WARRANTY; without even the implied
> - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> - * See the GNU General Public License for more details.
> - *
> - * Alternatively, you can license this software under a commercial
> - * license, as set out in <https://www.cesanta.com/license>.
> - */
> -
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_common.h"
> -#endif
> -#ifndef CS_MONGOOSE_SRC_COMMON_H_
> -#define CS_MONGOOSE_SRC_COMMON_H_
> -
> -#define MG_VERSION "6.18"
> -
> -/* Local tweaks, applied before any of Mongoose's own headers. */
> -#ifdef MG_LOCALS
> -#include <mg_locals.h>
> -#endif
> -
> -#endif /* CS_MONGOOSE_SRC_COMMON_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platform.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORM_H_
> -#define CS_COMMON_PLATFORM_H_
> -
> -/*
> - * For the "custom" platform, includes and dependencies can be
> - * provided through mg_locals.h.
> - */
> -#define CS_P_CUSTOM 0
> -#define CS_P_UNIX 1
> -#define CS_P_WINDOWS 2
> -#define CS_P_ESP32 15
> -#define CS_P_ESP8266 3
> -#define CS_P_CC3100 6
> -#define CS_P_CC3200 4
> -#define CS_P_CC3220 17
> -#define CS_P_MSP432 5
> -#define CS_P_TM4C129 14
> -#define CS_P_MBED 7
> -#define CS_P_WINCE 8
> -#define CS_P_NXP_LPC 13
> -#define CS_P_NXP_KINETIS 9
> -#define CS_P_NRF51 12
> -#define CS_P_NRF52 10
> -#define CS_P_PIC32 11
> -#define CS_P_RS14100 18
> -#define CS_P_STM32 16
> -/* Next id: 19 */
> -
> -/* If not specified explicitly, we guess platform by defines. */
> -#ifndef CS_PLATFORM
> -
> -#if defined(TARGET_IS_MSP432P4XX) || defined(__MSP432P401R__)
> -#define CS_PLATFORM CS_P_MSP432
> -#elif defined(cc3200) || defined(TARGET_IS_CC3200)
> -#define CS_PLATFORM CS_P_CC3200
> -#elif defined(cc3220) || defined(TARGET_IS_CC3220)
> -#define CS_PLATFORM CS_P_CC3220
> -#elif defined(__unix__) || defined(__APPLE__)
> -#define CS_PLATFORM CS_P_UNIX
> -#elif defined(WINCE)
> -#define CS_PLATFORM CS_P_WINCE
> -#elif defined(_WIN32)
> -#define CS_PLATFORM CS_P_WINDOWS
> -#elif defined(__MBED__)
> -#define CS_PLATFORM CS_P_MBED
> -#elif defined(__USE_LPCOPEN)
> -#define CS_PLATFORM CS_P_NXP_LPC
> -#elif defined(FRDM_K64F) || defined(FREEDOM)
> -#define CS_PLATFORM CS_P_NXP_KINETIS
> -#elif defined(PIC32)
> -#define CS_PLATFORM CS_P_PIC32
> -#elif defined(ESP_PLATFORM)
> -#define CS_PLATFORM CS_P_ESP32
> -#elif defined(ICACHE_FLASH)
> -#define CS_PLATFORM CS_P_ESP8266
> -#elif defined(TARGET_IS_TM4C129_RA0) || defined(TARGET_IS_TM4C129_RA1) || \
> -    defined(TARGET_IS_TM4C129_RA2)
> -#define CS_PLATFORM CS_P_TM4C129
> -#elif defined(RS14100)
> -#define CS_PLATFORM CS_P_RS14100
> -#elif defined(STM32)
> -#define CS_PLATFORM CS_P_STM32
> -#endif
> -
> -#ifndef CS_PLATFORM
> -#error "CS_PLATFORM is not specified and we couldn't guess it."
> -#endif
> +// Copyright (c) 2004-2013 Sergey Lyubka
> +// Copyright (c) 2013-2021 Cesanta Software Limited
> +// All rights reserved
> +//
> +// This software is dual-licensed: you can redistribute it and/or modify
> +// it under the terms of the GNU General Public License version 2 as
> +// published by the Free Software Foundation. For the terms of this
> +// license, see <http://www.gnu.org/licenses/>.
> +//
> +// You are free to use this software under the terms of the GNU General
> +// Public License, but WITHOUT ANY WARRANTY; without even the implied
> +// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> +// See the GNU General Public License for more details.
> +//
> +// Alternatively, you can license this software under a commercial
> +// license, as set out in <https://www.cesanta.com/license>.
> +
> +#ifndef MONGOOSE_H
> +#define MONGOOSE_H
> +
> +#define MG_VERSION "7.4"
>   
> -#endif /* !defined(CS_PLATFORM) */
> -
> -#define MG_NET_IF_SOCKET 1
> -#define MG_NET_IF_SIMPLELINK 2
> -#define MG_NET_IF_LWIP_LOW_LEVEL 3
> -#define MG_NET_IF_PIC32 4
> -#define MG_NET_IF_NULL 5
> -
> -#define MG_SSL_IF_OPENSSL 1
> -#define MG_SSL_IF_MBEDTLS 2
> -#define MG_SSL_IF_SIMPLELINK 3
> -
> -/* Amalgamated: #include "common/platforms/platform_unix.h" */
> -/* Amalgamated: #include "common/platforms/platform_windows.h" */
> -/* Amalgamated: #include "common/platforms/platform_esp32.h" */
> -/* Amalgamated: #include "common/platforms/platform_esp8266.h" */
> -/* Amalgamated: #include "common/platforms/platform_cc3100.h" */
> -/* Amalgamated: #include "common/platforms/platform_cc3200.h" */
> -/* Amalgamated: #include "common/platforms/platform_cc3220.h" */
> -/* Amalgamated: #include "common/platforms/platform_mbed.h" */
> -/* Amalgamated: #include "common/platforms/platform_nrf51.h" */
> -/* Amalgamated: #include "common/platforms/platform_nrf52.h" */
> -/* Amalgamated: #include "common/platforms/platform_wince.h" */
> -/* Amalgamated: #include "common/platforms/platform_nxp_lpc.h" */
> -/* Amalgamated: #include "common/platforms/platform_nxp_kinetis.h" */
> -/* Amalgamated: #include "common/platforms/platform_pic32.h" */
> -/* Amalgamated: #include "common/platforms/platform_rs14100.h" */
> -/* Amalgamated: #include "common/platforms/platform_stm32.h" */
> -#if CS_PLATFORM == CS_P_CUSTOM
> -#include <platform_custom.h>
> +#ifdef __cplusplus
> +extern "C" {
>   #endif
>   
> -/* Common stuff */
>   
> -#if !defined(PRINTF_LIKE)
> -#if defined(__GNUC__) || defined(__clang__) || defined(__TI_COMPILER_VERSION__)
> -#define PRINTF_LIKE(f, a) __attribute__((format(printf, f, a)))
> -#else
> -#define PRINTF_LIKE(f, a)
> -#endif
> +#ifndef MG_ENABLE_SOCKET
> +#define MG_ENABLE_SOCKET 1
>   #endif
>   
> -#if !defined(WEAK)
> -#if (defined(__GNUC__) || defined(__clang__) || \
> -     defined(__TI_COMPILER_VERSION__)) &&       \
> -    !defined(_WIN32)
> -#define WEAK __attribute__((weak))
> -#else
> -#define WEAK
> -#endif
> +#ifndef MG_ENABLE_MBEDTLS
> +#define MG_ENABLE_MBEDTLS 0
>   #endif
>   
> -#ifdef __GNUC__
> -#define NORETURN __attribute__((noreturn))
> -#define NOINLINE __attribute__((noinline))
> -#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
> -#define NOINSTR __attribute__((no_instrument_function))
> -#define DO_NOT_WARN_UNUSED __attribute__((unused))
> -#else
> -#define NORETURN
> -#define NOINLINE
> -#define WARN_UNUSED_RESULT
> -#define NOINSTR
> -#define DO_NOT_WARN_UNUSED
> -#endif /* __GNUC__ */
> -
> -#ifndef ARRAY_SIZE
> -#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
> +#ifndef MG_ENABLE_OPENSSL
> +#define MG_ENABLE_OPENSSL 0
>   #endif
>   
> -#endif /* CS_COMMON_PLATFORM_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_windows.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_
> -#if CS_PLATFORM == CS_P_WINDOWS
> -
> -/*
> - * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
> - * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
> - * MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
> - * MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
> - * MSVC++ 9.0  _MSC_VER == 1500 (Visual Studio 2008)
> - * MSVC++ 8.0  _MSC_VER == 1400 (Visual Studio 2005)
> - * MSVC++ 7.1  _MSC_VER == 1310 (Visual Studio 2003)
> - * MSVC++ 7.0  _MSC_VER == 1300
> - * MSVC++ 6.0  _MSC_VER == 1200
> - * MSVC++ 5.0  _MSC_VER == 1100
> - */
> -#ifdef _MSC_VER
> -#pragma warning(disable : 4127) /* FD_SET() emits warning, disable it */
> -#pragma warning(disable : 4204) /* missing c99 support */
> +#ifndef MG_ENABLE_SSI
> +#define MG_ENABLE_SSI 1
>   #endif
>   
> -#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
> -#define _WINSOCK_DEPRECATED_NO_WARNINGS 1
> +#ifndef MG_ENABLE_IPV6
> +#define MG_ENABLE_IPV6 0
>   #endif
>   
> -#ifndef _CRT_SECURE_NO_WARNINGS
> -#define _CRT_SECURE_NO_WARNINGS
> +#ifndef MG_ENABLE_LOG
> +#define MG_ENABLE_LOG 1
>   #endif
>   
> -#include <assert.h>
> -#include <direct.h>
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <io.h>
> -#include <limits.h>
> -#include <signal.h>
> -#include <stddef.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <sys/stat.h>
> -#include <time.h>
> -#include <ctype.h>
> -
> -#ifdef _MSC_VER
> -#pragma comment(lib, "ws2_32.lib") /* Linking with winsock library */
> +#ifndef MG_ENABLE_MD5
> +#define MG_ENABLE_MD5 0
>   #endif
>   
> -#include <winsock2.h>
> -#include <ws2tcpip.h>
> -#include <windows.h>
> -#include <process.h>
> -
> -#if defined(_MSC_VER) && (_MSC_VER < 1700)
> -typedef int bool;
> -#else
> -#include <stdbool.h>
> +// Set MG_ENABLE_WINSOCK=0 for Win32 builds with external IP stack (like LWIP)
> +#ifndef MG_ENABLE_WINSOCK
> +#define MG_ENABLE_WINSOCK 1
>   #endif
>   
> -#if defined(_MSC_VER) && _MSC_VER >= 1800
> -#define strdup _strdup
> +#ifndef MG_ENABLE_DIRLIST
> +#define MG_ENABLE_DIRLIST 0
>   #endif
>   
> -#ifndef EINPROGRESS
> -#define EINPROGRESS WSAEINPROGRESS
> -#endif
> -#ifndef EWOULDBLOCK
> -#define EWOULDBLOCK WSAEWOULDBLOCK
> -#endif
> -#ifndef __func__
> -#define STRX(x) #x
> -#define STR(x) STRX(x)
> -#define __func__ __FILE__ ":" STR(__LINE__)
> -#endif
> -#define snprintf _snprintf
> -#define vsnprintf _vsnprintf
> -#define to64(x) _atoi64(x)
> -#if !defined(__MINGW32__) && !defined(__MINGW64__)
> -#define popen(x, y) _popen((x), (y))
> -#define pclose(x) _pclose(x)
> -#define fileno _fileno
> -#endif
> -#if defined(_MSC_VER) && _MSC_VER >= 1400
> -#define fseeko(x, y, z) _fseeki64((x), (y), (z))
> -#else
> -#define fseeko(x, y, z) fseek((x), (y), (z))
> -#endif
> -#if defined(_MSC_VER) && _MSC_VER <= 1200
> -typedef unsigned long uintptr_t;
> -typedef long intptr_t;
> -#endif
> -typedef int socklen_t;
> -#if _MSC_VER >= 1700
> -#include <stdint.h>
> -#else
> -typedef signed char int8_t;
> -typedef unsigned char uint8_t;
> -typedef int int32_t;
> -typedef unsigned int uint32_t;
> -typedef short int16_t;
> -typedef unsigned short uint16_t;
> -typedef __int64 int64_t;
> -typedef unsigned __int64 uint64_t;
> -#endif
> -typedef SOCKET sock_t;
> -typedef uint32_t in_addr_t;
> -#ifndef UINT16_MAX
> -#define UINT16_MAX 65535
> -#endif
> -#ifndef UINT32_MAX
> -#define UINT32_MAX 4294967295
> -#endif
> -#ifndef pid_t
> -#define pid_t HANDLE
> -#endif
> -#define INT64_FMT "I64d"
> -#define INT64_X_FMT "I64x"
> -#define SIZE_T_FMT "Iu"
> -typedef struct _stati64 cs_stat_t;
> -#ifndef S_ISDIR
> -#define S_ISDIR(x) (((x) &_S_IFMT) == _S_IFDIR)
> -#endif
> -#ifndef S_ISREG
> -#define S_ISREG(x) (((x) &_S_IFMT) == _S_IFREG)
> +#ifndef MG_ENABLE_CUSTOM_RANDOM
> +#define MG_ENABLE_CUSTOM_RANDOM 0
>   #endif
> -#define DIRSEP '\\'
> -#define CS_DEFINE_DIRENT
>   
> -#ifndef va_copy
> -#ifdef __va_copy
> -#define va_copy __va_copy
> -#else
> -#define va_copy(x, y) (x) = (y)
> -#endif
> +#ifndef MG_ENABLE_PACKED_FS
> +#define MG_ENABLE_PACKED_FS 0
>   #endif
>   
> -#ifndef MG_MAX_HTTP_REQUEST_SIZE
> -#define MG_MAX_HTTP_REQUEST_SIZE 8192
> +// Granularity of the send/recv IO buffer growth
> +#ifndef MG_IO_SIZE
> +#define MG_IO_SIZE 2048
>   #endif
>   
> -#ifndef MG_MAX_HTTP_SEND_MBUF
> -#define MG_MAX_HTTP_SEND_MBUF 4096
> +// Maximum size of the recv IO buffer
> +#ifndef MG_MAX_RECV_BUF_SIZE
> +#define MG_MAX_RECV_BUF_SIZE (3 * 1024 * 1024)
>   #endif
>   
>   #ifndef MG_MAX_HTTP_HEADERS
>   #define MG_MAX_HTTP_HEADERS 40
>   #endif
>   
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> +#ifndef MG_PATH_MAX
> +#define MG_PATH_MAX PATH_MAX
>   #endif
>   
> -#ifndef MG_ENABLE_BROADCAST
> -#define MG_ENABLE_BROADCAST 1
> +#ifndef MG_SOCK_LISTEN_BACKLOG_SIZE
> +#define MG_SOCK_LISTEN_BACKLOG_SIZE 128
>   #endif
>   
> -#ifndef MG_ENABLE_DIRECTORY_LISTING
> -#define MG_ENABLE_DIRECTORY_LISTING 1
> -#endif
> -
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_CGI
> -#define MG_ENABLE_HTTP_CGI MG_ENABLE_FILESYSTEM
> -#endif
> -
> -#ifndef MG_NET_IF
> -#define MG_NET_IF MG_NET_IF_SOCKET
> -#endif
> -
> -unsigned int sleep(unsigned int seconds);
>   
> -/* https://stackoverflow.com/questions/16647819/timegm-cross-platform */
> -#define timegm _mkgmtime
> +#define MG_ARCH_CUSTOM 0
> +#define MG_ARCH_UNIX 1
> +#define MG_ARCH_WIN32 2
> +#define MG_ARCH_ESP32 3
> +#define MG_ARCH_ESP8266 4
> +#define MG_ARCH_FREERTOS_TCP 5
> +#define MG_ARCH_FREERTOS_LWIP 6
> +#define MG_ARCH_AZURERTOS 7
>   
> -#define gmtime_r(a, b) \
> -  do {                 \
> -    *(b) = *gmtime(a); \
> -  } while (0)
> -
> -#endif /* CS_PLATFORM == CS_P_WINDOWS */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_unix.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_
> -#if CS_PLATFORM == CS_P_UNIX
> -
> -#ifndef _XOPEN_SOURCE
> -#define _XOPEN_SOURCE 600
> +#if !defined(MG_ARCH)
> +#if defined(__unix__) || defined(__APPLE__)
> +#define MG_ARCH MG_ARCH_UNIX
> +#elif defined(_WIN32)
> +#define MG_ARCH MG_ARCH_WIN32
> +#elif defined(ICACHE_FLASH) || defined(ICACHE_RAM_ATTR)
> +#define MG_ARCH MG_ARCH_ESP8266
> +#elif defined(ESP_PLATFORM)
> +#define MG_ARCH MG_ARCH_ESP32
> +#elif defined(FREERTOS_IP_H)
> +#define MG_ARCH MG_ARCH_FREERTOS_TCP
> +#elif defined(AZURE_RTOS_THREADX)
> +#define MG_ARCH MG_ARCH_AZURERTOS
>   #endif
>   
> -/* <inttypes.h> wants this for C++ */
> -#ifndef __STDC_FORMAT_MACROS
> -#define __STDC_FORMAT_MACROS
> +#if !defined(MG_ARCH)
> +#error "MG_ARCH is not specified and we couldn't guess it."
>   #endif
> +#endif  // !defined(MG_ARCH)
>   
> -/* C++ wants that for INT64_MAX */
> -#ifndef __STDC_LIMIT_MACROS
> -#define __STDC_LIMIT_MACROS
> +#if !defined(PRINTF_LIKE)
> +#if defined(__GNUC__) || defined(__clang__) || defined(__TI_COMPILER_VERSION__)
> +#define PRINTF_LIKE(f, a) __attribute__((format(printf, f, a)))
> +#else
> +#define PRINTF_LIKE(f, a)
>   #endif
> -
> -/* Enable fseeko() and ftello() functions */
> -#ifndef _LARGEFILE_SOURCE
> -#define _LARGEFILE_SOURCE
>   #endif
>   
> -/* Enable 64-bit file offsets */
> -#ifndef _FILE_OFFSET_BITS
> -#define _FILE_OFFSET_BITS 64
> +#if MG_ARCH == MG_ARCH_CUSTOM
> +#include <mongoose_custom.h>
>   #endif
>   
> -#include <arpa/inet.h>
> -#include <assert.h>
> -#include <ctype.h>
> -#include <dirent.h>
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <limits.h>
> -#include <math.h>
> -#include <netdb.h>
> -#include <netinet/in.h>
> -#include <pthread.h>
> -#include <signal.h>
> -#include <stdarg.h>
> -#include <stdbool.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <sys/param.h>
> -#include <sys/socket.h>
> -#include <sys/select.h>
> -#include <sys/stat.h>
> -#include <sys/time.h>
> -#include <sys/types.h>
> -#include <unistd.h>
>   
> -#ifdef __APPLE__
> -#include <machine/endian.h>
> -#ifndef BYTE_ORDER
> -#define LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN
> -#define BIG_ENDIAN __DARWIN_BIG_ENDIAN
> -#define PDP_ENDIAN __DARWIN_PDP_ENDIAN
> -#define BYTE_ORDER __DARWIN_BYTE_ORDER
> -#endif
> -#endif
>   
> -/*
> - * osx correctly avoids defining strtoll when compiling in strict ansi mode.
> - * c++ 11 standard defines strtoll as well.
> - * We require strtoll, and if your embedded pre-c99 compiler lacks one, please
> - * implement a shim.
> - */
> -#if !(defined(__cplusplus) && __cplusplus >= 201103L) && \
> -    !(defined(__DARWIN_C_LEVEL) && __DARWIN_C_LEVEL >= 200809L)
> -long long strtoll(const char *, char **, int);
> -#endif
>   
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> -#define SIZE_T_FMT "zu"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -
> -#ifndef __cdecl
> -#define __cdecl
> -#endif
>   
> -#ifndef va_copy
> -#ifdef __va_copy
> -#define va_copy __va_copy
> -#else
> -#define va_copy(x, y) (x) = (y)
> -#endif
> -#endif
>   
> -#define closesocket(x) close(x)
>   
> -#ifndef MG_MAX_HTTP_REQUEST_SIZE
> -#define MG_MAX_HTTP_REQUEST_SIZE 8192
> -#endif
>   
> -#ifndef MG_MAX_HTTP_SEND_MBUF
> -#define MG_MAX_HTTP_SEND_MBUF 4096
> -#endif
>   
> -#ifndef MG_MAX_HTTP_HEADERS
> -#define MG_MAX_HTTP_HEADERS 40
> -#endif
> +#if MG_ARCH == MG_ARCH_AZURERTOS
>   
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> +#include <stdarg.h>
> +#include <stdint.h>
> +#include <stdbool.h>
> +#include <time.h>
> +#include <stdio.h>
> +
> +#include <tx_api.h>
> +#include <fx_api.h>
>   
> -#ifndef MG_ENABLE_BROADCAST
> -#define MG_ENABLE_BROADCAST 1
> -#endif
> +#include <tx_port.h>
> +#include <nx_port.h>
> +#include <nx_api.h>
> +#include <nx_bsd.h>
>   
> -#ifndef MG_ENABLE_DIRECTORY_LISTING
> -#define MG_ENABLE_DIRECTORY_LISTING 1
> +#ifdef __REDLIB__
> +#define va_copy(d,s)__builtin_va_copy(d,s)
>   #endif
>   
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> +#define PATH_MAX FX_MAXIMUM_PATH
> +#define MG_DIRSEP '\\'
>   
> -#ifndef MG_ENABLE_HTTP_CGI
> -#define MG_ENABLE_HTTP_CGI MG_ENABLE_FILESYSTEM
> -#endif
> +#define socklen_t int
> +#define closesocket(x) soc_close(x)
> +#define gmtime_r(a, b) gmtime(a)
> +#define MG_INT64_FMT "%lld"
>   
> -#ifndef MG_NET_IF
> -#define MG_NET_IF MG_NET_IF_SOCKET
> -#endif
> +static __inline struct tm *localtime_r(time_t *t, struct tm *tm) {
> +  (void) tm;
> +  return localtime(t);
> +}
>   
> -#ifndef MG_HOSTS_FILE_NAME
> -#define MG_HOSTS_FILE_NAME "/etc/hosts"
> -#endif
> +#undef FOPEN_MAX
>   
> -#ifndef MG_RESOLV_CONF_FILE_NAME
> -#define MG_RESOLV_CONF_FILE_NAME "/etc/resolv.conf"
>   #endif
>   
> -#endif /* CS_PLATFORM == CS_P_UNIX */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_esp32.h"
> -#endif
>   
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_
> -#if CS_PLATFORM == CS_P_ESP32
> +#if MG_ARCH == MG_ARCH_ESP32
>   
> -#include <assert.h>
>   #include <ctype.h>
>   #include <dirent.h>
> +#include <errno.h>
>   #include <fcntl.h>
> -#include <inttypes.h>
> -#include <machine/endian.h>
> -#include <stdbool.h>
> -#include <stdint.h>
> +#include <limits.h>
> +#include <netdb.h>
> +#include <stdarg.h>
> +#include <stddef.h>
> +#include <stdio.h>
> +#include <stdlib.h>
>   #include <string.h>
>   #include <sys/stat.h>
> -#include <sys/time.h>
> -
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -#define _FILE_OFFSET_BITS 32
> -
> -#define MG_LWIP 1
> +#include <sys/types.h>
> +#include <time.h>
>   
> -#ifndef MG_NET_IF
> -#define MG_NET_IF MG_NET_IF_SOCKET
> +#define MG_DIRSEP '/'
> +#define MG_INT64_FMT "%lld"
> +#ifndef MG_PATH_MAX
> +#define MG_PATH_MAX 128
>   #endif
> +#undef MG_ENABLE_DIRLIST
> +#define MG_ENABLE_DIRLIST 1
>   
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
>   #endif
>   
> -#endif /* CS_PLATFORM == CS_P_ESP32 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_esp8266.h"
> -#endif
>   
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_
> -#if CS_PLATFORM == CS_P_ESP8266
> +#if MG_ARCH == MG_ARCH_ESP8266
>   
> -#include <assert.h>
>   #include <ctype.h>
> +#include <dirent.h>
> +#include <errno.h>
>   #include <fcntl.h>
> -#include <inttypes.h>
> -#include <machine/endian.h>
> +#include <limits.h>
> +#include <netdb.h>
> +#include <stdarg.h>
>   #include <stdbool.h>
> +#include <stddef.h>
> +#include <stdio.h>
> +#include <stdlib.h>
>   #include <string.h>
>   #include <sys/stat.h>
>   #include <sys/time.h>
> -
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#if !defined(MGOS_VFS_DEFINE_DIRENT)
> -#define CS_DEFINE_DIRENT
> -#endif
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -#define _FILE_OFFSET_BITS 32
> -
> -#define MG_LWIP 1
> -
> -/* struct timeval is defined in sys/time.h. */
> -#define LWIP_TIMEVAL_PRIVATE 0
> -
> -#ifndef MG_NET_IF
> -#include <lwip/opt.h>
> -#if LWIP_SOCKET /* RTOS SDK has LWIP sockets */
> -#define MG_NET_IF MG_NET_IF_SOCKET
> -#else
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -#endif
> -#endif
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#define inet_ntop(af, src, dst, size)                                          \
> -  (((af) == AF_INET) ? ipaddr_ntoa_r((const ip_addr_t *) (src), (dst), (size)) \
> -                     : NULL)
> -#define inet_pton(af, src, dst) \
> -  (((af) == AF_INET) ? ipaddr_aton((src), (ip_addr_t *) (dst)) : 0)
> -
> -#endif /* CS_PLATFORM == CS_P_ESP8266 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_cc3100.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_
> -#if CS_PLATFORM == CS_P_CC3100
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <string.h>
> +#include <sys/types.h>
>   #include <time.h>
>   
> -#define MG_NET_IF MG_NET_IF_SIMPLELINK
> -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK
> -
> -/*
> - * CC3100 SDK and STM32 SDK include headers w/out path, just like
> - * #include "simplelink.h". As result, we have to add all required directories
> - * into Makefile IPATH and do the same thing (include w/out path)
> - */
> -
> -#include <simplelink.h>
> -#include <netapp.h>
> -#undef timeval
> -
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> +#include <esp_system.h>
>   
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define SIZE_T_FMT "u"
> +#define MG_DIRSEP '/'
> +#define MG_INT64_FMT "%lld"
>   
> -#define SOMAXCONN 8
> -
> -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
> -char *inet_ntoa(struct in_addr in);
> -int inet_pton(int af, const char *src, void *dst);
> -
> -#endif /* CS_PLATFORM == CS_P_CC3100 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_cc3200.h"
>   #endif
>   
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_
> -#if CS_PLATFORM == CS_P_CC3200
>   
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> +#if MG_ARCH == MG_ARCH_FREERTOS_LWIP
> +
> +#include <stdarg.h>
>   #include <stdbool.h>
>   #include <stdint.h>
>   #include <string.h>
> -#include <time.h>
>   
> -#ifndef __TI_COMPILER_VERSION__
> -#include <fcntl.h>
> +#if defined(__GNUC__)
> +#include <sys/stat.h>
>   #include <sys/time.h>
> -#endif
> -
> -#define MG_NET_IF MG_NET_IF_SIMPLELINK
> -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK
> -
> -/* Only SPIFFS supports directories, SLFS does not. */
> -#if defined(CC3200_FS_SPIFFS) && !defined(MG_ENABLE_DIRECTORY_LISTING)
> -#define MG_ENABLE_DIRECTORY_LISTING 1
> -#endif
> -
> -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */
> -
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -
> -#define fileno(x) -1
> -
> -/* Some functions we implement for Mongoose. */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -#ifdef __TI_COMPILER_VERSION__
> -struct SlTimeval_t;
> -#define timeval SlTimeval_t
> -int gettimeofday(struct timeval *t, void *tz);
> -int settimeofday(const struct timeval *tv, const void *tz);
> -
> -int asprintf(char **strp, const char *fmt, ...);
> -
> -#endif
> -
> -/* TI's libc does not have stat & friends, add them. */
> -#ifdef __TI_COMPILER_VERSION__
> -
> -#include <file.h>
> -
> -typedef unsigned int mode_t;
> -typedef size_t _off_t;
> -typedef long ssize_t;
> -
> -struct stat {
> -  int st_ino;
> -  mode_t st_mode;
> -  int st_nlink;
> -  time_t st_mtime;
> -  off_t st_size;
> -};
> -
> -int _stat(const char *pathname, struct stat *st);
> -int stat(const char *pathname, struct stat *st);
> -
> -#define __S_IFMT 0170000
> -
> -#define __S_IFDIR 0040000
> -#define __S_IFCHR 0020000
> -#define __S_IFREG 0100000
> -
> -#define __S_ISTYPE(mode, mask) (((mode) &__S_IFMT) == (mask))
> -
> -#define S_IFDIR __S_IFDIR
> -#define S_IFCHR __S_IFCHR
> -#define S_IFREG __S_IFREG
> -#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
> -#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
> -
> -/* 5.x series compilers don't have va_copy, 16.x do. */
> -#if __TI_COMPILER_VERSION__ < 16000000
> -#define va_copy(apc, ap) ((apc) = (ap))
> -#endif
> -
> -#endif /* __TI_COMPILER_VERSION__ */
> -
> -#ifdef CC3200_FS_SLFS
> -#define MG_FS_SLFS
> -#endif
> -
> -#if (defined(CC3200_FS_SPIFFS) || defined(CC3200_FS_SLFS)) && \
> -    !defined(MG_ENABLE_FILESYSTEM)
> -#define MG_ENABLE_FILESYSTEM 1
> -#define CS_DEFINE_DIRENT
> -#endif
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_CC3200 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_cc3220.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_CC3220_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_CC3220_H_
> -#if CS_PLATFORM == CS_P_CC3220
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdbool.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -
> -#ifndef __TI_COMPILER_VERSION__
> -#include <fcntl.h>
> -#include <sys/time.h>
> -#endif
> -
> -#define MG_NET_IF MG_NET_IF_SIMPLELINK
> -#ifndef MG_SSL_IF
> -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK
> -#endif
> -
> -/* Only SPIFFS supports directories, SLFS does not. */
> -#if defined(CC3220_FS_SPIFFS) && !defined(MG_ENABLE_DIRECTORY_LISTING)
> -#define MG_ENABLE_DIRECTORY_LISTING 1
> -#endif
> -
> -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */
> -
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -
> -#define fileno(x) -1
> -
> -/* Some functions we implement for Mongoose. */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -#ifdef __TI_COMPILER_VERSION__
> -struct SlTimeval_t;
> -#define timeval SlTimeval_t
> -int gettimeofday(struct timeval *t, void *tz);
> -int settimeofday(const struct timeval *tv, const void *tz);
> -
> -int asprintf(char **strp, const char *fmt, ...);
> -
> -#endif
> -
> -/* TI's libc does not have stat & friends, add them. */
> -#ifdef __TI_COMPILER_VERSION__
> -
> -#include <file.h>
> -
> -typedef unsigned int mode_t;
> -typedef size_t _off_t;
> -typedef long ssize_t;
> -
> -struct stat {
> -  int st_ino;
> -  mode_t st_mode;
> -  int st_nlink;
> -  time_t st_mtime;
> -  off_t st_size;
> -};
> -
> -int _stat(const char *pathname, struct stat *st);
> -int stat(const char *pathname, struct stat *st);
> -
> -#define __S_IFMT 0170000
> -
> -#define __S_IFDIR 0040000
> -#define __S_IFCHR 0020000
> -#define __S_IFREG 0100000
> -
> -#define __S_ISTYPE(mode, mask) (((mode) &__S_IFMT) == (mask))
> -
> -#define S_IFDIR __S_IFDIR
> -#define S_IFCHR __S_IFCHR
> -#define S_IFREG __S_IFREG
> -#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
> -#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
> -
> -#endif /* __TI_COMPILER_VERSION__ */
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_CC3220 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_msp432.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_
> -#if CS_PLATFORM == CS_P_MSP432
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -
> -#ifndef __TI_COMPILER_VERSION__
> -#include <fcntl.h>
> -#include <sys/time.h>
> -#endif
> -
> -#define MG_NET_IF MG_NET_IF_SIMPLELINK
> -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK
> -
> -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */
> -
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -
> -#define fileno(x) -1
> -
> -/* Some functions we implement for Mongoose. */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -#ifdef __TI_COMPILER_VERSION__
> -struct SlTimeval_t;
> -#define timeval SlTimeval_t
> -int gettimeofday(struct timeval *t, void *tz);
> -#endif
> -
> -/* TI's libc does not have stat & friends, add them. */
> -#ifdef __TI_COMPILER_VERSION__
> -
> -#include <file.h>
> -
> -typedef unsigned int mode_t;
> -typedef size_t _off_t;
> -typedef long ssize_t;
> -
> -struct stat {
> -  int st_ino;
> -  mode_t st_mode;
> -  int st_nlink;
> -  time_t st_mtime;
> -  off_t st_size;
> -};
> -
> -int _stat(const char *pathname, struct stat *st);
> -#define stat(a, b) _stat(a, b)
> -
> -#define __S_IFMT 0170000
> -
> -#define __S_IFDIR 0040000
> -#define __S_IFCHR 0020000
> -#define __S_IFREG 0100000
> -
> -#define __S_ISTYPE(mode, mask) (((mode) &__S_IFMT) == (mask))
> -
> -#define S_IFDIR __S_IFDIR
> -#define S_IFCHR __S_IFCHR
> -#define S_IFREG __S_IFREG
> -#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
> -#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
> -
> -/* As of 5.2.7, TI compiler does not support va_copy() yet. */
> -#define va_copy(apc, ap) ((apc) = (ap))
> -
> -#endif /* __TI_COMPILER_VERSION__ */
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#if (defined(CC3200_FS_SPIFFS) || defined(CC3200_FS_SLFS)) && \
> -    !defined(MG_ENABLE_FILESYSTEM)
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_MSP432 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_tm4c129.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_
> -#if CS_PLATFORM == CS_P_TM4C129
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -
> -#ifndef __TI_COMPILER_VERSION__
> -#include <fcntl.h>
> -#include <sys/time.h>
> -#endif
> -
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define __cdecl
> -
> -#ifndef MG_NET_IF
> -#include <lwip/opt.h>
> -#if LWIP_SOCKET
> -#define MG_NET_IF MG_NET_IF_SOCKET
>   #else
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -#endif
> -#define MG_LWIP 1
> -#elif MG_NET_IF == MG_NET_IF_SIMPLELINK
> -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */
> -#endif
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#ifdef __TI_COMPILER_VERSION__
> -/* As of 5.2.8, TI compiler does not support va_copy() yet. */
> -#define va_copy(apc, ap) ((apc) = (ap))
> -#endif /* __TI_COMPILER_VERSION__ */
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_TM4C129 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_mbed.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_MBED_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_MBED_H_
> -#if CS_PLATFORM == CS_P_MBED
> -
> -/*
> - * mbed.h contains C++ code (e.g. templates), thus, it should be processed
> - * only if included directly to startup file (ex: main.cpp)
> - */
> -#ifdef __cplusplus
> -/* Amalgamated: #include "mbed.h" */
> -#endif /* __cplusplus */
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -#include <sys/stat.h>
> -#include <sys/types.h>
> -#include <fcntl.h>
> -#include <stdio.h>
> -
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -/*
> - * mbed can be compiled with the ARM compiler which
> - * just doesn't come with a gettimeofday shim
> - * because it's a BSD API and ARM targets embedded
> - * non-unix platforms.
> - */
> -#if defined(__ARMCC_VERSION) || defined(__ICCARM__)
> -#define _TIMEVAL_DEFINED
> -#define gettimeofday _gettimeofday
> -
> -/* copied from GCC on ARM; for some reason useconds are signed */
> -typedef long suseconds_t; /* microseconds (signed) */
> +typedef long suseconds_t;
>   struct timeval {
> -  time_t tv_sec;       /* seconds */
> -  suseconds_t tv_usec; /* and microseconds */
> -};
> -
> -#endif
> -
> -#if MG_NET_IF == MG_NET_IF_SIMPLELINK
> -
> -#define MG_SIMPLELINK_NO_OSI 1
> -
> -#include <simplelink.h>
> -
> -typedef int sock_t;
> -#define INVALID_SOCKET (-1)
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT PRId64
> -#define INT64_X_FMT PRIx64
> -#define SIZE_T_FMT "u"
> -
> -#define SOMAXCONN 8
> -
> -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
> -char *inet_ntoa(struct in_addr in);
> -int inet_pton(int af, const char *src, void *dst);
> -int inet_aton(const char *cp, struct in_addr *inp);
> -in_addr_t inet_addr(const char *cp);
> -
> -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK */
> -
> -#endif /* CS_PLATFORM == CS_P_MBED */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_MBED_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_nrf51.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_
> -#if CS_PLATFORM == CS_P_NRF51
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <inttypes.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -#define MG_LWIP 1
> -#define MG_ENABLE_IPV6 1
> -
> -/*
> - * For ARM C Compiler, make lwip to export `struct timeval`; for other
> - * compilers, suppress it.
> - */
> -#if !defined(__ARMCC_VERSION)
> -#define LWIP_TIMEVAL_PRIVATE 0
> -#else
> -struct timeval;
> -int gettimeofday(struct timeval *tp, void *tzp);
> -#endif
> -
> -#define INT64_FMT PRId64
> -#define SIZE_T_FMT "u"
> -
> -/*
> - * ARM C Compiler doesn't have strdup, so we provide it
> - */
> -#define CS_ENABLE_STRDUP defined(__ARMCC_VERSION)
> -
> -#endif /* CS_PLATFORM == CS_P_NRF51 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_nrf52.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_
> -#if CS_PLATFORM == CS_P_NRF52
> -
> -#include <assert.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <inttypes.h>
> -#include <stdbool.h>
> -#include <stdint.h>
> -#include <string.h>
> -#include <time.h>
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -#define MG_LWIP 1
> -#define MG_ENABLE_IPV6 1
> -
> -#if !defined(ENOSPC)
> -#define ENOSPC 28 /* No space left on device */
> -#endif
> -
> -/*
> - * For ARM C Compiler, make lwip to export `struct timeval`; for other
> - * compilers, suppress it.
> - */
> -#if !defined(__ARMCC_VERSION)
> -#define LWIP_TIMEVAL_PRIVATE 0
> -#endif
> -
> -#define INT64_FMT PRId64
> -#define SIZE_T_FMT "u"
> -
> -/*
> - * ARM C Compiler doesn't have strdup, so we provide it
> - */
> -#define CS_ENABLE_STRDUP defined(__ARMCC_VERSION)
> -
> -#endif /* CS_PLATFORM == CS_P_NRF52 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/simplelink/cs_simplelink.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_
> -#define CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_
> -
> -#if defined(MG_NET_IF) && MG_NET_IF == MG_NET_IF_SIMPLELINK
> -
> -/* If simplelink.h is already included, all bets are off. */
> -#if !defined(__SIMPLELINK_H__)
> -
> -#include <stdbool.h>
> -
> -#ifndef __TI_COMPILER_VERSION__
> -#undef __CONCAT
> -#undef FD_CLR
> -#undef FD_ISSET
> -#undef FD_SET
> -#undef FD_SETSIZE
> -#undef FD_ZERO
> -#undef fd_set
> -#endif
> -
> -#if CS_PLATFORM == CS_P_CC3220
> -#include <ti/drivers/net/wifi/porting/user.h>
> -#include <ti/drivers/net/wifi/simplelink.h>
> -#include <ti/drivers/net/wifi/sl_socket.h>
> -#include <ti/drivers/net/wifi/netapp.h>
> -#else
> -/* We want to disable SL_INC_STD_BSD_API_NAMING, so we include user.h ourselves
> - * and undef it. */
> -#define PROVISIONING_API_H_
> -#include <simplelink/user.h>
> -#undef PROVISIONING_API_H_
> -#undef SL_INC_STD_BSD_API_NAMING
> -
> -#include <simplelink/include/simplelink.h>
> -#include <simplelink/include/netapp.h>
> -#endif /* CS_PLATFORM == CS_P_CC3220 */
> -
> -/* Now define only the subset of the BSD API that we use.
> - * Notably, close(), read() and write() are not defined. */
> -#define AF_INET SL_AF_INET
> -
> -#define socklen_t SlSocklen_t
> -#define sockaddr SlSockAddr_t
> -#define sockaddr_in SlSockAddrIn_t
> -#define in_addr SlInAddr_t
> -
> -#define SOCK_STREAM SL_SOCK_STREAM
> -#define SOCK_DGRAM SL_SOCK_DGRAM
> -
> -#define htonl sl_Htonl
> -#define ntohl sl_Ntohl
> -#define htons sl_Htons
> -#define ntohs sl_Ntohs
> -
> -#ifndef EACCES
> -#define EACCES SL_EACCES
> -#endif
> -#ifndef EAFNOSUPPORT
> -#define EAFNOSUPPORT SL_EAFNOSUPPORT
> -#endif
> -#ifndef EAGAIN
> -#define EAGAIN SL_EAGAIN
> -#endif
> -#ifndef EBADF
> -#define EBADF SL_EBADF
> -#endif
> -#ifndef EINVAL
> -#define EINVAL SL_EINVAL
> -#endif
> -#ifndef ENOMEM
> -#define ENOMEM SL_ENOMEM
> -#endif
> -#ifndef EWOULDBLOCK
> -#define EWOULDBLOCK SL_EWOULDBLOCK
> -#endif
> -
> -#define SOMAXCONN 8
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
> -char *inet_ntoa(struct in_addr in);
> -int inet_pton(int af, const char *src, void *dst);
> -
> -struct mg_mgr;
> -struct mg_connection;
> -
> -typedef void (*mg_init_cb)(struct mg_mgr *mgr);
> -bool mg_start_task(int priority, int stack_size, mg_init_cb mg_init);
> -
> -void mg_run_in_task(void (*cb)(struct mg_mgr *mgr, void *arg), void *cb_arg);
> -
> -int sl_fs_init(void);
> -
> -void sl_restart_cb(struct mg_mgr *mgr);
> -
> -int sl_set_ssl_opts(int sock, struct mg_connection *nc);
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* !defined(__SIMPLELINK_H__) */
> -
> -/* Compatibility with older versions of SimpleLink */
> -#if SL_MAJOR_VERSION_NUM < 2
> -
> -#define SL_ERROR_BSD_EAGAIN SL_EAGAIN
> -#define SL_ERROR_BSD_EALREADY SL_EALREADY
> -#define SL_ERROR_BSD_ENOPROTOOPT SL_ENOPROTOOPT
> -#define SL_ERROR_BSD_ESECDATEERROR SL_ESECDATEERROR
> -#define SL_ERROR_BSD_ESECSNOVERIFY SL_ESECSNOVERIFY
> -#define SL_ERROR_FS_FAILED_TO_ALLOCATE_MEM SL_FS_ERR_FAILED_TO_ALLOCATE_MEM
> -#define SL_ERROR_FS_FILE_HAS_NOT_BEEN_CLOSE_CORRECTLY \
> -  SL_FS_FILE_HAS_NOT_BEEN_CLOSE_CORRECTLY
> -#define SL_ERROR_FS_FILE_NAME_EXIST SL_FS_FILE_NAME_EXIST
> -#define SL_ERROR_FS_FILE_NOT_EXISTS SL_FS_ERR_FILE_NOT_EXISTS
> -#define SL_ERROR_FS_NO_AVAILABLE_NV_INDEX SL_FS_ERR_NO_AVAILABLE_NV_INDEX
> -#define SL_ERROR_FS_NOT_ENOUGH_STORAGE_SPACE SL_FS_ERR_NO_AVAILABLE_BLOCKS
> -#define SL_ERROR_FS_NOT_SUPPORTED SL_FS_ERR_NOT_SUPPORTED
> -#define SL_ERROR_FS_WRONG_FILE_NAME SL_FS_WRONG_FILE_NAME
> -#define SL_ERROR_FS_INVALID_HANDLE SL_FS_ERR_INVALID_HANDLE
> -#define SL_NETCFG_MAC_ADDRESS_GET SL_MAC_ADDRESS_GET
> -#define SL_SOCKET_FD_ZERO SL_FD_ZERO
> -#define SL_SOCKET_FD_SET SL_FD_SET
> -#define SL_SOCKET_FD_ISSET SL_FD_ISSET
> -#define SL_SO_SECURE_DOMAIN_NAME_VERIFICATION SO_SECURE_DOMAIN_NAME_VERIFICATION
> -
> -#define SL_FS_READ FS_MODE_OPEN_READ
> -#define SL_FS_WRITE FS_MODE_OPEN_WRITE
> -
> -#define SL_FI_FILE_SIZE(fi) ((fi).FileLen)
> -#define SL_FI_FILE_MAX_SIZE(fi) ((fi).AllocatedLen)
> -
> -#define SlDeviceVersion_t SlVersionFull
> -#define sl_DeviceGet sl_DevGet
> -#define SL_DEVICE_GENERAL SL_DEVICE_GENERAL_CONFIGURATION
> -#define SL_LEN_TYPE _u8
> -#define SL_OPT_TYPE _u8
> -
> -#else /* SL_MAJOR_VERSION_NUM >= 2 */
> -
> -#define FS_MODE_OPEN_CREATE(max_size, flag) \
> -  (SL_FS_CREATE | SL_FS_CREATE_MAX_SIZE(max_size))
> -#define SL_FI_FILE_SIZE(fi) ((fi).Len)
> -#define SL_FI_FILE_MAX_SIZE(fi) ((fi).MaxSize)
> -
> -#define SL_LEN_TYPE _u16
> -#define SL_OPT_TYPE _u16
> -
> -#endif /* SL_MAJOR_VERSION_NUM < 2 */
> -
> -int slfs_open(const unsigned char *fname, uint32_t flags, uint32_t *token);
> -
> -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK */
> -
> -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_wince.h"
> -#endif
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_
> -
> -#if CS_PLATFORM == CS_P_WINCE
> -
> -/*
> - * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
> - * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
> - * MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
> - * MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
> - * MSVC++ 9.0  _MSC_VER == 1500 (Visual Studio 2008)
> - * MSVC++ 8.0  _MSC_VER == 1400 (Visual Studio 2005)
> - * MSVC++ 7.1  _MSC_VER == 1310 (Visual Studio 2003)
> - * MSVC++ 7.0  _MSC_VER == 1300
> - * MSVC++ 6.0  _MSC_VER == 1200
> - * MSVC++ 5.0  _MSC_VER == 1100
> - */
> -#pragma warning(disable : 4127) /* FD_SET() emits warning, disable it */
> -#pragma warning(disable : 4204) /* missing c99 support */
> -
> -#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
> -#define _WINSOCK_DEPRECATED_NO_WARNINGS 1
> -#endif
> -
> -#ifndef _CRT_SECURE_NO_WARNINGS
> -#define _CRT_SECURE_NO_WARNINGS
> -#endif
> -
> -#include <assert.h>
> -#include <limits.h>
> -#include <stddef.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <time.h>
> -
> -#pragma comment(lib, "ws2.lib") /* Linking with WinCE winsock library */
> -
> -#include <winsock2.h>
> -#include <ws2tcpip.h>
> -#include <windows.h>
> -
> -#define strdup _strdup
> -
> -#ifndef EINPROGRESS
> -#define EINPROGRESS WSAEINPROGRESS
> -#endif
> -
> -#ifndef EWOULDBLOCK
> -#define EWOULDBLOCK WSAEWOULDBLOCK
> -#endif
> -
> -#ifndef EAGAIN
> -#define EAGAIN EWOULDBLOCK
> -#endif
> -
> -#ifndef __func__
> -#define STRX(x) #x
> -#define STR(x) STRX(x)
> -#define __func__ __FILE__ ":" STR(__LINE__)
> -#endif
> -
> -#define snprintf _snprintf
> -#define fileno _fileno
> -#define vsnprintf _vsnprintf
> -#define sleep(x) Sleep((x) *1000)
> -#define to64(x) _atoi64(x)
> -#define rmdir _rmdir
> -
> -#if defined(_MSC_VER) && _MSC_VER >= 1400
> -#define fseeko(x, y, z) _fseeki64((x), (y), (z))
> -#else
> -#define fseeko(x, y, z) fseek((x), (y), (z))
> -#endif
> -
> -typedef int socklen_t;
> -
> -#if _MSC_VER >= 1700
> -#include <stdint.h>
> -#else
> -typedef signed char int8_t;
> -typedef unsigned char uint8_t;
> -typedef int int32_t;
> -typedef unsigned int uint32_t;
> -typedef short int16_t;
> -typedef unsigned short uint16_t;
> -typedef __int64 int64_t;
> -typedef unsigned __int64 uint64_t;
> -#endif
> -
> -typedef SOCKET sock_t;
> -typedef uint32_t in_addr_t;
> -
> -#ifndef UINT16_MAX
> -#define UINT16_MAX 65535
> -#endif
> -
> -#ifndef UINT32_MAX
> -#define UINT32_MAX 4294967295
> -#endif
> -
> -#ifndef pid_t
> -#define pid_t HANDLE
> -#endif
> -
> -#define INT64_FMT "I64d"
> -#define INT64_X_FMT "I64x"
> -/* TODO(alashkin): check if this is correct */
> -#define SIZE_T_FMT "u"
> -
> -#define DIRSEP '\\'
> -#define CS_DEFINE_DIRENT
> -
> -#ifndef va_copy
> -#ifdef __va_copy
> -#define va_copy __va_copy
> -#else
> -#define va_copy(x, y) (x) = (y)
> -#endif
> -#endif
> -
> -#ifndef MG_MAX_HTTP_REQUEST_SIZE
> -#define MG_MAX_HTTP_REQUEST_SIZE 8192
> -#endif
> -
> -#ifndef MG_MAX_HTTP_SEND_MBUF
> -#define MG_MAX_HTTP_SEND_MBUF 4096
> -#endif
> -
> -#ifndef MG_MAX_HTTP_HEADERS
> -#define MG_MAX_HTTP_HEADERS 40
> -#endif
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#define abort() DebugBreak();
> -
> -#ifndef BUFSIZ
> -#define BUFSIZ 4096
> -#endif
> -/*
> - * Explicitly disabling MG_ENABLE_THREADS for WinCE
> - * because they are enabled for _WIN32 by default
> - */
> -#ifndef MG_ENABLE_THREADS
> -#define MG_ENABLE_THREADS 0
> -#endif
> -
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> -
> -#ifndef MG_NET_IF
> -#define MG_NET_IF MG_NET_IF_SOCKET
> -#endif
> -
> -typedef struct _stati64 {
> -  uint32_t st_mtime;
> -  uint32_t st_size;
> -  uint32_t st_mode;
> -} cs_stat_t;
> -
> -/*
> - * WinCE 6.0 has a lot of useful definitions in ATL (not windows.h) headers
> - * use #ifdefs to avoid conflicts
> - */
> -
> -#ifndef ENOENT
> -#define ENOENT ERROR_PATH_NOT_FOUND
> -#endif
> -
> -#ifndef EACCES
> -#define EACCES ERROR_ACCESS_DENIED
> -#endif
> -
> -#ifndef ENOMEM
> -#define ENOMEM ERROR_NOT_ENOUGH_MEMORY
> -#endif
> -
> -#ifndef _UINTPTR_T_DEFINED
> -typedef unsigned int *uintptr_t;
> -#endif
> -
> -#define _S_IFREG 2
> -#define _S_IFDIR 4
> -
> -#ifndef S_ISDIR
> -#define S_ISDIR(x) (((x) &_S_IFDIR) != 0)
> -#endif
> -
> -#ifndef S_ISREG
> -#define S_ISREG(x) (((x) &_S_IFREG) != 0)
> -#endif
> -
> -int open(const char *filename, int oflag, int pmode);
> -int _wstati64(const wchar_t *path, cs_stat_t *st);
> -const char *strerror();
> -
> -#endif /* CS_PLATFORM == CS_P_WINCE */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_nxp_lpc.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_
> -
> -#if CS_PLATFORM == CS_P_NXP_LPC
> -
> -#include <ctype.h>
> -#include <stdint.h>
> -#include <string.h>
> -
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define INT64_FMT "lld"
> -#define INT64_X_FMT "llx"
> -#define __cdecl
> -
> -#define MG_LWIP 1
> -
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -
> -/*
> - * LPCXpress comes with 3 C library implementations: Newlib, NewlibNano and
> - *Redlib.
> - * See https://community.nxp.com/message/630860 for more details.
> - *
> - * Redlib is the default and lacks certain things, so we provide them.
> - */
> -#ifdef __REDLIB_INTERFACE_VERSION__
> -
> -/* Let LWIP define timeval for us. */
> -#define LWIP_TIMEVAL_PRIVATE 1
> -
> -#define va_copy(d, s) __builtin_va_copy(d, s)
> -
> -#define CS_ENABLE_TO64 1
> -#define to64(x) cs_to64(x)
> -
> -#define CS_ENABLE_STRDUP 1
> -
> -#else
> -
> -#include <sys/time.h>
> -#define LWIP_TIMEVAL_PRIVATE 0
> -#define to64(x) strtoll(x, NULL, 10)
> -
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_NXP_LPC */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_nxp_kinetis.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_
> -
> -#if CS_PLATFORM == CS_P_NXP_KINETIS
> -
> -#include <ctype.h>
> -#include <inttypes.h>
> -#include <string.h>
> -#include <sys/time.h>
> -
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT "lld"
> -#define INT64_X_FMT "llx"
> -#define __cdecl
> -
> -#define MG_LWIP 1
> -
> -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL
> -
> -/* struct timeval is defined in sys/time.h. */
> -#define LWIP_TIMEVAL_PRIVATE 0
> -
> -#endif /* CS_PLATFORM == CS_P_NXP_KINETIS */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_pic32.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_
> -
> -#if CS_PLATFORM == CS_P_PIC32
> -
> -#define MG_NET_IF MG_NET_IF_PIC32
> -
> -#include <stdint.h>
> -#include <time.h>
> -#include <ctype.h>
> -#include <stdlib.h>
> -
> -#include <system_config.h>
> -#include <system_definitions.h>
> -
> -#include <sys/types.h>
> -
> -typedef TCP_SOCKET sock_t;
> -#define to64(x) strtoll(x, NULL, 10)
> -
> -#define SIZE_T_FMT "lu"
> -#define INT64_FMT "lld"
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -char *inet_ntoa(struct in_addr in);
> -
> -#endif /* CS_PLATFORM == CS_P_PIC32 */
> -
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_rs14100.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_RS14100_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_RS14100_H_
> -#if CS_PLATFORM == CS_P_RS14100
> -
> -#include <ctype.h>
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <stdint.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <sys/stat.h>
> -#include <sys/time.h>
> -#include <sys/types.h>
> -#include <unistd.h>
> -
> -#ifdef MGOS_HAVE_VFS_COMMON
> -#include <mgos_vfs.h>
> -#endif
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT "lld"
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_RS14100 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_RS14100_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/platform_stm32.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_PLATFORM_STM32_H_
> -#define CS_COMMON_PLATFORMS_PLATFORM_STM32_H_
> -#if CS_PLATFORM == CS_P_STM32
> -
> -#include <ctype.h>
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <stdint.h>
> -#include <stdio.h>
> -#include <string.h>
> -#include <sys/stat.h>
> -#include <sys/time.h>
> -#include <sys/types.h>
> -#include <unistd.h>
> -#include <dirent.h>
> -
> -#include <stm32_sdk_hal.h>
> -
> -#define to64(x) strtoll(x, NULL, 10)
> -#define INT64_FMT "lld"
> -#define SIZE_T_FMT "u"
> -typedef struct stat cs_stat_t;
> -#define DIRSEP '/'
> -
> -#ifndef CS_ENABLE_STDIO
> -#define CS_ENABLE_STDIO 1
> -#endif
> -
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 1
> -#endif
> -
> -#endif /* CS_PLATFORM == CS_P_STM32 */
> -#endif /* CS_COMMON_PLATFORMS_PLATFORM_STM32_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/platforms/lwip/mg_lwip.h"
> -#endif
> -
> -#ifndef CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_
> -#define CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_
> -
> -#ifndef MG_LWIP
> -#define MG_LWIP 0
> -#endif
> -
> -#if MG_LWIP
> -
> -/*
> - * When compiling for nRF5x chips with arm-none-eabi-gcc, it has BYTE_ORDER
> - * already defined, so in order to avoid warnings in lwip, we have to undefine
> - * it.
> - *
> - * TODO: Check if in the future versions of nRF5 SDK that changes.
> - *       Current version of nRF51 SDK: 0.8.0
> - *                          nRF5 SDK:  0.9.0
> - */
> -#if CS_PLATFORM == CS_P_NRF51 || CS_PLATFORM == CS_P_NRF52
> -#undef BYTE_ORDER
> -#endif
> -
> -#include <lwip/opt.h>
> -#include <lwip/err.h>
> -#include <lwip/ip_addr.h>
> -#include <lwip/inet.h>
> -#include <lwip/netdb.h>
> -#include <lwip/dns.h>
> -
> -#ifndef LWIP_PROVIDE_ERRNO
> -#include <errno.h>
> -#endif
> -
> -#if LWIP_SOCKET
> -#include <lwip/sockets.h>
> -#else
> -/* We really need the definitions from sockets.h. */
> -#undef LWIP_SOCKET
> -#define LWIP_SOCKET 1
> -#include <lwip/sockets.h>
> -#undef LWIP_SOCKET
> -#define LWIP_SOCKET 0
> -#endif
> -
> -#define INVALID_SOCKET (-1)
> -#define SOMAXCONN 10
> -typedef int sock_t;
> -
> -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL
> -struct mg_mgr;
> -struct mg_connection;
> -void mg_lwip_set_keepalive_params(struct mg_connection *nc, int idle,
> -                                  int interval, int count);
> -#endif
> -
> -/* For older version of LWIP */
> -#ifndef ipX_2_ip
> -#define ipX_2_ip(x) (x)
> -#endif
> -
> -#endif /* MG_LWIP */
> -
> -#endif /* CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_md5.h"
> -#endif
> -
> -#ifndef CS_COMMON_MD5_H_
> -#define CS_COMMON_MD5_H_
> -
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifndef CS_DISABLE_MD5
> -#define CS_DISABLE_MD5 0
> -#endif
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -typedef struct {
> -  uint32_t buf[4];
> -  uint32_t bits[2];
> -  unsigned char in[64];
> -} cs_md5_ctx;
> -
> -void cs_md5_init(cs_md5_ctx *c);
> -void cs_md5_update(cs_md5_ctx *c, const unsigned char *data, size_t len);
> -void cs_md5_final(unsigned char *md, cs_md5_ctx *c);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_COMMON_MD5_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_sha1.h"
> -#endif
> -
> -#ifndef CS_COMMON_SHA1_H_
> -#define CS_COMMON_SHA1_H_
> -
> -#ifndef CS_DISABLE_SHA1
> -#define CS_DISABLE_SHA1 0
> -#endif
> -
> -#if !CS_DISABLE_SHA1
> -
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -typedef struct {
> -  uint32_t state[5];
> -  uint32_t count[2];
> -  unsigned char buffer[64];
> -} cs_sha1_ctx;
> -
> -void cs_sha1_init(cs_sha1_ctx *);
> -void cs_sha1_update(cs_sha1_ctx *, const unsigned char *data, uint32_t len);
> -void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *);
> -void cs_hmac_sha1(const unsigned char *key, size_t key_len,
> -                  const unsigned char *text, size_t text_len,
> -                  unsigned char out[20]);
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_DISABLE_SHA1 */
> -
> -#endif /* CS_COMMON_SHA1_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_time.h"
> -#endif
> -
> -#ifndef CS_COMMON_CS_TIME_H_
> -#define CS_COMMON_CS_TIME_H_
> -
> -#include <time.h>
> -
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/* Sub-second granularity time(). */
> -double cs_time(void);
> -
> -/*
> - * Similar to (non-standard) timegm, converts broken-down time into the number
> - * of seconds since Unix Epoch.
> - */
> -double cs_timegm(const struct tm *tm);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_COMMON_CS_TIME_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/mg_str.h"
> -#endif
> -
> -#ifndef CS_COMMON_MG_STR_H_
> -#define CS_COMMON_MG_STR_H_
> -
> -#include <stddef.h>
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -/* Describes chunk of memory */
> -struct mg_str {
> -  const char *p; /* Memory chunk pointer */
> -  size_t len;    /* Memory chunk length */
> -};
> -
> -/*
> - * Helper function for creating mg_str struct from plain C string.
> - * `NULL` is allowed and becomes `{NULL, 0}`.
> - */
> -struct mg_str mg_mk_str(const char *s);
> -
> -/*
> - * Like `mg_mk_str`, but takes string length explicitly.
> - */
> -struct mg_str mg_mk_str_n(const char *s, size_t len);
> -
> -/* Macro for initializing mg_str. */
> -#define MG_MK_STR(str_literal) \
> -  { str_literal, sizeof(str_literal) - 1 }
> -#define MG_MK_STR_N(str_literal, len) \
> -  { str_literal, len }
> -#define MG_NULL_STR \
> -  { NULL, 0 }
> -
> -/*
> - * Cross-platform version of `strcmp()` where where first string is
> - * specified by `struct mg_str`.
> - */
> -int mg_vcmp(const struct mg_str *str2, const char *str1);
> -
> -/*
> - * Cross-platform version of `strncasecmp()` where first string is
> - * specified by `struct mg_str`.
> - */
> -int mg_vcasecmp(const struct mg_str *str2, const char *str1);
> -
> -/* Creates a copy of s (heap-allocated). */
> -struct mg_str mg_strdup(const struct mg_str s);
> -
> -/*
> - * Creates a copy of s (heap-allocated).
> - * Resulting string is NUL-terminated (but NUL is not included in len).
> - */
> -struct mg_str mg_strdup_nul(const struct mg_str s);
> -
> -/*
> - * Locates character in a string.
> - */
> -const char *mg_strchr(const struct mg_str s, int c);
> -
> -/*
> - * Compare two `mg_str`s; return value is the same as `strcmp`.
> - */
> -int mg_strcmp(const struct mg_str str1, const struct mg_str str2);
> -
> -/*
> - * Like `mg_strcmp`, but compares at most `n` characters.
> - */
> -int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n);
> -
> -/*
> - * Compare two `mg_str`s ignoreing case; return value is the same as `strcmp`.
> - */
> -int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2);
> -
> -/*
> - * Free the string (assuming it was heap allocated).
> - */
> -void mg_strfree(struct mg_str *s);
> -
> -/*
> - * Finds the first occurrence of a substring `needle` in the `haystack`.
> - */
> -const char *mg_strstr(const struct mg_str haystack, const struct mg_str needle);
> -
> -/* Strip whitespace at the start and the end of s */
> -struct mg_str mg_strstrip(struct mg_str s);
> -
> -/* Returns 1 if s starts with the given prefix. */
> -int mg_str_starts_with(struct mg_str s, struct mg_str prefix);
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_COMMON_MG_STR_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/mbuf.h"
> -#endif
> -
> -/*
> - * Mbufs are mutable/growing memory buffers, like C++ strings.
> - * Mbuf can append data to the end of a buffer or insert data into arbitrary
> - * position in the middle of a buffer. The buffer grows automatically when
> - * needed.
> - */
> -
> -#ifndef CS_COMMON_MBUF_H_
> -#define CS_COMMON_MBUF_H_
> -
> -#include <stdlib.h>
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#if defined(__cplusplus)
> -extern "C" {
> -#endif
> -
> -#ifndef MBUF_SIZE_MULTIPLIER
> -#define MBUF_SIZE_MULTIPLIER 1.5
> -#endif
> -
> -#ifndef MBUF_SIZE_MAX_HEADROOM
> -#ifdef BUFSIZ
> -#define MBUF_SIZE_MAX_HEADROOM BUFSIZ
> -#else
> -#define MBUF_SIZE_MAX_HEADROOM 1024
> -#endif
> -#endif
> -
> -/* Memory buffer descriptor */
> -struct mbuf {
> -  char *buf;   /* Buffer pointer */
> -  size_t len;  /* Data length. Data is located between offset 0 and len. */
> -  size_t size; /* Buffer size allocated by realloc(1). Must be >= len */
> -};
> -
> -/*
> - * Initialises an Mbuf.
> - * `initial_capacity` specifies the initial capacity of the mbuf.
> - */
> -void mbuf_init(struct mbuf *, size_t initial_capacity);
> -
> -/* Frees the space allocated for the mbuffer and resets the mbuf structure. */
> -void mbuf_free(struct mbuf *);
> -
> -/*
> - * Appends data to the Mbuf.
> - *
> - * Returns the number of bytes appended or 0 if out of memory.
> - */
> -size_t mbuf_append(struct mbuf *, const void *data, size_t data_size);
> -
> -/*
> - * Appends data to the Mbuf and frees it (data must be heap-allocated).
> - *
> - * Returns the number of bytes appended or 0 if out of memory.
> - * data is freed irrespective of return value.
> - */
> -size_t mbuf_append_and_free(struct mbuf *, void *data, size_t data_size);
> -
> -/*
> - * Inserts data at a specified offset in the Mbuf.
> - *
> - * Existing data will be shifted forwards and the buffer will
> - * be grown if necessary.
> - * Returns the number of bytes inserted.
> - */
> -size_t mbuf_insert(struct mbuf *, size_t, const void *, size_t);
> -
> -/* Removes `data_size` bytes from the beginning of the buffer. */
> -void mbuf_remove(struct mbuf *, size_t data_size);
> -
> -/*
> - * Resizes an Mbuf.
> - *
> - * If `new_size` is smaller than buffer's `len`, the
> - * resize is not performed.
> - */
> -void mbuf_resize(struct mbuf *, size_t new_size);
> -
> -/* Moves the state from one mbuf to the other. */
> -void mbuf_move(struct mbuf *from, struct mbuf *to);
> -
> -/* Removes all the data from mbuf (if any). */
> -void mbuf_clear(struct mbuf *);
> -
> -/* Shrinks an Mbuf by resizing its `size` to `len`. */
> -void mbuf_trim(struct mbuf *);
> -
> -#if defined(__cplusplus)
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_COMMON_MBUF_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/cs_base64.h"
> -#endif
> -
> -#ifndef CS_COMMON_CS_BASE64_H_
> -#define CS_COMMON_CS_BASE64_H_
> -
> -#ifndef DISABLE_BASE64
> -#define DISABLE_BASE64 0
> -#endif
> -
> -#if !DISABLE_BASE64
> -
> -#include <stdio.h>
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -typedef void (*cs_base64_putc_t)(char, void *);
> -
> -struct cs_base64_ctx {
> -  /* cannot call it putc because it's a macro on some environments */
> -  cs_base64_putc_t b64_putc;
> -  unsigned char chunk[3];
> -  int chunk_size;
> -  void *user_data;
> -};
> -
> -void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t putc,
> -                    void *user_data);
> -void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len);
> -void cs_base64_finish(struct cs_base64_ctx *ctx);
> -
> -void cs_base64_encode(const unsigned char *src, int src_len, char *dst);
> -void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len);
> -
> -/*
> - * Decodes a base64 string `s` length `len` into `dst`.
> - * `dst` must have enough space to hold the result.
> - * `*dec_len` will contain the resulting length of the string in `dst`
> - * while return value will return number of processed bytes in `src`.
> - * Return value == len indicates successful processing of all the data.
> - */
> -int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len);
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* DISABLE_BASE64 */
> -
> -#endif /* CS_COMMON_CS_BASE64_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/str_util.h"
> -#endif
> -
> -#ifndef CS_COMMON_STR_UTIL_H_
> -#define CS_COMMON_STR_UTIL_H_
> -
> -#include <stdarg.h>
> -#include <stdlib.h>
> -
> -/* Amalgamated: #include "common/mg_str.h" */
> -/* Amalgamated: #include "common/platform.h" */
> -
> -#ifndef CS_ENABLE_STRDUP
> -#define CS_ENABLE_STRDUP 0
> -#endif
> -
> -#ifndef CS_ENABLE_TO64
> -#define CS_ENABLE_TO64 0
> -#endif
> -
> -/*
> - * Expands to a string representation of its argument: e.g.
> - * `CS_STRINGIFY_LIT(5) expands to "5"`
> - */
> -#if !defined(_MSC_VER) || _MSC_VER >= 1900
> -#define CS_STRINGIFY_LIT(...) #__VA_ARGS__
> -#else
> -#define CS_STRINGIFY_LIT(x) #x
> -#endif
> -
> -/*
> - * Expands to a string representation of its argument, which is allowed
> - * to be a macro: e.g.
> - *
> - * #define FOO 123
> - * CS_STRINGIFY_MACRO(FOO)
> - *
> - * expands to 123.
> - */
> -#define CS_STRINGIFY_MACRO(x) CS_STRINGIFY_LIT(x)
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -/*
> - * Equivalent of standard `strnlen()`.
> - */
> -size_t c_strnlen(const char *s, size_t maxlen);
> -
> -/*
> - * Equivalent of standard `snprintf()`.
> - */
> -int c_snprintf(char *buf, size_t buf_size, const char *format, ...)
> -    PRINTF_LIKE(3, 4);
> -
> -/*
> - * Equivalent of standard `vsnprintf()`.
> - */
> -int c_vsnprintf(char *buf, size_t buf_size, const char *format, va_list ap);
> -
> -/*
> - * Find the first occurrence of find in s, where the search is limited to the
> - * first slen characters of s.
> - */
> -const char *c_strnstr(const char *s, const char *find, size_t slen);
> -
> -/*
> - * Stringify binary data. Output buffer size must be 2 * size_of_input + 1
> - * because each byte of input takes 2 bytes in string representation
> - * plus 1 byte for the terminating \0 character.
> - */
> -void cs_to_hex(char *to, const unsigned char *p, size_t len);
> -
> -/*
> - * Convert stringified binary data back to binary.
> - * Does the reverse of `cs_to_hex()`.
> - */
> -void cs_from_hex(char *to, const char *p, size_t len);
> -
> -#if CS_ENABLE_STRDUP
> -/*
> - * Equivalent of standard `strdup()`, defined if only `CS_ENABLE_STRDUP` is 1.
> - */
> -char *strdup(const char *src);
> -#endif
> -
> -#if CS_ENABLE_TO64
> -#include <stdint.h>
> -/*
> - * Simple string -> int64 conversion routine.
> - */
> -int64_t cs_to64(const char *s);
> -#endif
> -
> -/*
> - * Cross-platform version of `strncasecmp()`.
> - */
> -int mg_ncasecmp(const char *s1, const char *s2, size_t len);
> -
> -/*
> - * Cross-platform version of `strcasecmp()`.
> - */
> -int mg_casecmp(const char *s1, const char *s2);
> -
> -/*
> - * Prints message to the buffer. If the buffer is large enough to hold the
> - * message, it returns buffer. If buffer is to small, it allocates a large
> - * enough buffer on heap and returns allocated buffer.
> - * This is a supposed use case:
> - *
> - * ```c
> - *    char buf[5], *p = buf;
> - *    mg_avprintf(&p, sizeof(buf), "%s", "hi there");
> - *    use_p_somehow(p);
> - *    if (p != buf) {
> - *      free(p);
> - *    }
> - * ```
> - *
> - * The purpose of this is to avoid malloc-ing if generated strings are small.
> - */
> -int mg_asprintf(char **buf, size_t size, const char *fmt, ...)
> -    PRINTF_LIKE(3, 4);
> -
> -/* Same as mg_asprintf, but takes varargs list. */
> -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap);
> -
> -/*
> - * 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.
> - * The value is stored in a val vector. If the value has a form "x=y", then
> - * eq_val vector is initialised to point to the "y" part, and val vector length
> - * is adjusted to point only to "x".
> - * If the list is just a comma separated list of entries, like "aa,bb,cc" then
> - * `eq_val` will contain zero-length string.
> - *
> - * The purpose of this function is to parse comma separated string without
> - * any copying/memory allocation.
> - */
> -const char *mg_next_comma_list_entry(const char *list, struct mg_str *val,
> -                                     struct mg_str *eq_val);
> -
> -/*
> - * Like `mg_next_comma_list_entry()`, but takes `list` as `struct mg_str`.
> - * NB: Test return value's .p, not .len. On last itreation that yields result
> - * .len will be 0 but .p will not. When finished, .p will be NULL.
> - */
> -struct mg_str mg_next_comma_list_entry_n(struct mg_str list, struct mg_str *val,
> -                                         struct mg_str *eq_val);
> -
> -/*
> - * Matches 0-terminated string (mg_match_prefix) or string with given length
> - * mg_match_prefix_n against a glob pattern. Glob syntax:
> - * ```
> - * - * matches zero or more characters until a slash character /
> - * - ** matches zero or more characters
> - * - ? Matches exactly one character which is not a slash /
> - * - | or ,  divides alternative patterns
> - * - any other character matches itself
> - * ```
> - * Match is case-insensitive. Return number of bytes matched.
> - * Examples:
> - * ```
> - * mg_match_prefix("a*f", len, "abcdefgh") == 6
> - * mg_match_prefix("a*f", len, "abcdexgh") == 0
> - * mg_match_prefix("a*f|de*,xy", len, "defgh") == 5
> - * mg_match_prefix("?*", len, "abc") == 3
> - * mg_match_prefix("?*", len, "") == 0
> - * ```
> - */
> -size_t mg_match_prefix(const char *pattern, int pattern_len, const char *str);
> -
> -/*
> - * Like `mg_match_prefix()`, but takes `pattern` and `str` as `struct mg_str`.
> - */
> -size_t mg_match_prefix_n(const struct mg_str pattern, const struct mg_str str);
> -
> -#ifdef __cplusplus
> -}
> -#endif
> -
> -#endif /* CS_COMMON_STR_UTIL_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "common/queue.h"
> -#endif
> -/* clang-format off */
> -/*-
> - * Copyright (c) 1991, 1993
> - *	The Regents of the University of California.  All rights reserved.
> - *
> - * Redistribution and use in source and binary forms, with or without
> - * modification, are permitted provided that the following conditions
> - * are met:
> - * 1. Redistributions of source code must retain the above copyright
> - *    notice, this list of conditions and the following disclaimer.
> - * 2. Redistributions in binary form must reproduce the above copyright
> - *    notice, this list of conditions and the following disclaimer in the
> - *    documentation and/or other materials provided with the distribution.
> - * 4. Neither the name of the University nor the names of its contributors
> - *    may be used to endorse or promote products derived from this software
> - *    without specific prior written permission.
> - *
> - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
> - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> - * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
> - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
> - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
> - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
> - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
> - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
> - * SUCH DAMAGE.
> - *
> - *	@(#)queue.h	8.5 (Berkeley) 8/20/94
> - * $FreeBSD$
> - */
> -
> -#ifndef _SYS_QUEUE_H_
> -#define	_SYS_QUEUE_H_
> -
> -/*
> - * This file defines four types of data structures: singly-linked lists,
> - * singly-linked tail queues, lists and tail queues.
> - *
> - * A singly-linked list is headed by a single forward pointer. The elements
> - * are singly linked for minimum space and pointer manipulation overhead at
> - * the expense of O(n) removal for arbitrary elements. New elements can be
> - * added to the list after an existing element or at the head of the list.
> - * Elements being removed from the head of the list should use the explicit
> - * macro for this purpose for optimum efficiency. A singly-linked list may
> - * only be traversed in the forward direction.  Singly-linked lists are ideal
> - * for applications with large datasets and few or no removals or for
> - * implementing a LIFO queue.
> - *
> - * A singly-linked tail queue is headed by a pair of pointers, one to the
> - * head of the list and the other to the tail of the list. The elements are
> - * singly linked for minimum space and pointer manipulation overhead at the
> - * expense of O(n) removal for arbitrary elements. New elements can be added
> - * to the list after an existing element, at the head of the list, or at the
> - * end of the list. Elements being removed from the head of the tail queue
> - * should use the explicit macro for this purpose for optimum efficiency.
> - * A singly-linked tail queue may only be traversed in the forward direction.
> - * Singly-linked tail queues are ideal for applications with large datasets
> - * and few or no removals or for implementing a FIFO queue.
> - *
> - * A list is headed by a single forward pointer (or an array of forward
> - * pointers for a hash table header). The elements are doubly linked
> - * so that an arbitrary element can be removed without a need to
> - * traverse the list. New elements can be added to the list before
> - * or after an existing element or at the head of the list. A list
> - * may be traversed in either direction.
> - *
> - * A tail queue is headed by a pair of pointers, one to the head of the
> - * list and the other to the tail of the list. The elements are doubly
> - * linked so that an arbitrary element can be removed without a need to
> - * traverse the list. New elements can be added to the list before or
> - * after an existing element, at the head of the list, or at the end of
> - * the list. A tail queue may be traversed in either direction.
> - *
> - * For details on the use of these macros, see the queue(3) manual page.
> - *
> - *
> - *				SLIST	LIST	STAILQ	TAILQ
> - * _HEAD			+	+	+	+
> - * _CLASS_HEAD			+	+	+	+
> - * _HEAD_INITIALIZER		+	+	+	+
> - * _ENTRY			+	+	+	+
> - * _CLASS_ENTRY			+	+	+	+
> - * _INIT			+	+	+	+
> - * _EMPTY			+	+	+	+
> - * _FIRST			+	+	+	+
> - * _NEXT			+	+	+	+
> - * _PREV			-	+	-	+
> - * _LAST			-	-	+	+
> - * _FOREACH			+	+	+	+
> - * _FOREACH_FROM		+	+	+	+
> - * _FOREACH_SAFE		+	+	+	+
> - * _FOREACH_FROM_SAFE		+	+	+	+
> - * _FOREACH_REVERSE		-	-	-	+
> - * _FOREACH_REVERSE_FROM	-	-	-	+
> - * _FOREACH_REVERSE_SAFE	-	-	-	+
> - * _FOREACH_REVERSE_FROM_SAFE	-	-	-	+
> - * _INSERT_HEAD			+	+	+	+
> - * _INSERT_BEFORE		-	+	-	+
> - * _INSERT_AFTER		+	+	+	+
> - * _INSERT_TAIL			-	-	+	+
> - * _CONCAT			-	-	+	+
> - * _REMOVE_AFTER		+	-	+	-
> - * _REMOVE_HEAD			+	-	+	-
> - * _REMOVE			+	+	+	+
> - * _SWAP			+	+	+	+
> - *
> - */
> -#ifdef QUEUE_MACRO_DEBUG
> -/* Store the last 2 places the queue element or head was altered */
> -struct qm_trace {
> -	unsigned long	 lastline;
> -	unsigned long	 prevline;
> -	const char	*lastfile;
> -	const char	*prevfile;
> -};
> -
> -#define	TRACEBUF	struct qm_trace trace;
> -#define	TRACEBUF_INITIALIZER	{ __LINE__, 0, __FILE__, NULL } ,
> -#define	TRASHIT(x)	do {(x) = (void *)-1;} while (0)
> -#define	QMD_SAVELINK(name, link)	void **name = (void *)&(link)
> -
> -#define	QMD_TRACE_HEAD(head) do {					\
> -	(head)->trace.prevline = (head)->trace.lastline;		\
> -	(head)->trace.prevfile = (head)->trace.lastfile;		\
> -	(head)->trace.lastline = __LINE__;				\
> -	(head)->trace.lastfile = __FILE__;				\
> -} while (0)
> -
> -#define	QMD_TRACE_ELEM(elem) do {					\
> -	(elem)->trace.prevline = (elem)->trace.lastline;		\
> -	(elem)->trace.prevfile = (elem)->trace.lastfile;		\
> -	(elem)->trace.lastline = __LINE__;				\
> -	(elem)->trace.lastfile = __FILE__;				\
> -} while (0)
> -
> -#else
> -#define	QMD_TRACE_ELEM(elem)
> -#define	QMD_TRACE_HEAD(head)
> -#define	QMD_SAVELINK(name, link)
> -#define	TRACEBUF
> -#define	TRACEBUF_INITIALIZER
> -#define	TRASHIT(x)
> -#endif	/* QUEUE_MACRO_DEBUG */
> -
> -#ifdef __cplusplus
> -/*
> - * In C++ there can be structure lists and class lists:
> - */
> -#define	QUEUE_TYPEOF(type) type
> -#else
> -#define	QUEUE_TYPEOF(type) struct type
> -#endif
> -
> -/*
> - * Singly-linked List declarations.
> - */
> -#define	SLIST_HEAD(name, type)						\
> -struct name {								\
> -	struct type *slh_first;	/* first element */			\
> -}
> -
> -#define	SLIST_CLASS_HEAD(name, type)					\
> -struct name {								\
> -	class type *slh_first;	/* first element */			\
> -}
> -
> -#define	SLIST_HEAD_INITIALIZER(head)					\
> -	{ NULL }
> -
> -#define	SLIST_ENTRY(type)						\
> -struct {								\
> -	struct type *sle_next;	/* next element */			\
> -}
> -
> -#define	SLIST_CLASS_ENTRY(type)						\
> -struct {								\
> -	class type *sle_next;		/* next element */		\
> -}
> -
> -/*
> - * Singly-linked List functions.
> - */
> -#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
> -
> -#define	SLIST_FIRST(head)	((head)->slh_first)
> -
> -#define	SLIST_FOREACH(var, head, field)					\
> -	for ((var) = SLIST_FIRST((head));				\
> -	    (var);							\
> -	    (var) = SLIST_NEXT((var), field))
> -
> -#define	SLIST_FOREACH_FROM(var, head, field)				\
> -	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
> -	    (var);							\
> -	    (var) = SLIST_NEXT((var), field))
> -
> -#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
> -	for ((var) = SLIST_FIRST((head));				\
> -	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
> -	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
> -	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
> -	for ((varp) = &SLIST_FIRST((head));				\
> -	    ((var) = *(varp)) != NULL;					\
> -	    (varp) = &SLIST_NEXT((var), field))
> -
> -#define	SLIST_INIT(head) do {						\
> -	SLIST_FIRST((head)) = NULL;					\
> -} while (0)
> -
> -#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
> -	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);	\
> -	SLIST_NEXT((slistelm), field) = (elm);				\
> -} while (0)
> -
> -#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
> -	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
> -	SLIST_FIRST((head)) = (elm);					\
> -} while (0)
> -
> -#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
> -
> -#define	SLIST_REMOVE(head, elm, type, field) do {			\
> -	QMD_SAVELINK(oldnext, (elm)->field.sle_next);			\
> -	if (SLIST_FIRST((head)) == (elm)) {				\
> -		SLIST_REMOVE_HEAD((head), field);			\
> -	}								\
> -	else {								\
> -		QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head);		\
> -		while (SLIST_NEXT(curelm, field) != (elm))		\
> -			curelm = SLIST_NEXT(curelm, field);		\
> -		SLIST_REMOVE_AFTER(curelm, field);			\
> -	}								\
> -	TRASHIT(*oldnext);						\
> -} while (0)
> -
> -#define SLIST_REMOVE_AFTER(elm, field) do {				\
> -	SLIST_NEXT(elm, field) =					\
> -	    SLIST_NEXT(SLIST_NEXT(elm, field), field);			\
> -} while (0)
> -
> -#define	SLIST_REMOVE_HEAD(head, field) do {				\
> -	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
> -} while (0)
> -
> -#define SLIST_SWAP(head1, head2, type) do {				\
> -	QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1);		\
> -	SLIST_FIRST(head1) = SLIST_FIRST(head2);			\
> -	SLIST_FIRST(head2) = swap_first;				\
> -} while (0)
> -
> -/*
> - * Singly-linked Tail queue declarations.
> - */
> -#define	STAILQ_HEAD(name, type)						\
> -struct name {								\
> -	struct type *stqh_first;/* first element */			\
> -	struct type **stqh_last;/* addr of last next element */		\
> -}
> -
> -#define	STAILQ_CLASS_HEAD(name, type)					\
> -struct name {								\
> -	class type *stqh_first;	/* first element */			\
> -	class type **stqh_last;	/* addr of last next element */		\
> -}
> -
> -#define	STAILQ_HEAD_INITIALIZER(head)					\
> -	{ NULL, &(head).stqh_first }
> -
> -#define	STAILQ_ENTRY(type)						\
> -struct {								\
> -	struct type *stqe_next;	/* next element */			\
> -}
> -
> -#define	STAILQ_CLASS_ENTRY(type)					\
> -struct {								\
> -	class type *stqe_next;	/* next element */			\
> -}
> -
> -/*
> - * Singly-linked Tail queue functions.
> - */
> -#define	STAILQ_CONCAT(head1, head2) do {				\
> -	if (!STAILQ_EMPTY((head2))) {					\
> -		*(head1)->stqh_last = (head2)->stqh_first;		\
> -		(head1)->stqh_last = (head2)->stqh_last;		\
> -		STAILQ_INIT((head2));					\
> -	}								\
> -} while (0)
> -
> -#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
> -
> -#define	STAILQ_FIRST(head)	((head)->stqh_first)
> -
> -#define	STAILQ_FOREACH(var, head, field)				\
> -	for((var) = STAILQ_FIRST((head));				\
> -	   (var);							\
> -	   (var) = STAILQ_NEXT((var), field))
> -
> -#define	STAILQ_FOREACH_FROM(var, head, field)				\
> -	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
> -	   (var);							\
> -	   (var) = STAILQ_NEXT((var), field))
> -
> -#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
> -	for ((var) = STAILQ_FIRST((head));				\
> -	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)		\
> -	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
> -	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	STAILQ_INIT(head) do {						\
> -	STAILQ_FIRST((head)) = NULL;					\
> -	(head)->stqh_last = &STAILQ_FIRST((head));			\
> -} while (0)
> -
> -#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
> -	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
> -		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
> -	STAILQ_NEXT((tqelm), field) = (elm);				\
> -} while (0)
> -
> -#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
> -	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
> -		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
> -	STAILQ_FIRST((head)) = (elm);					\
> -} while (0)
> -
> -#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
> -	STAILQ_NEXT((elm), field) = NULL;				\
> -	*(head)->stqh_last = (elm);					\
> -	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
> -} while (0)
> -
> -#define	STAILQ_LAST(head, type, field)				\
> -	(STAILQ_EMPTY((head)) ? NULL :				\
> -	    __containerof((head)->stqh_last,			\
> -	    QUEUE_TYPEOF(type), field.stqe_next))
> -
> -#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
> -
> -#define	STAILQ_REMOVE(head, elm, type, field) do {			\
> -	QMD_SAVELINK(oldnext, (elm)->field.stqe_next);			\
> -	if (STAILQ_FIRST((head)) == (elm)) {				\
> -		STAILQ_REMOVE_HEAD((head), field);			\
> -	}								\
> -	else {								\
> -		QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head);	\
> -		while (STAILQ_NEXT(curelm, field) != (elm))		\
> -			curelm = STAILQ_NEXT(curelm, field);		\
> -		STAILQ_REMOVE_AFTER(head, curelm, field);		\
> -	}								\
> -	TRASHIT(*oldnext);						\
> -} while (0)
> -
> -#define STAILQ_REMOVE_AFTER(head, elm, field) do {			\
> -	if ((STAILQ_NEXT(elm, field) =					\
> -	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
> -		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
> -} while (0)
> -
> -#define	STAILQ_REMOVE_HEAD(head, field) do {				\
> -	if ((STAILQ_FIRST((head)) =					\
> -	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
> -		(head)->stqh_last = &STAILQ_FIRST((head));		\
> -} while (0)
> -
> -#define STAILQ_SWAP(head1, head2, type) do {				\
> -	QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1);		\
> -	QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last;		\
> -	STAILQ_FIRST(head1) = STAILQ_FIRST(head2);			\
> -	(head1)->stqh_last = (head2)->stqh_last;			\
> -	STAILQ_FIRST(head2) = swap_first;				\
> -	(head2)->stqh_last = swap_last;					\
> -	if (STAILQ_EMPTY(head1))					\
> -		(head1)->stqh_last = &STAILQ_FIRST(head1);		\
> -	if (STAILQ_EMPTY(head2))					\
> -		(head2)->stqh_last = &STAILQ_FIRST(head2);		\
> -} while (0)
> -
> -
> -/*
> - * List declarations.
> - */
> -#define	LIST_HEAD(name, type)						\
> -struct name {								\
> -	struct type *lh_first;	/* first element */			\
> -}
> -
> -#define	LIST_CLASS_HEAD(name, type)					\
> -struct name {								\
> -	class type *lh_first;	/* first element */			\
> -}
> -
> -#define	LIST_HEAD_INITIALIZER(head)					\
> -	{ NULL }
> -
> -#define	LIST_ENTRY(type)						\
> -struct {								\
> -	struct type *le_next;	/* next element */			\
> -	struct type **le_prev;	/* address of previous next element */	\
> -}
> -
> -#define	LIST_CLASS_ENTRY(type)						\
> -struct {								\
> -	class type *le_next;	/* next element */			\
> -	class type **le_prev;	/* address of previous next element */	\
> -}
> -
> -/*
> - * List functions.
> - */
> -
> -#if (defined(_KERNEL) && defined(INVARIANTS))
> -#define	QMD_LIST_CHECK_HEAD(head, field) do {				\
> -	if (LIST_FIRST((head)) != NULL &&				\
> -	    LIST_FIRST((head))->field.le_prev !=			\
> -	     &LIST_FIRST((head)))					\
> -		panic("Bad list head %p first->prev != head", (head));	\
> -} while (0)
> -
> -#define	QMD_LIST_CHECK_NEXT(elm, field) do {				\
> -	if (LIST_NEXT((elm), field) != NULL &&				\
> -	    LIST_NEXT((elm), field)->field.le_prev !=			\
> -	     &((elm)->field.le_next))					\
> -		panic("Bad link elm %p next->prev != elm", (elm));	\
> -} while (0)
> -
> -#define	QMD_LIST_CHECK_PREV(elm, field) do {				\
> -	if (*(elm)->field.le_prev != (elm))				\
> -		panic("Bad link elm %p prev->next != elm", (elm));	\
> -} while (0)
> -#else
> -#define	QMD_LIST_CHECK_HEAD(head, field)
> -#define	QMD_LIST_CHECK_NEXT(elm, field)
> -#define	QMD_LIST_CHECK_PREV(elm, field)
> -#endif /* (_KERNEL && INVARIANTS) */
> -
> -#define	LIST_EMPTY(head)	((head)->lh_first == NULL)
> -
> -#define	LIST_FIRST(head)	((head)->lh_first)
> -
> -#define	LIST_FOREACH(var, head, field)					\
> -	for ((var) = LIST_FIRST((head));				\
> -	    (var);							\
> -	    (var) = LIST_NEXT((var), field))
> -
> -#define	LIST_FOREACH_FROM(var, head, field)				\
> -	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
> -	    (var);							\
> -	    (var) = LIST_NEXT((var), field))
> -
> -#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
> -	for ((var) = LIST_FIRST((head));				\
> -	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	LIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
> -	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
> -	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	LIST_INIT(head) do {						\
> -	LIST_FIRST((head)) = NULL;					\
> -} while (0)
> -
> -#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
> -	QMD_LIST_CHECK_NEXT(listelm, field);				\
> -	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
> -		LIST_NEXT((listelm), field)->field.le_prev =		\
> -		    &LIST_NEXT((elm), field);				\
> -	LIST_NEXT((listelm), field) = (elm);				\
> -	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
> -} while (0)
> -
> -#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
> -	QMD_LIST_CHECK_PREV(listelm, field);				\
> -	(elm)->field.le_prev = (listelm)->field.le_prev;		\
> -	LIST_NEXT((elm), field) = (listelm);				\
> -	*(listelm)->field.le_prev = (elm);				\
> -	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
> -} while (0)
> -
> -#define	LIST_INSERT_HEAD(head, elm, field) do {				\
> -	QMD_LIST_CHECK_HEAD((head), field);				\
> -	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
> -		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
> -	LIST_FIRST((head)) = (elm);					\
> -	(elm)->field.le_prev = &LIST_FIRST((head));			\
> -} while (0)
> -
> -#define	LIST_NEXT(elm, field)	((elm)->field.le_next)
> -
> -#define	LIST_PREV(elm, head, type, field)			\
> -	((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL :	\
> -	    __containerof((elm)->field.le_prev,			\
> -	    QUEUE_TYPEOF(type), field.le_next))
> -
> -#define	LIST_REMOVE(elm, field) do {					\
> -	QMD_SAVELINK(oldnext, (elm)->field.le_next);			\
> -	QMD_SAVELINK(oldprev, (elm)->field.le_prev);			\
> -	QMD_LIST_CHECK_NEXT(elm, field);				\
> -	QMD_LIST_CHECK_PREV(elm, field);				\
> -	if (LIST_NEXT((elm), field) != NULL)				\
> -		LIST_NEXT((elm), field)->field.le_prev = 		\
> -		    (elm)->field.le_prev;				\
> -	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
> -	TRASHIT(*oldnext);						\
> -	TRASHIT(*oldprev);						\
> -} while (0)
> -
> -#define LIST_SWAP(head1, head2, type, field) do {			\
> -	QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1);		\
> -	LIST_FIRST((head1)) = LIST_FIRST((head2));			\
> -	LIST_FIRST((head2)) = swap_tmp;					\
> -	if ((swap_tmp = LIST_FIRST((head1))) != NULL)			\
> -		swap_tmp->field.le_prev = &LIST_FIRST((head1));		\
> -	if ((swap_tmp = LIST_FIRST((head2))) != NULL)			\
> -		swap_tmp->field.le_prev = &LIST_FIRST((head2));		\
> -} while (0)
> -
> -/*
> - * Tail queue declarations.
> - */
> -#define	TAILQ_HEAD(name, type)						\
> -struct name {								\
> -	struct type *tqh_first;	/* first element */			\
> -	struct type **tqh_last;	/* addr of last next element */		\
> -	TRACEBUF							\
> -}
> -
> -#define	TAILQ_CLASS_HEAD(name, type)					\
> -struct name {								\
> -	class type *tqh_first;	/* first element */			\
> -	class type **tqh_last;	/* addr of last next element */		\
> -	TRACEBUF							\
> -}
> -
> -#define	TAILQ_HEAD_INITIALIZER(head)					\
> -	{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
> -
> -#define	TAILQ_ENTRY(type)						\
> -struct {								\
> -	struct type *tqe_next;	/* next element */			\
> -	struct type **tqe_prev;	/* address of previous next element */	\
> -	TRACEBUF							\
> -}
> -
> -#define	TAILQ_CLASS_ENTRY(type)						\
> -struct {								\
> -	class type *tqe_next;	/* next element */			\
> -	class type **tqe_prev;	/* address of previous next element */	\
> -	TRACEBUF							\
> -}
> -
> -/*
> - * Tail queue functions.
> - */
> -#if (defined(_KERNEL) && defined(INVARIANTS))
> -#define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
> -	if (!TAILQ_EMPTY(head) &&					\
> -	    TAILQ_FIRST((head))->field.tqe_prev !=			\
> -	     &TAILQ_FIRST((head)))					\
> -		panic("Bad tailq head %p first->prev != head", (head));	\
> -} while (0)
> -
> -#define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
> -	if (*(head)->tqh_last != NULL)					\
> -		panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
> -} while (0)
> -
> -#define	QMD_TAILQ_CHECK_NEXT(elm, field) do {				\
> -	if (TAILQ_NEXT((elm), field) != NULL &&				\
> -	    TAILQ_NEXT((elm), field)->field.tqe_prev !=			\
> -	     &((elm)->field.tqe_next))					\
> -		panic("Bad link elm %p next->prev != elm", (elm));	\
> -} while (0)
> -
> -#define	QMD_TAILQ_CHECK_PREV(elm, field) do {				\
> -	if (*(elm)->field.tqe_prev != (elm))				\
> -		panic("Bad link elm %p prev->next != elm", (elm));	\
> -} while (0)
> -#else
> -#define	QMD_TAILQ_CHECK_HEAD(head, field)
> -#define	QMD_TAILQ_CHECK_TAIL(head, headname)
> -#define	QMD_TAILQ_CHECK_NEXT(elm, field)
> -#define	QMD_TAILQ_CHECK_PREV(elm, field)
> -#endif /* (_KERNEL && INVARIANTS) */
> -
> -#define	TAILQ_CONCAT(head1, head2, field) do {				\
> -	if (!TAILQ_EMPTY(head2)) {					\
> -		*(head1)->tqh_last = (head2)->tqh_first;		\
> -		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
> -		(head1)->tqh_last = (head2)->tqh_last;			\
> -		TAILQ_INIT((head2));					\
> -		QMD_TRACE_HEAD(head1);					\
> -		QMD_TRACE_HEAD(head2);					\
> -	}								\
> -} while (0)
> -
> -#define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
> -
> -#define	TAILQ_FIRST(head)	((head)->tqh_first)
> -
> -#define	TAILQ_FOREACH(var, head, field)					\
> -	for ((var) = TAILQ_FIRST((head));				\
> -	    (var);							\
> -	    (var) = TAILQ_NEXT((var), field))
> -
> -#define	TAILQ_FOREACH_FROM(var, head, field)				\
> -	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
> -	    (var);							\
> -	    (var) = TAILQ_NEXT((var), field))
> -
> -#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
> -	for ((var) = TAILQ_FIRST((head));				\
> -	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)			\
> -	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
> -	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
> -	    (var) = (tvar))
> -
> -#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
> -	for ((var) = TAILQ_LAST((head), headname);			\
> -	    (var);							\
> -	    (var) = TAILQ_PREV((var), headname, field))
> -
> -#define	TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)		\
> -	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
> -	    (var);							\
> -	    (var) = TAILQ_PREV((var), headname, field))
> -
> -#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
> -	for ((var) = TAILQ_LAST((head), headname);			\
> -	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
> -	    (var) = (tvar))
> -
> -#define	TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
> -	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
> -	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
> -	    (var) = (tvar))
> -
> -#define	TAILQ_INIT(head) do {						\
> -	TAILQ_FIRST((head)) = NULL;					\
> -	(head)->tqh_last = &TAILQ_FIRST((head));			\
> -	QMD_TRACE_HEAD(head);						\
> -} while (0)
> -
> -#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
> -	QMD_TAILQ_CHECK_NEXT(listelm, field);				\
> -	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
> -		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
> -		    &TAILQ_NEXT((elm), field);				\
> -	else {								\
> -		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
> -		QMD_TRACE_HEAD(head);					\
> -	}								\
> -	TAILQ_NEXT((listelm), field) = (elm);				\
> -	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);		\
> -	QMD_TRACE_ELEM(&(elm)->field);					\
> -	QMD_TRACE_ELEM(&(listelm)->field);				\
> -} while (0)
> -
> -#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
> -	QMD_TAILQ_CHECK_PREV(listelm, field);				\
> -	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
> -	TAILQ_NEXT((elm), field) = (listelm);				\
> -	*(listelm)->field.tqe_prev = (elm);				\
> -	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);		\
> -	QMD_TRACE_ELEM(&(elm)->field);					\
> -	QMD_TRACE_ELEM(&(listelm)->field);				\
> -} while (0)
> -
> -#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
> -	QMD_TAILQ_CHECK_HEAD(head, field);				\
> -	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
> -		TAILQ_FIRST((head))->field.tqe_prev =			\
> -		    &TAILQ_NEXT((elm), field);				\
> -	else								\
> -		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
> -	TAILQ_FIRST((head)) = (elm);					\
> -	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
> -	QMD_TRACE_HEAD(head);						\
> -	QMD_TRACE_ELEM(&(elm)->field);					\
> -} while (0)
> -
> -#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
> -	QMD_TAILQ_CHECK_TAIL(head, field);				\
> -	TAILQ_NEXT((elm), field) = NULL;				\
> -	(elm)->field.tqe_prev = (head)->tqh_last;			\
> -	*(head)->tqh_last = (elm);					\
> -	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
> -	QMD_TRACE_HEAD(head);						\
> -	QMD_TRACE_ELEM(&(elm)->field);					\
> -} while (0)
> -
> -#define	TAILQ_LAST(head, headname)					\
> -	(*(((struct headname *)((head)->tqh_last))->tqh_last))
> -
> -#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
> -
> -#define	TAILQ_PREV(elm, headname, field)				\
> -	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
> -
> -#define	TAILQ_REMOVE(head, elm, field) do {				\
> -	QMD_SAVELINK(oldnext, (elm)->field.tqe_next);			\
> -	QMD_SAVELINK(oldprev, (elm)->field.tqe_prev);			\
> -	QMD_TAILQ_CHECK_NEXT(elm, field);				\
> -	QMD_TAILQ_CHECK_PREV(elm, field);				\
> -	if ((TAILQ_NEXT((elm), field)) != NULL)				\
> -		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
> -		    (elm)->field.tqe_prev;				\
> -	else {								\
> -		(head)->tqh_last = (elm)->field.tqe_prev;		\
> -		QMD_TRACE_HEAD(head);					\
> -	}								\
> -	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);		\
> -	TRASHIT(*oldnext);						\
> -	TRASHIT(*oldprev);						\
> -	QMD_TRACE_ELEM(&(elm)->field);					\
> -} while (0)
> -
> -#define TAILQ_SWAP(head1, head2, type, field) do {			\
> -	QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first;		\
> -	QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last;		\
> -	(head1)->tqh_first = (head2)->tqh_first;			\
> -	(head1)->tqh_last = (head2)->tqh_last;				\
> -	(head2)->tqh_first = swap_first;				\
> -	(head2)->tqh_last = swap_last;					\
> -	if ((swap_first = (head1)->tqh_first) != NULL)			\
> -		swap_first->field.tqe_prev = &(head1)->tqh_first;	\
> -	else								\
> -		(head1)->tqh_last = &(head1)->tqh_first;		\
> -	if ((swap_first = (head2)->tqh_first) != NULL)			\
> -		swap_first->field.tqe_prev = &(head2)->tqh_first;	\
> -	else								\
> -		(head2)->tqh_last = &(head2)->tqh_first;		\
> -} while (0)
> -
> -#endif /* !_SYS_QUEUE_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_features.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_FEATURES_H_
> -#define CS_MONGOOSE_SRC_FEATURES_H_
> -
> -#ifndef MG_DISABLE_HTTP_DIGEST_AUTH
> -#define MG_DISABLE_HTTP_DIGEST_AUTH 0
> -#endif
> -
> -#ifndef MG_DISABLE_HTTP_KEEP_ALIVE
> -#define MG_DISABLE_HTTP_KEEP_ALIVE 0
> -#endif
> -
> -#ifndef MG_DISABLE_PFS
> -#define MG_DISABLE_PFS 0
> -#endif
> -
> -#ifndef MG_DISABLE_WS_RANDOM_MASK
> -#define MG_DISABLE_WS_RANDOM_MASK 0
> -#endif
> -
> -#ifndef MG_ENABLE_ASYNC_RESOLVER
> -#define MG_ENABLE_ASYNC_RESOLVER 1
> -#endif
> -
> -#ifndef MG_ENABLE_BROADCAST
> -#define MG_ENABLE_BROADCAST 0
> -#endif
> -
> -#ifndef MG_ENABLE_COAP
> -#define MG_ENABLE_COAP 0
> -#endif
> -
> -#ifndef MG_ENABLE_DEBUG
> -#define MG_ENABLE_DEBUG 0
> -#endif
> -
> -#ifndef MG_ENABLE_DIRECTORY_LISTING
> -#define MG_ENABLE_DIRECTORY_LISTING 0
> -#endif
> -
> -#ifndef MG_ENABLE_DNS
> -#define MG_ENABLE_DNS 1
> -#endif
> -
> -#ifndef MG_ENABLE_DNS_SERVER
> -#define MG_ENABLE_DNS_SERVER 0
> -#endif
> -
> -#ifndef MG_ENABLE_FAKE_DAVLOCK
> -#define MG_ENABLE_FAKE_DAVLOCK 0
> -#endif
> -
> -#ifndef MG_ENABLE_FILESYSTEM
> -#define MG_ENABLE_FILESYSTEM 0
> -#endif
> -
> -#ifndef MG_ENABLE_GETADDRINFO
> -#define MG_ENABLE_GETADDRINFO 0
> -#endif
> -
> -#ifndef MG_ENABLE_HEXDUMP
> -#define MG_ENABLE_HEXDUMP CS_ENABLE_STDIO
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP
> -#define MG_ENABLE_HTTP 1
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_CGI
> -#define MG_ENABLE_HTTP_CGI 0
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_SSI
> -#define MG_ENABLE_HTTP_SSI MG_ENABLE_FILESYSTEM
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_SSI_EXEC
> -#define MG_ENABLE_HTTP_SSI_EXEC 0
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_STREAMING_MULTIPART
> -#define MG_ENABLE_HTTP_STREAMING_MULTIPART 0
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_WEBDAV
> -#define MG_ENABLE_HTTP_WEBDAV 0
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_WEBSOCKET
> -#define MG_ENABLE_HTTP_WEBSOCKET MG_ENABLE_HTTP
> -#endif
> -
> -#ifndef MG_ENABLE_IPV6
> -#define MG_ENABLE_IPV6 0
> -#endif
> -
> -#ifndef MG_ENABLE_MQTT
> -#define MG_ENABLE_MQTT 1
> -#endif
> -
> -#ifndef MG_ENABLE_SOCKS
> -#define MG_ENABLE_SOCKS 0
> -#endif
> -
> -#ifndef MG_ENABLE_MQTT_BROKER
> -#define MG_ENABLE_MQTT_BROKER 0
> -#endif
> -
> -#ifndef MG_ENABLE_SSL
> -#define MG_ENABLE_SSL 0
> -#endif
> -
> -#ifndef MG_ENABLE_SYNC_RESOLVER
> -#define MG_ENABLE_SYNC_RESOLVER 0
> -#endif
> -
> -#ifndef MG_ENABLE_STDIO
> -#define MG_ENABLE_STDIO CS_ENABLE_STDIO
> -#endif
> -
> -#ifndef MG_NET_IF
> -#define MG_NET_IF MG_NET_IF_SOCKET
> -#endif
> -
> -#ifndef MG_SSL_IF
> -#define MG_SSL_IF MG_SSL_IF_OPENSSL
> -#endif
> -
> -#ifndef MG_ENABLE_THREADS /* ifdef-ok */
> -#ifdef _WIN32
> -#define MG_ENABLE_THREADS 1
> -#else
> -#define MG_ENABLE_THREADS 0
> -#endif
> -#endif
> -
> -#if MG_ENABLE_DEBUG && !defined(CS_ENABLE_DEBUG)
> -#define CS_ENABLE_DEBUG 1
> -#endif
> -
> -/* MQTT broker requires MQTT */
> -#if MG_ENABLE_MQTT_BROKER && !MG_ENABLE_MQTT
> -#undef MG_ENABLE_MQTT
> -#define MG_ENABLE_MQTT 1
> -#endif
> -
> -#ifndef MG_ENABLE_HTTP_URL_REWRITES
> -#define MG_ENABLE_HTTP_URL_REWRITES \
> -  (CS_PLATFORM == CS_P_WINDOWS || CS_PLATFORM == CS_P_UNIX)
> -#endif
> -
> -#ifndef MG_ENABLE_SNTP
> -#define MG_ENABLE_SNTP 0
> -#endif
> -
> -#ifndef MG_ENABLE_EXTRA_ERRORS_DESC
> -#define MG_ENABLE_EXTRA_ERRORS_DESC 0
> -#endif
> -
> -#ifndef MG_ENABLE_CALLBACK_USERDATA
> -#define MG_ENABLE_CALLBACK_USERDATA 0
> -#endif
> -
> -#if MG_ENABLE_CALLBACK_USERDATA
> -#define MG_UD_ARG(ud) , ud
> -#define MG_CB(cb, ud) cb, ud
> -#else
> -#define MG_UD_ARG(ud)
> -#define MG_CB(cb, ud) cb
> -#endif
> -
> -#endif /* CS_MONGOOSE_SRC_FEATURES_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net_if.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_NET_IF_H_
> -#define CS_MONGOOSE_SRC_NET_IF_H_
> -
> -/* Amalgamated: #include "common/platform.h" */
> -
> -/*
> - * Internal async networking core interface.
> - * Consists of calls made by the core, which should not block,
> - * and callbacks back into the core ("..._cb").
> - * Callbacks may (will) cause methods to be invoked from within,
> - * but methods are not allowed to invoke callbacks inline.
> - *
> - * Implementation must ensure that only one callback is invoked at any time.
> - */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -#define MG_MAIN_IFACE 0
> -
> -struct mg_mgr;
> -struct mg_connection;
> -union socket_address;
> -
> -struct mg_iface_vtable;
> -
> -struct mg_iface {
> -  struct mg_mgr *mgr;
> -  void *data; /* Implementation-specific data */
> -  const struct mg_iface_vtable *vtable;
> -};
> -
> -struct mg_iface_vtable {
> -  void (*init)(struct mg_iface *iface);
> -  void (*free)(struct mg_iface *iface);
> -  void (*add_conn)(struct mg_connection *nc);
> -  void (*remove_conn)(struct mg_connection *nc);
> -  time_t (*poll)(struct mg_iface *iface, int timeout_ms);
> -
> -  /* Set up a listening TCP socket on a given address. rv = 0 -> ok. */
> -  int (*listen_tcp)(struct mg_connection *nc, union socket_address *sa);
> -  /* Request that a "listening" UDP socket be created. */
> -  int (*listen_udp)(struct mg_connection *nc, union socket_address *sa);
> -
> -  /* Request that a TCP connection is made to the specified address. */
> -  void (*connect_tcp)(struct mg_connection *nc, const union socket_address *sa);
> -  /* Open a UDP socket. Doesn't actually connect anything. */
> -  void (*connect_udp)(struct mg_connection *nc);
> -
> -  /* Send functions for TCP and UDP. Sent data is copied before return. */
> -  int (*tcp_send)(struct mg_connection *nc, const void *buf, size_t len);
> -  int (*udp_send)(struct mg_connection *nc, const void *buf, size_t len);
> -
> -  int (*tcp_recv)(struct mg_connection *nc, void *buf, size_t len);
> -  int (*udp_recv)(struct mg_connection *nc, void *buf, size_t len,
> -                  union socket_address *sa, size_t *sa_len);
> -
> -  /* Perform interface-related connection initialization. Return 1 on ok. */
> -  int (*create_conn)(struct mg_connection *nc);
> -  /* Perform interface-related cleanup on connection before destruction. */
> -  void (*destroy_conn)(struct mg_connection *nc);
> -
> -  /* Associate a socket to a connection. */
> -  void (*sock_set)(struct mg_connection *nc, sock_t sock);
> -
> -  /* Put connection's address into *sa, local (remote = 0) or remote. */
> -  void (*get_conn_addr)(struct mg_connection *nc, int remote,
> -                        union socket_address *sa);
> -};
> -
> -extern const struct mg_iface_vtable *mg_ifaces[];
> -extern int mg_num_ifaces;
> -
> -/* Creates a new interface instance. */
> -struct mg_iface *mg_if_create_iface(const struct mg_iface_vtable *vtable,
> -                                    struct mg_mgr *mgr);
> -
> -/*
> - * Find an interface with a given implementation. The search is started from
> - * interface `from`, exclusive. Returns NULL if none is found.
> - */
> -struct mg_iface *mg_find_iface(struct mg_mgr *mgr,
> -                               const struct mg_iface_vtable *vtable,
> -                               struct mg_iface *from);
> -/*
> - * Deliver a new TCP connection. Returns NULL in case on error (unable to
> - * create connection, in which case interface state should be discarded.
> - * This is phase 1 of the two-phase process - MG_EV_ACCEPT will be delivered
> - * when mg_if_accept_tcp_cb is invoked.
> - */
> -struct mg_connection *mg_if_accept_new_conn(struct mg_connection *lc);
> -void mg_if_accept_tcp_cb(struct mg_connection *nc, union socket_address *sa,
> -                         size_t sa_len);
> -
> -/* Callback invoked by connect methods. err = 0 -> ok, != 0 -> error. */
> -void mg_if_connect_cb(struct mg_connection *nc, int err);
> -/*
> - * Callback that tells the core that data can be received.
> - * Core will use tcp/udp_recv to retrieve the data.
> - */
> -void mg_if_can_recv_cb(struct mg_connection *nc);
> -void mg_if_can_send_cb(struct mg_connection *nc);
> -/*
> - * Receive callback.
> - * buf must be heap-allocated and ownership is transferred to the core.
> - */
> -void mg_if_recv_udp_cb(struct mg_connection *nc, void *buf, int len,
> -                       union socket_address *sa, size_t sa_len);
> -
> -/* void mg_if_close_conn(struct mg_connection *nc); */
> -
> -/* Deliver a POLL event to the connection. */
> -int mg_if_poll(struct mg_connection *nc, double now);
> -
> -/*
> - * Return minimal timer value amoung connections in the manager.
> - * Returns 0 if there aren't any timers.
> - */
> -double mg_mgr_min_timer(const struct mg_mgr *mgr);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_MONGOOSE_SRC_NET_IF_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_ssl_if.h"
> -#endif
> -
> -#ifndef CS_MONGOOSE_SRC_SSL_IF_H_
> -#define CS_MONGOOSE_SRC_SSL_IF_H_
> -
> -#if MG_ENABLE_SSL
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -struct mg_ssl_if_ctx;
> -struct mg_connection;
> -
> -void mg_ssl_if_init(void);
> -
> -enum mg_ssl_if_result {
> -  MG_SSL_OK = 0,
> -  MG_SSL_WANT_READ = -1,
> -  MG_SSL_WANT_WRITE = -2,
> -  MG_SSL_ERROR = -3,
> -};
> -
> -struct mg_ssl_if_conn_params {
> -  const char *cert;
> -  const char *key;
> -  const char *ca_cert;
> -  const char *server_name;
> -  const char *cipher_suites;
> -  const char *psk_identity;
> -  const char *psk_key;
> -};
> -
> -enum mg_ssl_if_result mg_ssl_if_conn_init(
> -    struct mg_connection *nc, const struct mg_ssl_if_conn_params *params,
> -    const char **err_msg);
> -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc,
> -                                            struct mg_connection *lc);
> -void mg_ssl_if_conn_close_notify(struct mg_connection *nc);
> -void mg_ssl_if_conn_free(struct mg_connection *nc);
> -
> -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc);
> -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t buf_size);
> -int mg_ssl_if_write(struct mg_connection *nc, const void *data, size_t len);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* MG_ENABLE_SSL */
> -
> -#endif /* CS_MONGOOSE_SRC_SSL_IF_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_net.h"
> -#endif
> -
> -/*
> - * === Core API: TCP/UDP/SSL
> - *
> - * NOTE: Mongoose manager is single threaded. It does not protect
> - * its data structures by mutexes, therefore all functions that are dealing
> - * with a particular event manager should be called from the same thread,
> - * with exception of the `mg_broadcast()` function. It is fine to have different
> - * event managers handled by different threads.
> - */
> -
> -#ifndef CS_MONGOOSE_SRC_NET_H_
> -#define CS_MONGOOSE_SRC_NET_H_
> -
> -/* Amalgamated: #include "mg_common.h" */
> -/* Amalgamated: #include "mg_net_if.h" */
> -/* Amalgamated: #include "common/mbuf.h" */
> -
> -#ifndef MG_VPRINTF_BUFFER_SIZE
> -#define MG_VPRINTF_BUFFER_SIZE 100
> -#endif
> -
> -#ifdef MG_USE_READ_WRITE
> -#define MG_RECV_FUNC(s, b, l, f) read(s, b, l)
> -#define MG_SEND_FUNC(s, b, l, f) write(s, b, l)
> -#else
> -#define MG_RECV_FUNC(s, b, l, f) recv(s, b, l, f)
> -#define MG_SEND_FUNC(s, b, l, f) send(s, b, l, f)
> -#endif
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -union socket_address {
> -  struct sockaddr sa;
> -  struct sockaddr_in sin;
> -#if MG_ENABLE_IPV6
> -  struct sockaddr_in6 sin6;
> -#else
> -  struct sockaddr sin6;
> -#endif
> -};
> -
> -struct mg_connection;
> -
> -/*
> - * Callback function (event handler) prototype. Must be defined by the user.
> - * Mongoose calls the event handler, passing the events defined below.
> - */
> -typedef void (*mg_event_handler_t)(struct mg_connection *nc, int ev,
> -                                   void *ev_data MG_UD_ARG(void *user_data));
> -
> -/* Events. Meaning of event parameter (evp) is given in the comment. */
> -#define MG_EV_POLL 0    /* Sent to each connection on each mg_mgr_poll() call */
> -#define MG_EV_ACCEPT 1  /* New connection accepted. union socket_address * */
> -#define MG_EV_CONNECT 2 /* connect() succeeded or failed. int *  */
> -#define MG_EV_RECV 3    /* Data has been received. int *num_bytes */
> -#define MG_EV_SEND 4    /* Data has been written to a socket. int *num_bytes */
> -#define MG_EV_CLOSE 5   /* Connection is closed. NULL */
> -#define MG_EV_TIMER 6   /* now >= conn->ev_timer_time. double * */
> -
> -/*
> - * Mongoose event manager.
> - */
> -struct mg_mgr {
> -  struct mg_connection *active_connections;
> -#if MG_ENABLE_HEXDUMP
> -  const char *hexdump_file; /* Debug hexdump file path */
> -#endif
> -#if MG_ENABLE_BROADCAST
> -  sock_t ctl[2]; /* Socketpair for mg_broadcast() */
> -#endif
> -  void *user_data; /* User data */
> -  int num_ifaces;
> -  int num_calls;
> -  struct mg_iface **ifaces; /* network interfaces */
> -  const char *nameserver;   /* DNS server to use */
> -};
> -
> -/*
> - * Mongoose connection.
> - */
> -struct mg_connection {
> -  struct mg_connection *next, *prev; /* mg_mgr::active_connections linkage */
> -  struct mg_connection *listener;    /* Set only for accept()-ed connections */
> -  struct mg_mgr *mgr;                /* Pointer to containing manager */
> -
> -  sock_t sock; /* Socket to the remote peer */
> -  int err;
> -  union socket_address sa; /* Remote peer address */
> -  size_t recv_mbuf_limit;  /* Max size of recv buffer */
> -  struct mbuf recv_mbuf;   /* Received data */
> -  struct mbuf send_mbuf;   /* Data scheduled for sending */
> -  time_t last_io_time;     /* Timestamp of the last socket IO */
> -  double ev_timer_time;    /* Timestamp of the future MG_EV_TIMER */
> -  mg_event_handler_t proto_handler; /* Protocol-specific event handler */
> -  void *proto_data;                 /* Protocol-specific data */
> -  void (*proto_data_destructor)(void *proto_data);
> -  mg_event_handler_t handler; /* Event handler function */
> -  void *user_data;            /* User-specific data */
> -  union {
> -    void *v;
> -    /*
> -     * the C standard is fussy about fitting function pointers into
> -     * void pointers, since some archs might have fat pointers for functions.
> -     */
> -    mg_event_handler_t f;
> -  } priv_1;
> -  void *priv_2;
> -  void *mgr_data; /* Implementation-specific event manager's data. */
> -  struct mg_iface *iface;
> -  unsigned long flags;
> -/* Flags set by Mongoose */
> -#define MG_F_LISTENING (1 << 0)          /* This connection is listening */
> -#define MG_F_UDP (1 << 1)                /* This connection is UDP */
> -#define MG_F_RESOLVING (1 << 2)          /* Waiting for async resolver */
> -#define MG_F_CONNECTING (1 << 3)         /* connect() call in progress */
> -#define MG_F_SSL (1 << 4)                /* SSL is enabled on the connection */
> -#define MG_F_SSL_HANDSHAKE_DONE (1 << 5) /* SSL hanshake has completed */
> -#define MG_F_WANT_READ (1 << 6)          /* SSL specific */
> -#define MG_F_WANT_WRITE (1 << 7)         /* SSL specific */
> -#define MG_F_IS_WEBSOCKET (1 << 8)       /* Websocket specific */
> -#define MG_F_RECV_AND_CLOSE (1 << 9) /* Drain rx and close the connection. */
> -
> -/* Flags that are settable by user */
> -#define MG_F_SEND_AND_CLOSE (1 << 10)      /* Push remaining data and close  */
> -#define MG_F_CLOSE_IMMEDIATELY (1 << 11)   /* Disconnect */
> -
> -/* Flags for protocol handlers */
> -#define MG_F_PROTO_1 (1 << 12)
> -#define MG_F_PROTO_2 (1 << 13)
> -#define MG_F_ENABLE_BROADCAST (1 << 14)    /* Allow broadcast address usage */
> -
> -/* Flags left for application */
> -#define MG_F_USER_1 (1 << 20)
> -#define MG_F_USER_2 (1 << 21)
> -#define MG_F_USER_3 (1 << 22)
> -#define MG_F_USER_4 (1 << 23)
> -#define MG_F_USER_5 (1 << 24)
> -#define MG_F_USER_6 (1 << 25)
> -
> -#if MG_ENABLE_SSL
> -  void *ssl_if_data; /* SSL library data. */
> -#else
> -  void *unused_ssl_if_data; /* To keep the size of the structure the same. */
> -#endif
> -};
> -
> -/*
> - * Initialise Mongoose manager. Side effect: ignores SIGPIPE signal.
> - * `mgr->user_data` field will be initialised with a `user_data` parameter.
> - * That is an arbitrary pointer, where the user code can associate some data
> - * with the particular Mongoose manager. For example, a C++ wrapper class
> - * could be written in which case `user_data` can hold a pointer to the
> - * class instance.
> - */
> -void mg_mgr_init(struct mg_mgr *mgr, void *user_data);
> -
> -/*
> - * Optional parameters to `mg_mgr_init_opt()`.
> - *
> - * If `main_iface` is not NULL, it will be used as the main interface in the
> - * default interface set. The pointer will be free'd by `mg_mgr_free`.
> - * Otherwise, the main interface will be autodetected based on the current
> - * platform.
> - *
> - * If `num_ifaces` is 0 and `ifaces` is NULL, the default interface set will be
> - * used.
> - * This is an advanced option, as it requires you to construct a full interface
> - * set, including special networking interfaces required by some optional
> - * features such as TCP tunneling. Memory backing `ifaces` and each of the
> - * `num_ifaces` pointers it contains will be reclaimed by `mg_mgr_free`.
> - */
> -struct mg_mgr_init_opts {
> -  const struct mg_iface_vtable *main_iface;
> -  int num_ifaces;
> -  const struct mg_iface_vtable **ifaces;
> -  const char *nameserver;
> -};
> -
> -/*
> - * Like `mg_mgr_init` but with more options.
> - *
> - * Notably, this allows you to create a manger and choose
> - * dynamically which networking interface implementation to use.
> - */
> -void mg_mgr_init_opt(struct mg_mgr *mgr, void *user_data,
> -                     struct mg_mgr_init_opts opts);
> -
> -/*
> - * De-initialises Mongoose manager.
> - *
> - * Closes and deallocates all active connections.
> - */
> -void mg_mgr_free(struct mg_mgr *mgr);
> -
> -/*
> - * This function performs the actual IO and must be called in a loop
> - * (an event loop). It returns number of user events generated (except POLLs).
> - * `milli` is the maximum number of milliseconds to sleep.
> - * `mg_mgr_poll()` checks all connections for IO readiness. If at least one
> - * of the connections is IO-ready, `mg_mgr_poll()` triggers the respective
> - * event handlers and returns.
> - */
> -int mg_mgr_poll(struct mg_mgr *mgr, int milli);
> -
> -#if MG_ENABLE_BROADCAST
> -/*
> - * Passes a message of a given length to all connections.
> - *
> - * Must be called from a thread that does NOT call `mg_mgr_poll()`.
> - * Note that `mg_broadcast()` is the only function
> - * that can be, and must be, called from a different (non-IO) thread.
> - *
> - * `func` callback function will be called by the IO thread for each
> - * connection. When called, the event will be `MG_EV_POLL`, and a message will
> - * be passed as the `ev_data` pointer. Maximum message size is capped
> - * by `MG_CTL_MSG_MESSAGE_SIZE` which is set to 8192 bytes by default.
> - */
> -void mg_broadcast(struct mg_mgr *mgr, mg_event_handler_t cb, void *data,
> -                  size_t len);
> -#endif
> -
> -/*
> - * Iterates over all active connections.
> - *
> - * Returns the next connection from the list
> - * of active connections or `NULL` if there are no more connections. Below
> - * is the iteration idiom:
> - *
> - * ```c
> - * for (c = mg_next(srv, NULL); c != NULL; c = mg_next(srv, c)) {
> - *   // Do something with connection `c`
> - * }
> - * ```
> - */
> -struct mg_connection *mg_next(struct mg_mgr *mgr, struct mg_connection *c);
> -
> -/*
> - * Optional parameters to `mg_add_sock_opt()`.
> - *
> - * `flags` is an initial `struct mg_connection::flags` bitmask to set,
> - * see `MG_F_*` flags definitions.
> - */
> -struct mg_add_sock_opts {
> -  void *user_data;           /* Initial value for connection's user_data */
> -  unsigned int flags;        /* Initial connection flags */
> -  const char **error_string; /* Placeholder for the error string */
> -  struct mg_iface *iface;    /* Interface instance */
> -};
> -
> -/*
> - * Creates a connection, associates it with the given socket and event handler
> - * and adds it to the manager.
> - *
> - * For more options see the `mg_add_sock_opt` variant.
> - */
> -struct mg_connection *mg_add_sock(struct mg_mgr *mgr, sock_t sock,
> -                                  MG_CB(mg_event_handler_t handler,
> -                                        void *user_data));
> -
> -/*
> - * Creates a connection, associates it with the given socket and event handler
> - * and adds to the manager.
> - *
> - * See the `mg_add_sock_opts` structure for a description of the options.
> - */
> -struct mg_connection *mg_add_sock_opt(struct mg_mgr *mgr, sock_t sock,
> -                                      MG_CB(mg_event_handler_t handler,
> -                                            void *user_data),
> -                                      struct mg_add_sock_opts opts);
> -
> -/*
> - * Optional parameters to `mg_bind_opt()`.
> - *
> - * `flags` is an initial `struct mg_connection::flags` bitmask to set,
> - * see `MG_F_*` flags definitions.
> - */
> -struct mg_bind_opts {
> -  void *user_data;           /* Initial value for connection's user_data */
> -  unsigned int flags;        /* Extra connection flags */
> -  const char **error_string; /* Placeholder for the error string */
> -  struct mg_iface *iface;    /* Interface instance */
> -#if MG_ENABLE_SSL
> -  /*
> -   * SSL settings.
> -   *
> -   * Server certificate to present to clients or client certificate to
> -   * present to tunnel dispatcher (for tunneled connections).
> -   */
> -  const char *ssl_cert;
> -  /* Private key corresponding to the certificate. If ssl_cert is set but
> -   * ssl_key is not, ssl_cert is used. */
> -  const char *ssl_key;
> -  /* CA bundle used to verify client certificates or tunnel dispatchers. */
> -  const char *ssl_ca_cert;
> -  /* Colon-delimited list of acceptable cipher suites.
> -   * Names depend on the library used, for example:
> -   *
> -   * ECDH-ECDSA-AES128-GCM-SHA256:DHE-RSA-AES128-SHA256 (OpenSSL)
> -   * TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256
> -   *   (mbedTLS)
> -   *
> -   * For OpenSSL the list can be obtained by running "openssl ciphers".
> -   * For mbedTLS, names can be found in library/ssl_ciphersuites.c
> -   * If NULL, a reasonable default is used.
> -   */
> -  const char *ssl_cipher_suites;
> -#endif
> -};
> -
> -/*
> - * Creates a listening connection.
> - *
> - * See `mg_bind_opt` for full documentation.
> - */
> -struct mg_connection *mg_bind(struct mg_mgr *mgr, const char *address,
> -                              MG_CB(mg_event_handler_t handler,
> -                                    void *user_data));
> -/*
> - * Creates a listening connection.
> - *
> - * The `address` parameter specifies which address to bind to. It's format is
> - * the same as for the `mg_connect()` call, where `HOST` part is optional.
> - * `address` can be just a port number, e.g. `:8000`. To bind to a specific
> - * interface, an IP address can be specified, e.g. `1.2.3.4:8000`. By default,
> - * a TCP connection is created. To create UDP connection, prepend `udp://`
> - * prefix, e.g. `udp://:8000`. To summarize, `address` parameter has following
> - * format: `[PROTO://][IP_ADDRESS]:PORT`, where `PROTO` could be `tcp` or
> - * `udp`.
> - *
> - * See the `mg_bind_opts` structure for a description of the optional
> - * parameters.
> - *
> - * Returns a new listening connection or `NULL` on error.
> - * NOTE: The connection remains owned by the manager, do not free().
> - */
> -struct mg_connection *mg_bind_opt(struct mg_mgr *mgr, const char *address,
> -                                  MG_CB(mg_event_handler_t handler,
> -                                        void *user_data),
> -                                  struct mg_bind_opts opts);
> -
> -/* Optional parameters to `mg_connect_opt()` */
> -struct mg_connect_opts {
> -  void *user_data;           /* Initial value for connection's user_data */
> -  unsigned int flags;        /* Extra connection flags */
> -  const char **error_string; /* Placeholder for the error string */
> -  struct mg_iface *iface;    /* Interface instance */
> -  const char *nameserver;    /* DNS server to use, NULL for default */
> -#if MG_ENABLE_SSL
> -  /*
> -   * SSL settings.
> -   * Client certificate to present to the server.
> -   */
> -  const char *ssl_cert;
> -  /*
> -   * Private key corresponding to the certificate.
> -   * If ssl_cert is set but ssl_key is not, ssl_cert is used.
> -   */
> -  const char *ssl_key;
> -  /*
> -   * Verify server certificate using this CA bundle. If set to "*", then SSL
> -   * is enabled but no cert verification is performed.
> -   */
> -  const char *ssl_ca_cert;
> -  /* Colon-delimited list of acceptable cipher suites.
> -   * Names depend on the library used, for example:
> -   *
> -   * ECDH-ECDSA-AES128-GCM-SHA256:DHE-RSA-AES128-SHA256 (OpenSSL)
> -   * TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256
> -   *   (mbedTLS)
> -   *
> -   * For OpenSSL the list can be obtained by running "openssl ciphers".
> -   * For mbedTLS, names can be found in library/ssl_ciphersuites.c
> -   * If NULL, a reasonable default is used.
> -   */
> -  const char *ssl_cipher_suites;
> -  /*
> -   * Server name verification. If ssl_ca_cert is set and the certificate has
> -   * passed verification, its subject will be verified against this string.
> -   * By default (if ssl_server_name is NULL) hostname part of the address will
> -   * be used. Wildcard matching is supported. A special value of "*" disables
> -   * name verification.
> -   */
> -  const char *ssl_server_name;
> -  /*
> -   * PSK identity and key. Identity is a NUL-terminated string and key is a hex
> -   * string. Key must be either 16 or 32 bytes (32 or 64 hex digits) for AES-128
> -   * or AES-256 respectively.
> -   * Note: Default list of cipher suites does not include PSK suites, if you
> -   * want to use PSK you will need to set ssl_cipher_suites as well.
> -   */
> -  const char *ssl_psk_identity;
> -  const char *ssl_psk_key;
> -#endif
> -};
> -
> -/*
> - * Connects to a remote host.
> - *
> - * See `mg_connect_opt()` for full documentation.
> - */
> -struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *address,
> -                                 MG_CB(mg_event_handler_t handler,
> -                                       void *user_data));
> -
> -/*
> - * Connects to a remote host.
> - *
> - * The `address` format is `[PROTO://]HOST:PORT`. `PROTO` could be `tcp` or
> - * `udp`. `HOST` could be an IP address,
> - * IPv6 address (if Mongoose is compiled with `-DMG_ENABLE_IPV6`) or a host
> - * name. If `HOST` is a name, Mongoose will resolve it asynchronously. Examples
> - * of valid addresses: `google.com:80`, `udp://1.2.3.4:53`, `10.0.0.1:443`,
> - * `[::1]:80`
> - *
> - * See the `mg_connect_opts` structure for a description of the optional
> - * parameters.
> - *
> - * Returns a new outbound connection or `NULL` on error.
> - *
> - * NOTE: The connection remains owned by the manager, do not free().
> - *
> - * NOTE: To enable IPv6 addresses `-DMG_ENABLE_IPV6` should be specified
> - * in the compilation flags.
> - *
> - * NOTE: The new connection will receive `MG_EV_CONNECT` as its first event
> - * which will report the connect success status.
> - * If the asynchronous resolution fails or the `connect()` syscall fails for
> - * whatever reason (e.g. with `ECONNREFUSED` or `ENETUNREACH`), then
> - * `MG_EV_CONNECT` event will report failure. Code example below:
> - *
> - * ```c
> - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
> - *   int connect_status;
> - *
> - *   switch (ev) {
> - *     case MG_EV_CONNECT:
> - *       connect_status = * (int *) ev_data;
> - *       if (connect_status == 0) {
> - *         // Success
> - *       } else  {
> - *         // Error
> - *         printf("connect() error: %s\n", strerror(connect_status));
> - *       }
> - *       break;
> - *     ...
> - *   }
> - * }
> - *
> - *   ...
> - *   mg_connect(mgr, "my_site.com:80", ev_handler);
> - * ```
> - */
> -struct mg_connection *mg_connect_opt(struct mg_mgr *mgr, const char *address,
> -                                     MG_CB(mg_event_handler_t handler,
> -                                           void *user_data),
> -                                     struct mg_connect_opts opts);
> -
> -#if MG_ENABLE_SSL && MG_NET_IF != MG_NET_IF_SIMPLELINK
> -/*
> - * Note: This function is deprecated. Please, use SSL options in
> - * mg_connect_opt.
> - *
> - * Enables SSL for a given connection.
> - * `cert` is a server certificate file name for a listening connection
> - * or a client certificate file name for an outgoing connection.
> - * The certificate files must be in PEM format. The server certificate file
> - * must contain a certificate, concatenated with a private key, optionally
> - * concatenated with DH parameters.
> - * `ca_cert` is a CA certificate or NULL if peer verification is not
> - * required.
> - * Return: NULL on success or error message on error.
> - */
> -const char *mg_set_ssl(struct mg_connection *nc, const char *cert,
> -                       const char *ca_cert);
> -#endif
> -
> -/*
> - * Sends data to the connection.
> - *
> - * Note that sending functions do not actually push data to the socket.
> - * They just append data to the output buffer. MG_EV_SEND will be delivered when
> - * the data has actually been pushed out.
> - */
> -void mg_send(struct mg_connection *, const void *buf, int len);
> -
> -/* Enables format string warnings for mg_printf */
> -#if defined(__GNUC__)
> -__attribute__((format(printf, 2, 3)))
> +  time_t tv_sec;
> +  suseconds_t tv_usec;
> +};
>   #endif
> -/* don't separate from mg_printf declaration */
>   
> -/*
> - * Sends `printf`-style formatted data to the connection.
> - *
> - * See `mg_send` for more details on send semantics.
> - */
> -int mg_printf(struct mg_connection *, const char *fmt, ...);
> +#include <FreeRTOS.h>
> +#include <task.h>
>   
> -/* Same as `mg_printf()`, but takes `va_list ap` as an argument. */
> -int mg_vprintf(struct mg_connection *, const char *fmt, va_list ap);
> +#include <lwip/sockets.h>
>   
> -/*
> - * Creates a socket pair.
> - * `sock_type` can be either `SOCK_STREAM` or `SOCK_DGRAM`.
> - * Returns 0 on failure and 1 on success.
> - */
> -int mg_socketpair(sock_t[2], int sock_type);
> -
> -#if MG_ENABLE_SYNC_RESOLVER
> -/*
> - * Convert domain name into IP address.
> - *
> - * This is a utility function. If compilation flags have
> - * `-DMG_ENABLE_GETADDRINFO`, then `getaddrinfo()` call is used for name
> - * resolution. Otherwise, `gethostbyname()` is used.
> - *
> - * CAUTION: this function can block.
> - * Return 1 on success, 0 on failure.
> - */
> -int mg_resolve(const char *domain_name, char *ip_addr_buf, size_t buf_len);
> +#if LWIP_SOCKET != 1
> +// Sockets support disabled in LWIP by default
> +#error Set LWIP_SOCKET variable to 1 (in lwipopts.h)
>   #endif
>   
> -/*
> - * Verify given IP address against the ACL.
> - *
> - * `remote_ip` - an IPv4 address to check, in host byte order
> - * `acl` - a comma separated list of IP subnets: `x.x.x.x/x` or `x.x.x.x`.
> - * Each subnet is
> - * prepended by either a - or a + sign. A plus sign means allow, where a
> - * minus sign means deny. If a subnet mask is omitted, such as `-1.2.3.4`,
> - * it means that only that single IP address is denied.
> - * Subnet masks may vary from 0 to 32, inclusive. The default setting
> - * is to allow all access. On each request the full list is traversed,
> - * and the last match wins. Example:
> - *
> - * `-0.0.0.0/0,+192.168/16` - deny all accesses, only allow 192.168/16 subnet
> - *
> - * To learn more about subnet masks, see this
> - * link:https://en.wikipedia.org/wiki/Subnetwork[Wikipedia page on Subnetwork].
> - *
> - * Returns -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed.
> - */
> -int mg_check_ip_acl(const char *acl, uint32_t remote_ip);
> -
> -/*
> - * Schedules an MG_EV_TIMER event to be delivered at `timestamp` time.
> - * `timestamp` is UNIX time (the number of seconds since Epoch). It is
> - * `double` instead of `time_t` to allow for sub-second precision.
> - * Returns the old timer value.
> - *
> - * Example: set the connect timeout to 1.5 seconds:
> - *
> - * ```
> - *  c = mg_connect(&mgr, "cesanta.com", ev_handler);
> - *  mg_set_timer(c, mg_time() + 1.5);
> - *  ...
> - *
> - *  void ev_handler(struct mg_connection *c, int ev, void *ev_data) {
> - *  switch (ev) {
> - *    case MG_EV_CONNECT:
> - *      mg_set_timer(c, 0);  // Clear connect timer
> - *      break;
> - *    case MG_EV_TIMER:
> - *      log("Connect timeout");
> - *      c->flags |= MG_F_CLOSE_IMMEDIATELY;
> - *      break;
> - * ```
> - */
> -double mg_set_timer(struct mg_connection *c, double timestamp);
> -
> -/*
> - * A sub-second precision version of time().
> - */
> -double mg_time(void);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -
> -#endif /* CS_MONGOOSE_SRC_NET_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_uri.h"
> +#if LWIP_POSIX_SOCKETS_IO_NAMES != 0
> +// LWIP_POSIX_SOCKETS_IO_NAMES must be disabled in posix-compatible OS
> +// enviroment (freertos mimics to one) otherwise names like `read` and `write`
> +// conflict
> +#error LWIP_POSIX_SOCKETS_IO_NAMES must be set to 0 (in lwipopts.h) for FreeRTOS
>   #endif
>   
> -/*
> - * === URI
> - */
> -
> -#ifndef CS_MONGOOSE_SRC_URI_H_
> -#define CS_MONGOOSE_SRC_URI_H_
> +#define MG_INT64_FMT "%lld"
> +#define MG_DIRSEP '/'
>   
> -/* Amalgamated: #include "mg_net.h" */
> +// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib
> +static inline void *mg_calloc(int cnt, size_t size) {
> +  void *p = pvPortMalloc(cnt * size);
> +  if (p != NULL) memset(p, 0, size);
> +  return p;
> +}
> +#define calloc(a, b) mg_calloc((a), (b))
> +#define free(a) vPortFree(a)
> +#define malloc(a) pvPortMalloc(a)
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/*
> - * Parses an URI and fills string chunks with locations of the respective
> - * uri components within the input uri string. NULL pointers will be
> - * ignored.
> - *
> - * General syntax:
> - *
> - *     [scheme://[user_info@]]host[:port][/path][?query][#fragment]
> - *
> - * Example:
> - *
> - *     foo.com:80
> - *     tcp://foo.com:1234
> - *     http://foo.com:80/bar?baz=1
> - *     https://user:pw@foo.com:443/blah
> - *
> - * `path` will include the leading slash. `query` won't include the leading `?`.
> - * `host` can contain embedded colons if surrounded by square brackets in order
> - * to support IPv6 literal addresses.
> - *
> - *
> - * Returns 0 on success, -1 on error.
> - */
> -int mg_parse_uri(const struct mg_str uri, struct mg_str *scheme,
> -                 struct mg_str *user_info, struct mg_str *host,
> -                 unsigned int *port, struct mg_str *path, struct mg_str *query,
> -                 struct mg_str *fragment);
> -
> -/*
> - * Assemble URI from parts. Any of the inputs can be NULL or zero-length mg_str.
> - *
> - * If normalize_path is true, path is normalized by resolving relative refs.
> - *
> - * Result is a heap-allocated string (uri->p must be free()d after use).
> - *
> - * Returns 0 on success, -1 on error.
> - */
> -int mg_assemble_uri(const struct mg_str *scheme, const struct mg_str *user_info,
> -                    const struct mg_str *host, unsigned int port,
> -                    const struct mg_str *path, const struct mg_str *query,
> -                    const struct mg_str *fragment, int normalize_path,
> -                    struct mg_str *uri);
> -
> -int mg_normalize_uri_path(const struct mg_str *in, struct mg_str *out);
> +#define gmtime_r(a, b) gmtime(a)
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* CS_MONGOOSE_SRC_URI_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_util.h"
> -#endif
> +#endif  // MG_ARCH == MG_ARCH_FREERTOS_LWIP
>   
> -/*
> - * === Utility API
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_UTIL_H_
> -#define CS_MONGOOSE_SRC_UTIL_H_
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP
>   
> +#include <ctype.h>
> +#include <errno.h>
> +#include <limits.h>
> +#include <stdarg.h>
> +#include <stdbool.h>
> +#include <stddef.h>
>   #include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <time.h>
>   
> -/* Amalgamated: #include "mg_common.h" */
> -/* Amalgamated: #include "mg_net_if.h" */
> +#include <FreeRTOS.h>
> +#include <FreeRTOS_IP.h>
> +#include <FreeRTOS_Sockets.h>
> +#include <task.h>
> +
> +#define MG_INT64_FMT "%lld"
> +#define MG_DIRSEP '/'
> +
> +// Why FreeRTOS-TCP did not implement a clean BSD API, but its own thing
> +// with FreeRTOS_ prefix, is beyond me
> +#define IPPROTO_TCP FREERTOS_IPPROTO_TCP
> +#define IPPROTO_UDP FREERTOS_IPPROTO_UDP
> +#define AF_INET FREERTOS_AF_INET
> +#define SOCK_STREAM FREERTOS_SOCK_STREAM
> +#define SOCK_DGRAM FREERTOS_SOCK_DGRAM
> +#define SO_BROADCAST 0
> +#define SO_ERROR 0
> +#define SOL_SOCKET 0
> +#define SO_REUSEADDR 0
> +#define sockaddr_in freertos_sockaddr
> +#define sockaddr freertos_sockaddr
> +#define accept(a, b, c) FreeRTOS_accept((a), (b), (c))
> +#define connect(a, b, c) FreeRTOS_connect((a), (b), (c))
> +#define bind(a, b, c) FreeRTOS_bind((a), (b), (c))
> +#define listen(a, b) FreeRTOS_listen((a), (b))
> +#define socket(a, b, c) FreeRTOS_socket((a), (b), (c))
> +#define send(a, b, c, d) FreeRTOS_send((a), (b), (c), (d))
> +#define recv(a, b, c, d) FreeRTOS_recv((a), (b), (c), (d))
> +#define setsockopt(a, b, c, d, e) FreeRTOS_setsockopt((a), (b), (c), (d), (e))
> +#define sendto(a, b, c, d, e, f) FreeRTOS_sendto((a), (b), (c), (d), (e), (f))
> +#define recvfrom(a, b, c, d, e, f) \
> +  FreeRTOS_recvfrom((a), (b), (c), (d), (e), (f))
> +#define closesocket(x) FreeRTOS_closesocket(x)
> +#define gethostbyname(x) FreeRTOS_gethostbyname(x)
> +#define getsockname(a, b, c) (-1)
> +
> +// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib
> +static inline void *mg_calloc(int cnt, size_t size) {
> +  void *p = pvPortMalloc(cnt * size);
> +  if (p != NULL) memset(p, 0, size);
> +  return p;
> +}
> +#define calloc(a, b) mg_calloc((a), (b))
> +#define free(a) vPortFree(a)
> +#define malloc(a) pvPortMalloc(a)
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> +#define gmtime_r(a, b) gmtime(a)
>   
> -#ifndef MG_MAX_PATH
> -#ifdef PATH_MAX
> -#define MG_MAX_PATH PATH_MAX
> -#else
> -#define MG_MAX_PATH 256
> -#endif
> +#if !defined(__GNUC__)
> +// copied from GCC on ARM; for some reason useconds are signed
> +typedef long suseconds_t;
> +struct timeval {
> +  time_t tv_sec;
> +  suseconds_t tv_usec;
> +};
>   #endif
>   
> -/*
> - * Fetches substring from input string `s`, `end` into `v`.
> - * Skips initial delimiter characters. Records first non-delimiter character
> - * at the beginning of substring `v`. Then scans the rest of the string
> - * until a delimiter character or end-of-string is found.
> - * `delimiters` is a 0-terminated string containing delimiter characters.
> - * Either one of `delimiters` or `end_string` terminates the search.
> - * Returns an `s` pointer, advanced forward where parsing has stopped.
> - */
> -const char *mg_skip(const char *s, const char *end_string,
> -                    const char *delimiters, struct mg_str *v);
> -
> -/*
> - * Decodes base64-encoded string `s`, `len` into the destination `dst`.
> - * The destination has to have enough space to hold the decoded buffer.
> - * Decoding stops either when all strings have been decoded or invalid an
> - * character appeared.
> - * Destination is '\0'-terminated.
> - * Returns the number of decoded characters. On success, that should be equal
> - * to `len`. On error (invalid character) the return value is smaller then
> - * `len`.
> - */
> -int mg_base64_decode(const unsigned char *s, int len, char *dst);
> -
> -/*
> - * Base64-encode chunk of memory `src`, `src_len` into the destination `dst`.
> - * Destination has to have enough space to hold encoded buffer.
> - * Destination is '\0'-terminated.
> - */
> -void mg_base64_encode(const unsigned char *src, int src_len, char *dst);
> -
> -#if MG_ENABLE_FILESYSTEM
> -/*
> - * Performs a 64-bit `stat()` call against a given file.
> - *
> - * `path` should be UTF8 encoded.
> - *
> - * Return value is the same as for `stat()` syscall.
> - */
> -int mg_stat(const char *path, cs_stat_t *st);
> -
> -/*
> - * Opens the given file and returns a file stream.
> - *
> - * `path` and `mode` should be UTF8 encoded.
> - *
> - * Return value is the same as for the `fopen()` call.
> - */
> -FILE *mg_fopen(const char *path, const char *mode);
> -
> -/*
> - * Opens the given file and returns a file stream.
> - *
> - * `path` should be UTF8 encoded.
> - *
> - * Return value is the same as for the `open()` syscall.
> - */
> -int mg_open(const char *path, int flag, int mode);
> -
> -/*
> - * Reads data from the given file stream.
> - *
> - * Return value is a number of bytes readen.
> - */
> -size_t mg_fread(void *ptr, size_t size, size_t count, FILE *f);
> -
> -/*
> - * Writes data to the given file stream.
> - *
> - * Return value is a number of bytes wtitten.
> - */
> -size_t mg_fwrite(const void *ptr, size_t size, size_t count, FILE *f);
> -
> -#endif /* MG_ENABLE_FILESYSTEM */
> -
> -#if MG_ENABLE_THREADS
> -/*
> - * Starts a new detached thread.
> - * Arguments and semantics are the same as pthead's `pthread_create()`.
> - * `thread_func` is a thread function, `thread_func_param` is a parameter
> - * that is passed to the thread function.
> - */
> -void *mg_start_thread(void *(*thread_func)(void *), void *thread_func_param);
> +#ifndef EINPROGRESS
> +#define EINPROGRESS pdFREERTOS_ERRNO_EINPROGRESS
>   #endif
> -
> -void mg_set_close_on_exec(sock_t);
> -
> -#define MG_SOCK_STRINGIFY_IP 1
> -#define MG_SOCK_STRINGIFY_PORT 2
> -#define MG_SOCK_STRINGIFY_REMOTE 4
> -/*
> - * Converts a connection's local or remote address into string.
> - *
> - * The `flags` parameter is a bit mask that controls the behaviour,
> - * see `MG_SOCK_STRINGIFY_*` definitions.
> - *
> - * - MG_SOCK_STRINGIFY_IP - print IP address
> - * - MG_SOCK_STRINGIFY_PORT - print port number
> - * - MG_SOCK_STRINGIFY_REMOTE - print remote peer's IP/port, not local address
> - *
> - * If both port number and IP address are printed, they are separated by `:`.
> - * If compiled with `-DMG_ENABLE_IPV6`, IPv6 addresses are supported.
> - * Return length of the stringified address.
> - */
> -int mg_conn_addr_to_str(struct mg_connection *c, char *buf, size_t len,
> -                        int flags);
> -#if MG_NET_IF == MG_NET_IF_SOCKET
> -/* Legacy interface. */
> -void mg_sock_to_str(sock_t sock, char *buf, size_t len, int flags);
> +#ifndef EWOULDBLOCK
> +#define EWOULDBLOCK pdFREERTOS_ERRNO_EWOULDBLOCK
>   #endif
> -
> -/*
> - * Convert the socket's address into string.
> - *
> - * `flags` is MG_SOCK_STRINGIFY_IP and/or MG_SOCK_STRINGIFY_PORT.
> - */
> -int mg_sock_addr_to_str(const union socket_address *sa, char *buf, size_t len,
> -                        int flags);
> -
> -#if MG_ENABLE_HEXDUMP
> -/*
> - * Generates a human-readable hexdump of memory chunk.
> - *
> - * Takes a memory buffer `buf` of length `len` and creates a hex dump of that
> - * buffer in `dst`. The generated output is a-la hexdump(1).
> - * Returns the length of generated string, excluding terminating `\0`. If
> - * returned length is bigger than `dst_len`, the overflow bytes are discarded.
> - */
> -int mg_hexdump(const void *buf, int len, char *dst, int dst_len);
> -
> -/* Same as mg_hexdump, but with output going to file instead of a buffer. */
> -void mg_hexdumpf(FILE *fp, const void *buf, int len);
> -
> -/*
> - * Generates human-readable hexdump of the data sent or received by the
> - * connection. `path` is a file name where hexdump should be written.
> - * `num_bytes` is a number of bytes sent/received. `ev` is one of the `MG_*`
> - * events sent to an event handler. This function is supposed to be called from
> - * the event handler.
> - */
> -void mg_hexdump_connection(struct mg_connection *nc, const char *path,
> -                           const void *buf, int num_bytes, int ev);
> +#ifndef EAGAIN
> +#define EAGAIN pdFREERTOS_ERRNO_EAGAIN
>   #endif
> -
> -/*
> - * Returns true if target platform is big endian.
> - */
> -int mg_is_big_endian(void);
> -
> -/*
> - * Use with cs_base64_init/update/finish in order to write out base64 in chunks.
> - */
> -void mg_mbuf_append_base64_putc(char ch, void *user_data);
> -
> -/*
> - * Encode `len` bytes starting at `data` as base64 and append them to an mbuf.
> - */
> -void mg_mbuf_append_base64(struct mbuf *mbuf, const void *data, size_t len);
> -
> -/*
> - * Generate a Basic Auth header and appends it to buf.
> - * If pass is NULL, then user is expected to contain the credentials pair
> - * already encoded as `user:pass`.
> - */
> -void mg_basic_auth_header(const struct mg_str user, const struct mg_str pass,
> -                          struct mbuf *buf);
> -
> -/*
> - * URL-escape the specified string.
> - * All characters acept letters, numbers and characters listed in
> - * `safe` are escaped. If `hex_upper`is true, `A-F` are used for hex digits.
> - * Input need not be NUL-terminated, but the returned string is.
> - * Returned string is heap-allocated and must be free()'d.
> - */
> -#define MG_URL_ENCODE_F_SPACE_AS_PLUS (1 << 0)
> -#define MG_URL_ENCODE_F_UPPERCASE_HEX (1 << 1)
> -struct mg_str mg_url_encode_opt(const struct mg_str src,
> -                                const struct mg_str safe, unsigned int flags);
> -
> -/* Same as `mg_url_encode_opt(src, "._-$,;~()/", 0)`. */
> -struct mg_str mg_url_encode(const struct mg_str src);
> -
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* CS_MONGOOSE_SRC_UTIL_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http.h"
> +#ifndef EINTR
> +#define EINTR pdFREERTOS_ERRNO_EINTR
>   #endif
>   
> -/*
> - * === Common API reference
> - */
> +#endif  // MG_ARCH == MG_ARCH_FREERTOS_TCP
>   
> -#ifndef CS_MONGOOSE_SRC_HTTP_H_
> -#define CS_MONGOOSE_SRC_HTTP_H_
>   
> -#if MG_ENABLE_HTTP
> +#if MG_ARCH == MG_ARCH_UNIX
>   
> -/* Amalgamated: #include "common/mg_str.h" */
> -/* Amalgamated: #include "mg_net.h" */
> +#define _DARWIN_UNLIMITED_SELECT 1  // No limit on file descriptors
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> +#include <arpa/inet.h>
> +#include <ctype.h>
> +#include <dirent.h>
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <inttypes.h>
> +#include <limits.h>
> +#include <netdb.h>
> +#include <netinet/tcp.h>
> +#include <signal.h>
> +#include <stdarg.h>
> +#include <stdbool.h>
> +#include <stddef.h>
> +#include <stdint.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/select.h>
> +#include <sys/socket.h>
> +#include <sys/stat.h>
> +#include <sys/time.h>
> +#include <sys/types.h>
> +#include <time.h>
> +#include <unistd.h>
> +
> +#define MG_DIRSEP '/'
> +#define MG_INT64_FMT "%" PRId64
> +#undef MG_ENABLE_DIRLIST
> +#define MG_ENABLE_DIRLIST 1
>   
> -#ifndef MG_MAX_HTTP_HEADERS
> -#define MG_MAX_HTTP_HEADERS 20
>   #endif
>   
> -#ifndef MG_MAX_HTTP_REQUEST_SIZE
> -#define MG_MAX_HTTP_REQUEST_SIZE 1024
> +
> +#if MG_ARCH == MG_ARCH_WIN32
> +
> +#ifndef WIN32_LEAN_AND_MEAN
> +#define WIN32_LEAN_AND_MEAN
>   #endif
>   
> -#ifndef MG_MAX_HTTP_SEND_MBUF
> -#define MG_MAX_HTTP_SEND_MBUF 1024
> +#ifndef _CRT_SECURE_NO_WARNINGS
> +#define _CRT_SECURE_NO_WARNINGS
>   #endif
>   
> -#ifndef MG_CGI_ENVIRONMENT_SIZE
> -#define MG_CGI_ENVIRONMENT_SIZE 8192
> +#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
> +#define _WINSOCK_DEPRECATED_NO_WARNINGS
>   #endif
>   
> -/* HTTP message */
> -struct http_message {
> -  struct mg_str message; /* Whole message: request line + headers + body */
> -  struct mg_str body;    /* Message body. 0-length for requests with no body */
> -
> -  /* HTTP Request line (or HTTP response line) */
> -  struct mg_str method; /* "GET" */
> -  struct mg_str uri;    /* "/my_file.html" */
> -  struct mg_str proto;  /* "HTTP/1.1" -- for both request and response */
> -
> -  /* For responses, code and response status message are set */
> -  int resp_code;
> -  struct mg_str resp_status_msg;
> -
> -  /*
> -   * Query-string part of the URI. For example, for HTTP request
> -   *    GET /foo/bar?param1=val1&param2=val2
> -   *    |    uri    |     query_string     |
> -   *
> -   * Note that question mark character doesn't belong neither to the uri,
> -   * nor to the query_string
> -   */
> -  struct mg_str query_string;
> -
> -  /* Headers */
> -  struct mg_str header_names[MG_MAX_HTTP_HEADERS];
> -  struct mg_str header_values[MG_MAX_HTTP_HEADERS];
> -};
> +#include <ctype.h>
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <limits.h>
> +#include <stdarg.h>
> +#include <stddef.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +#include <time.h>
>   
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -/* WebSocket message */
> -struct websocket_message {
> -  unsigned char *data;
> -  size_t size;
> -  unsigned char flags;
> -};
> +#if defined(_MSC_VER) && _MSC_VER < 1700
> +#define __func__ ""
> +typedef __int64 int64_t;
> +typedef unsigned __int64 uint64_t;
> +typedef unsigned char uint8_t;
> +typedef char int8_t;
> +typedef unsigned short uint16_t;
> +typedef short int16_t;
> +typedef unsigned int uint32_t;
> +typedef int int32_t;
> +typedef enum { false = 0, true = 1 } bool;
> +#else
> +#include <stdbool.h>
> +#include <stdint.h>
> +#include <ws2tcpip.h>
>   #endif
>   
> -/* HTTP multipart part */
> -struct mg_http_multipart_part {
> -  const char *file_name;
> -  const char *var_name;
> -  struct mg_str data;
> -  int status; /* <0 on error */
> -  void *user_data;
> -  /*
> -   * User handler can indicate how much of the data was consumed
> -   * by setting this variable. By default, it is assumed that all
> -   * data has been consumed by the handler.
> -   * If not all data was consumed, user's handler will be invoked again later
> -   * with the remainder.
> -   */
> -  size_t num_data_consumed;
> -};
> +#include <winsock2.h>
>   
> -/* SSI call context */
> -struct mg_ssi_call_ctx {
> -  struct http_message *req; /* The request being processed. */
> -  struct mg_str file;       /* Filesystem path of the file being processed. */
> -  struct mg_str arg; /* The argument passed to the tag: <!-- call arg -->. */
> -};
> +// Protect from calls like std::snprintf in app code
> +// See https://github.com/cesanta/mongoose/issues/1047
> +#ifndef __cplusplus
> +#define snprintf _snprintf
> +#define vsnprintf _vsnprintf
> +#ifndef strdup  // For MSVC with _DEBUG, see #1359
> +#define strdup(x) _strdup(x)
> +#endif
> +#endif
>   
> -/* HTTP and websocket events. void *ev_data is described in a comment. */
> -#define MG_EV_HTTP_REQUEST 100 /* struct http_message * */
> -#define MG_EV_HTTP_REPLY 101   /* struct http_message * */
> -#define MG_EV_HTTP_CHUNK 102   /* struct http_message * */
> -#define MG_EV_SSI_CALL 105     /* char * */
> -#define MG_EV_SSI_CALL_CTX 106 /* struct mg_ssi_call_ctx * */
> -
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -#define MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* struct http_message * */
> -#define MG_EV_WEBSOCKET_HANDSHAKE_DONE 112    /* struct http_message * */
> -#define MG_EV_WEBSOCKET_FRAME 113             /* struct websocket_message * */
> -#define MG_EV_WEBSOCKET_CONTROL_FRAME 114     /* struct websocket_message * */
> +typedef unsigned suseconds_t;
> +typedef int socklen_t;
> +#define MG_DIRSEP '\\'
> +#ifndef PATH_MAX
> +#define PATH_MAX MAX_PATH
> +#endif
> +#ifndef EINPROGRESS
> +#define EINPROGRESS WSAEINPROGRESS
> +#endif
> +#ifndef EWOULDBLOCK
> +#define EWOULDBLOCK WSAEWOULDBLOCK
>   #endif
>   
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -#define MG_EV_HTTP_MULTIPART_REQUEST 121 /* struct http_message */
> -#define MG_EV_HTTP_PART_BEGIN 122        /* struct mg_http_multipart_part */
> -#define MG_EV_HTTP_PART_DATA 123         /* struct mg_http_multipart_part */
> -#define MG_EV_HTTP_PART_END 124          /* struct mg_http_multipart_part */
> -/* struct mg_http_multipart_part */
> -#define MG_EV_HTTP_MULTIPART_REQUEST_END 125
> +#ifndef va_copy
> +#ifdef __va_copy
> +#define va_copy __va_copy
> +#else
> +#define va_copy(x, y) (x) = (y)
> +#endif
> +#endif
> +#ifndef S_ISDIR
> +#define S_ISDIR(x) (((x) &_S_IFMT) == _S_IFDIR)
>   #endif
>   
> -#define MG_F_WEBSOCKET_NO_DEFRAG MG_F_PROTO_1
> -#define MG_F_DELETE_CHUNK MG_F_PROTO_2
> -
> -/*
> - * Attaches a built-in HTTP event handler to the given connection.
> - * The user-defined event handler will receive following extra events:
> - *
> - * - MG_EV_HTTP_REQUEST: HTTP request has arrived. Parsed HTTP request
> - *  is passed as
> - *   `struct http_message` through the handler's `void *ev_data` pointer.
> - * - MG_EV_HTTP_REPLY: The HTTP reply has arrived. The parsed HTTP reply is
> - *   passed as `struct http_message` through the handler's `void *ev_data`
> - *   pointer.
> - * - MG_EV_HTTP_CHUNK: The HTTP chunked-encoding chunk has arrived.
> - *   The parsed HTTP reply is passed as `struct http_message` through the
> - *   handler's `void *ev_data` pointer. `http_message::body` would contain
> - *   incomplete, reassembled HTTP body.
> - *   It will grow with every new chunk that arrives, and it can
> - *   potentially consume a lot of memory. An event handler may process
> - *   the body as chunks are coming, and signal Mongoose to delete processed
> - *   body by setting `MG_F_DELETE_CHUNK` in `mg_connection::flags`. When
> - *   the last zero chunk is received,
> - *   Mongoose sends `MG_EV_HTTP_REPLY` event with
> - *   full reassembled body (if handler did not signal to delete chunks) or
> - *   with empty body (if handler did signal to delete chunks).
> - * - MG_EV_WEBSOCKET_HANDSHAKE_REQUEST: server has received the WebSocket
> - *   handshake request. `ev_data` contains parsed HTTP request.
> - * - MG_EV_WEBSOCKET_HANDSHAKE_DONE: server has completed the WebSocket
> - *   handshake. `ev_data` is a `struct http_message` containing the
> - *   client's request (server mode) or server's response (client).
> - *   In client mode handler can examine `resp_code`, which should be 101.
> - * - MG_EV_WEBSOCKET_FRAME: new WebSocket frame has arrived. `ev_data` is
> - *   `struct websocket_message *`
> - *
> - * When compiled with MG_ENABLE_HTTP_STREAMING_MULTIPART, Mongoose parses
> - * multipart requests and splits them into separate events:
> - * - MG_EV_HTTP_MULTIPART_REQUEST: Start of the request.
> - *   This event is sent before body is parsed. After this, the user
> - *   should expect a sequence of PART_BEGIN/DATA/END requests.
> - *   This is also the last time when headers and other request fields are
> - *   accessible.
> - * - MG_EV_HTTP_PART_BEGIN: Start of a part of a multipart message.
> - *   Argument: mg_http_multipart_part with var_name and file_name set
> - *   (if present). No data is passed in this message.
> - * - MG_EV_HTTP_PART_DATA: new portion of data from the multipart message.
> - *   Argument: mg_http_multipart_part. var_name and file_name are preserved,
> - *   data is available in mg_http_multipart_part.data.
> - * - MG_EV_HTTP_PART_END: End of the current part. var_name, file_name are
> - *   the same, no data in the message. If status is 0, then the part is
> - *   properly terminated with a boundary, status < 0 means that connection
> - *   was terminated.
> - * - MG_EV_HTTP_MULTIPART_REQUEST_END: End of the multipart request.
> - *   Argument: mg_http_multipart_part, var_name and file_name are NULL,
> - *   status = 0 means request was properly closed, < 0 means connection
> - *   was terminated (note: in this case both PART_END and REQUEST_END are
> - *   delivered).
> - */
> -void mg_set_protocol_http_websocket(struct mg_connection *nc);
> -
> -#if MG_ENABLE_HTTP_WEBSOCKET
> -/*
> - * Send websocket handshake to the server.
> - *
> - * `nc` must be a valid connection, connected to a server. `uri` is an URI
> - * to fetch, extra_headers` is extra HTTP headers to send or `NULL`.
> - *
> - * This function is intended to be used by websocket client.
> - *
> - * Note that the Host header is mandatory in HTTP/1.1 and must be
> - * included in `extra_headers`. `mg_send_websocket_handshake2` offers
> - * a better API for that.
> - *
> - * Deprecated in favour of `mg_send_websocket_handshake2`
> - */
> -void mg_send_websocket_handshake(struct mg_connection *nc, const char *uri,
> -                                 const char *extra_headers);
> -
> -/*
> - * Send websocket handshake to the server.
> - *
> - * `nc` must be a valid connection, connected to a server. `uri` is an URI
> - * to fetch, `host` goes into the `Host` header, `protocol` goes into the
> - * `Sec-WebSocket-Proto` header (NULL to omit), extra_headers` is extra HTTP
> - * headers to send or `NULL`.
> - *
> - * This function is intended to be used by websocket client.
> - */
> -void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path,
> -                                  const char *host, const char *protocol,
> -                                  const char *extra_headers);
> -
> -/* Like mg_send_websocket_handshake2 but also passes basic auth header */
> -void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path,
> -                                  const char *host, const char *protocol,
> -                                  const char *extra_headers, const char *user,
> -                                  const char *pass);
> -
> -/* Same as mg_send_websocket_handshake3 but with strings not necessarily
> - * NUL-temrinated */
> -void mg_send_websocket_handshake3v(struct mg_connection *nc,
> -                                   const struct mg_str path,
> -                                   const struct mg_str host,
> -                                   const struct mg_str protocol,
> -                                   const struct mg_str extra_headers,
> -                                   const struct mg_str user,
> -                                   const struct mg_str pass);
> -
> -/*
> - * Helper function that creates an outbound WebSocket connection.
> - *
> - * `url` is a URL to connect to. It must be properly URL-encoded, e.g. have
> - * no spaces, etc. By default, `mg_connect_ws()` sends Connection and
> - * Host headers. `extra_headers` is an extra HTTP header to send, e.g.
> - * `"User-Agent: my-app\r\n"`.
> - * If `protocol` is not NULL, then a `Sec-WebSocket-Protocol` header is sent.
> - *
> - * Examples:
> - *
> - * ```c
> - *   nc1 = mg_connect_ws(mgr, ev_handler_1, "ws://echo.websocket.org", NULL,
> - *                       NULL);
> - *   nc2 = mg_connect_ws(mgr, ev_handler_1, "wss://echo.websocket.org", NULL,
> - *                       NULL);
> - *   nc3 = mg_connect_ws(mgr, ev_handler_1, "ws://api.cesanta.com",
> - *                       "clubby.cesanta.com", NULL);
> - * ```
> - */
> -struct mg_connection *mg_connect_ws(struct mg_mgr *mgr,
> -                                    MG_CB(mg_event_handler_t event_handler,
> -                                          void *user_data),
> -                                    const char *url, const char *protocol,
> -                                    const char *extra_headers);
> -
> -/*
> - * Helper function that creates an outbound WebSocket connection
> - *
> - * Mostly identical to `mg_connect_ws`, but allows to provide extra parameters
> - * (for example, SSL parameters)
> - */
> -struct mg_connection *mg_connect_ws_opt(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *url, const char *protocol,
> -    const char *extra_headers);
> -
> -/*
> - * Send WebSocket frame to the remote end.
> - *
> - * `op_and_flags` specifies the frame's type. It's one of:
> - *
> - * - WEBSOCKET_OP_CONTINUE
> - * - WEBSOCKET_OP_TEXT
> - * - WEBSOCKET_OP_BINARY
> - * - WEBSOCKET_OP_CLOSE
> - * - WEBSOCKET_OP_PING
> - * - WEBSOCKET_OP_PONG
> - *
> - * Orred with one of the flags:
> - *
> - * - WEBSOCKET_DONT_FIN: Don't set the FIN flag on the frame to be sent.
> - *
> - * `data` and `data_len` contain frame data.
> - */
> -void mg_send_websocket_frame(struct mg_connection *nc, int op_and_flags,
> -                             const void *data, size_t data_len);
> -
> -/*
> - * Like `mg_send_websocket_frame()`, but composes a single frame from multiple
> - * buffers.
> - */
> -void mg_send_websocket_framev(struct mg_connection *nc, int op_and_flags,
> -                              const struct mg_str *strings, int num_strings);
> -
> -/*
> - * Sends WebSocket frame to the remote end.
> - *
> - * Like `mg_send_websocket_frame()`, but allows to create formatted messages
> - * with `printf()`-like semantics.
> - */
> -void mg_printf_websocket_frame(struct mg_connection *nc, int op_and_flags,
> -                               const char *fmt, ...);
> -
> -/* Websocket opcodes, from http://tools.ietf.org/html/rfc6455 */
> -#define WEBSOCKET_OP_CONTINUE 0
> -#define WEBSOCKET_OP_TEXT 1
> -#define WEBSOCKET_OP_BINARY 2
> -#define WEBSOCKET_OP_CLOSE 8
> -#define WEBSOCKET_OP_PING 9
> -#define WEBSOCKET_OP_PONG 10
> +#define MG_INT64_FMT "%I64d"
>   
> -/*
> - * If set causes the FIN flag to not be set on outbound
> - * frames. This enables sending multiple fragments of a single
> - * logical message.
> - *
> - * The WebSocket protocol mandates that if the FIN flag of a data
> - * frame is not set, the next frame must be a WEBSOCKET_OP_CONTINUE.
> - * The last frame must have the FIN bit set.
> - *
> - * Note that mongoose will automatically defragment incoming messages,
> - * so this flag is used only on outbound messages.
> - */
> -#define WEBSOCKET_DONT_FIN 0x100
> -
> -#endif /* MG_ENABLE_HTTP_WEBSOCKET */
> -
> -/*
> - * Decodes a URL-encoded string.
> - *
> - * Source string is specified by (`src`, `src_len`), and destination is
> - * (`dst`, `dst_len`). If `is_form_url_encoded` is non-zero, then
> - * `+` character is decoded as a blank space character. This function
> - * guarantees to NUL-terminate the destination. If destination is too small,
> - * then the source string is partially decoded and `-1` is returned.
> - *Otherwise,
> - * a length of the decoded string is returned, not counting final NUL.
> - */
> -int mg_url_decode(const char *src, int src_len, char *dst, int dst_len,
> -                  int is_form_url_encoded);
> -
> -extern void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[],
> -                          const size_t *msg_lens, uint8_t *digest);
> -extern void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[],
> -                           const size_t *msg_lens, uint8_t *digest);
> -
> -/*
> - * Flags for `mg_http_is_authorized()`.
> - */
> -#define MG_AUTH_FLAG_IS_DIRECTORY (1 << 0)
> -#define MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE (1 << 1)
> -#define MG_AUTH_FLAG_ALLOW_MISSING_FILE (1 << 2)
> -
> -/*
> - * Checks whether an http request is authorized. `domain` is the authentication
> - * realm, `passwords_file` is a htdigest file (can be created e.g. with
> - * `htdigest` utility). If either `domain` or `passwords_file` is NULL, this
> - * function always returns 1; otherwise checks the authentication in the
> - * http request and returns 1 only if there is a match; 0 otherwise.
> - */
> -int mg_http_is_authorized(struct http_message *hm, struct mg_str path,
> -                          const char *domain, const char *passwords_file,
> -                          int flags);
> -
> -/*
> - * Sends 401 Unauthorized response.
> - */
> -void mg_http_send_digest_auth_request(struct mg_connection *c,
> -                                      const char *domain);
> +#undef MG_ENABLE_DIRLIST
> +#define MG_ENABLE_DIRLIST 1
>   
> -#ifdef __cplusplus
> +// https://lgtm.com/rules/2154840805/ -gmtime, localtime, ctime and asctime
> +static __inline struct tm *gmtime_r(time_t *t, struct tm *tm) {
> +  (void) tm;
> +  return gmtime(t);
>   }
> -#endif /* __cplusplus */
>   
> -#endif /* MG_ENABLE_HTTP */
> +static __inline struct tm *localtime_r(time_t *t, struct tm *tm) {
> +  (void) tm;
> +  return localtime(t);
> +}
>   
> -#endif /* CS_MONGOOSE_SRC_HTTP_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_server.h"
>   #endif
> -/*
> - * === Server API reference
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_HTTP_SERVER_H_
> -#define CS_MONGOOSE_SRC_HTTP_SERVER_H_
>   
> -#if MG_ENABLE_HTTP
> +#include <ctype.h>
> +#include <string.h>
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/*
> - * Parses a HTTP message.
> - *
> - * `is_req` should be set to 1 if parsing a request, 0 if reply.
> - *
> - * Returns the number of bytes parsed. If HTTP message is
> - * incomplete `0` is returned. On parse error, a negative number is returned.
> - */
> -int mg_parse_http(const char *s, int n, struct http_message *hm, int is_req);
> -
> -/*
> - * Searches and returns the header `name` in parsed HTTP message `hm`.
> - * If header is not found, NULL is returned. Example:
> - *
> - *     struct mg_str *host_hdr = mg_get_http_header(hm, "Host");
> - */
> -struct mg_str *mg_get_http_header(struct http_message *hm, const char *name);
> -
> -/*
> - * Parses the HTTP header `hdr`. Finds variable `var_name` and stores its value
> - * in the buffer `*buf`, `buf_size`. If the buffer size is not enough,
> - * allocates a buffer of required size and writes it to `*buf`, similar to
> - * asprintf(). The caller should always check whether the buffer was updated,
> - * and free it if so.
> - *
> - * This function is supposed to parse cookies, authentication headers, etc.
> - * Example (error handling omitted):
> - *
> - *     char user_buf[20];
> - *     char *user = user_buf;
> - *     struct mg_str *hdr = mg_get_http_header(hm, "Authorization");
> - *     mg_http_parse_header2(hdr, "username", &user, sizeof(user_buf));
> - *     // ... do something useful with user
> - *     if (user != user_buf) {
> - *       free(user);
> - *     }
> - *
> - * Returns the length of the variable's value. If variable is not found, 0 is
> - * returned.
> - */
> -int mg_http_parse_header2(struct mg_str *hdr, const char *var_name, char **buf,
> -                          size_t buf_size);
> -
> -/*
> - * DEPRECATED: use mg_http_parse_header2() instead.
> - *
> - * Same as mg_http_parse_header2(), but takes buffer as a `char *` (instead of
> - * `char **`), and thus it cannot allocate a new buffer if the provided one
> - * is not enough, and just returns 0 in that case.
> - */
> -int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf,
> -                         size_t buf_size)
> -#ifdef __GNUC__
> -    __attribute__((deprecated))
> -#endif
> -    ;
> -
> -/*
> - * Gets and parses the Authorization: Basic header
> - * Returns -1 if no Authorization header is found, or if
> - * mg_parse_http_basic_auth
> - * fails parsing the resulting header.
> - */
> -int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len,
> -                           char *pass, size_t pass_len);
> -
> -/*
> - * Parses the Authorization: Basic header
> - * Returns -1 iif the authorization type is not "Basic" or any other error such
> - * as incorrectly encoded base64 user password pair.
> - */
> -int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len,
> -                             char *pass, size_t pass_len);
> -
> -/*
> - * Parses the buffer `buf`, `buf_len` that contains multipart form data chunks.
> - * Stores the chunk name in a `var_name`, `var_name_len` buffer.
> - * If a chunk is an uploaded file, then `file_name`, `file_name_len` is
> - * filled with an uploaded file name. `chunk`, `chunk_len`
> - * points to the chunk data.
> - *
> - * Return: number of bytes to skip to the next chunk or 0 if there are
> - *         no more chunks.
> - *
> - * Usage example:
> - *
> - * ```c
> - *    static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
> - *      switch(ev) {
> - *        case MG_EV_HTTP_REQUEST: {
> - *          struct http_message *hm = (struct http_message *) ev_data;
> - *          char var_name[100], file_name[100];
> - *          const char *chunk;
> - *          size_t chunk_len, n1, n2;
> - *
> - *          n1 = n2 = 0;
> - *          while ((n2 = mg_parse_multipart(hm->body.p + n1,
> - *                                          hm->body.len - n1,
> - *                                          var_name, sizeof(var_name),
> - *                                          file_name, sizeof(file_name),
> - *                                          &chunk, &chunk_len)) > 0) {
> - *            printf("var: %s, file_name: %s, size: %d, chunk: [%.*s]\n",
> - *                   var_name, file_name, (int) chunk_len,
> - *                   (int) chunk_len, chunk);
> - *            n1 += n2;
> - *          }
> - *        }
> - *        break;
> - * ```
> - */
> -size_t mg_parse_multipart(const char *buf, size_t buf_len, char *var_name,
> -                          size_t var_name_len, char *file_name,
> -                          size_t file_name_len, const char **chunk,
> -                          size_t *chunk_len);
> -
> -/*
> - * Fetches a HTTP form variable.
> - *
> - * Fetches a variable `name` from a `buf` into a buffer specified by `dst`,
> - * `dst_len`. The destination is always zero-terminated. Returns the length of
> - * a fetched variable. If not found, 0 is returned. `buf` must be valid
> - * url-encoded buffer. If destination is too small or an error occured,
> - * negative number is returned.
> - */
> -int mg_get_http_var(const struct mg_str *buf, const char *name, char *dst,
> -                    size_t dst_len);
> -
> -#if MG_ENABLE_FILESYSTEM
> -/*
> - * This structure defines how `mg_serve_http()` works.
> - * Best practice is to set only required settings, and leave the rest as NULL.
> - */
> -struct mg_serve_http_opts {
> -  /* Path to web root directory */
> -  const char *document_root;
> -
> -  /* List of index files. Default is "" */
> -  const char *index_files;
> -
> -  /*
> -   * Leave as NULL to disable authentication.
> -   * To enable directory protection with authentication, set this to ".htpasswd"
> -   * Then, creating ".htpasswd" file in any directory automatically protects
> -   * it with digest authentication.
> -   * Use `mongoose` web server binary, or `htdigest` Apache utility to
> -   * create/manipulate passwords file.
> -   * Make sure `auth_domain` is set to a valid domain name.
> -   */
> -  const char *per_directory_auth_file;
> -
> -  /* Authorization domain (domain name of this web server) */
> -  const char *auth_domain;
> -
> -  /*
> -   * Leave as NULL to disable authentication.
> -   * Normally, only selected directories in the document root are protected.
> -   * If absolutely every access to the web server needs to be authenticated,
> -   * regardless of the URI, set this option to the path to the passwords file.
> -   * Format of that file is the same as ".htpasswd" file. Make sure that file
> -   * is located outside document root to prevent people fetching it.
> -   */
> -  const char *global_auth_file;
> -
> -  /* Set to "no" to disable directory listing. Enabled by default. */
> -  const char *enable_directory_listing;
> -
> -  /*
> -   * SSI files pattern. If not set, "**.shtml$|**.shtm$" is used.
> -   *
> -   * All files that match ssi_pattern are treated as SSI.
> -   *
> -   * Server Side Includes (SSI) is a simple interpreted server-side scripting
> -   * language which is most commonly used to include the contents of a file
> -   * into a web page. It can be useful when it is desirable to include a common
> -   * piece of code throughout a website, for example, headers and footers.
> -   *
> -   * In order for a webpage to recognize an SSI-enabled HTML file, the
> -   * filename should end with a special extension, by default the extension
> -   * should be either .shtml or .shtm
> -   *
> -   * Unknown SSI directives are silently ignored by Mongoose. Currently,
> -   * the following SSI directives are supported:
> -   *    &lt;!--#include FILE_TO_INCLUDE --&gt;
> -   *    &lt;!--#exec "COMMAND_TO_EXECUTE" --&gt;
> -   *    &lt;!--#call COMMAND --&gt;
> -   *
> -   * Note that &lt;!--#include ...> directive supports three path
> -   *specifications:
> -   *
> -   * &lt;!--#include virtual="path" --&gt;  Path is relative to web server root
> -   * &lt;!--#include abspath="path" --&gt;  Path is absolute or relative to the
> -   *                                  web server working dir
> -   * &lt;!--#include file="path" --&gt;,    Path is relative to current document
> -   * &lt;!--#include "path" --&gt;
> -   *
> -   * The include directive may be used to include the contents of a file or
> -   * the result of running a CGI script.
> -   *
> -   * The exec directive is used to execute
> -   * a command on a server, and show command's output. Example:
> -   *
> -   * &lt;!--#exec "ls -l" --&gt;
> -   *
> -   * The call directive is a way to invoke a C handler from the HTML page.
> -   * On each occurence of &lt;!--#call COMMAND OPTIONAL_PARAMS> directive,
> -   * Mongoose calls a registered event handler with MG_EV_SSI_CALL event,
> -   * and event parameter will point to the COMMAND OPTIONAL_PARAMS string.
> -   * An event handler can output any text, for example by calling
> -   * `mg_printf()`. This is a flexible way of generating a web page on
> -   * server side by calling a C event handler. Example:
> -   *
> -   * &lt;!--#call foo --&gt; ... &lt;!--#call bar --&gt;
> -   *
> -   * In the event handler:
> -   *    case MG_EV_SSI_CALL: {
> -   *      const char *param = (const char *) ev_data;
> -   *      if (strcmp(param, "foo") == 0) {
> -   *        mg_printf(c, "hello from foo");
> -   *      } else if (strcmp(param, "bar") == 0) {
> -   *        mg_printf(c, "hello from bar");
> -   *      }
> -   *      break;
> -   *    }
> -   */
> -  const char *ssi_pattern;
> -
> -  /* IP ACL. By default, NULL, meaning all IPs are allowed to connect */
> -  const char *ip_acl;
> -
> -#if MG_ENABLE_HTTP_URL_REWRITES
> -  /* URL rewrites.
> -   *
> -   * Comma-separated list of `uri_pattern=url_file_or_directory_path` rewrites.
> -   * When HTTP request is received, Mongoose constructs a file name from the
> -   * requested URI by combining `document_root` and the URI. However, if the
> -   * rewrite option is used and `uri_pattern` matches requested URI, then
> -   * `document_root` is ignored. Instead, `url_file_or_directory_path` is used,
> -   * which should be a full path name or a path relative to the web server's
> -   * current working directory. It can also be an URI (http:// or https://)
> -   * in which case mongoose will behave as a reverse proxy for that destination.
> -   *
> -   * Note that `uri_pattern`, as all Mongoose patterns, is a prefix pattern.
> -   *
> -   * If uri_pattern starts with `@` symbol, then Mongoose compares it with the
> -   * HOST header of the request. If they are equal, Mongoose sets document root
> -   * to `file_or_directory_path`, implementing virtual hosts support.
> -   * Example: `@foo.com=/document/root/for/foo.com`
> -   *
> -   * If `uri_pattern` starts with `%` symbol, then Mongoose compares it with
> -   * the listening port. If they match, then Mongoose issues a 301 redirect.
> -   * For example, to redirect all HTTP requests to the
> -   * HTTPS port, do `%80=https://my.site.com`. Note that the request URI is
> -   * automatically appended to the redirect location.
> -   */
> -  const char *url_rewrites;
> -#endif
> +struct mg_str {
> +  const char *ptr;  // Pointer to string data
> +  size_t len;       // String len
> +};
> +
> +#define MG_NULL_STR \
> +  { NULL, 0 }
> +
> +// Using macro to avoid shadowing C++ struct constructor, see #1298
> +#define mg_str(s) mg_str_s(s)
>   
> -  /* DAV document root. If NULL, DAV requests are going to fail. */
> -  const char *dav_document_root;
> +struct mg_str mg_str(const char *s);
> +struct mg_str mg_str_n(const char *s, size_t n);
> +int mg_lower(const char *s);
> +int mg_ncasecmp(const char *s1, const char *s2, size_t len);
> +int mg_casecmp(const char *s1, const char *s2);
> +int mg_vcmp(const struct mg_str *s1, const char *s2);
> +int mg_vcasecmp(const struct mg_str *str1, const char *str2);
> +int mg_strcmp(const struct mg_str str1, const struct mg_str str2);
> +struct mg_str mg_strstrip(struct mg_str s);
> +struct mg_str mg_strdup(const struct mg_str s);
> +const char *mg_strstr(const struct mg_str haystack, const struct mg_str needle);
>   
> -  /*
> -   * DAV passwords file. If NULL, DAV requests are going to fail.
> -   * If passwords file is set to "-", then DAV auth is disabled.
> -   */
> -  const char *dav_auth_file;
>   
> -  /* Glob pattern for the files to hide. */
> -  const char *hidden_file_pattern;
>   
> -  /* Set to non-NULL to enable CGI, e.g. **.cgi$|**.php$" */
> -  const char *cgi_file_pattern;
>   
> -  /* If not NULL, ignore CGI script hashbang and use this interpreter */
> -  const char *cgi_interpreter;
>   
> -  /*
> -   * Comma-separated list of Content-Type overrides for path suffixes, e.g.
> -   * ".txt=text/plain; charset=utf-8,.c=text/plain"
> -   */
> -  const char *custom_mime_types;
> +#if MG_ENABLE_LOG
> +#define LOG(level, args)                                                   \
> +  do {                                                                     \
> +    if (mg_log_prefix((level), __FILE__, __LINE__, __func__)) mg_log args; \
> +  } while (0)
> +enum { LL_NONE, LL_ERROR, LL_INFO, LL_DEBUG, LL_VERBOSE_DEBUG };
> +bool mg_log_prefix(int ll, const char *file, int line, const char *fname);
> +void mg_log(const char *fmt, ...) PRINTF_LIKE(1, 2);
> +void mg_log_set(const char *spec);
> +void mg_log_set_callback(void (*fn)(const void *, size_t, void *), void *param);
> +#else
> +#define LOG(level, args) (void) 0
> +#define mg_log_set(x) (void) (x)
> +#endif
>   
> -  /*
> -   * Extra HTTP headers to add to each server response.
> -   * Example: to enable CORS, set this to "Access-Control-Allow-Origin: *".
> -   */
> -  const char *extra_headers;
> -};
>   
> -/*
> - * Serves given HTTP request according to the `options`.
> - *
> - * Example code snippet:
> - *
> - * ```c
> - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
> - *   struct http_message *hm = (struct http_message *) ev_data;
> - *   struct mg_serve_http_opts opts = { .document_root = "/var/www" };  // C99
> - *
> - *   switch (ev) {
> - *     case MG_EV_HTTP_REQUEST:
> - *       mg_serve_http(nc, hm, opts);
> - *       break;
> - *     default:
> - *       break;
> - *   }
> - * }
> - * ```
> - */
> -void mg_serve_http(struct mg_connection *nc, struct http_message *hm,
> -                   struct mg_serve_http_opts opts);
> -
> -/*
> - * Serves a specific file with a given MIME type and optional extra headers.
> - *
> - * Example code snippet:
> - *
> - * ```c
> - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
> - *   switch (ev) {
> - *     case MG_EV_HTTP_REQUEST: {
> - *       struct http_message *hm = (struct http_message *) ev_data;
> - *       mg_http_serve_file(nc, hm, "file.txt",
> - *                          mg_mk_str("text/plain"), mg_mk_str(""));
> - *       break;
> - *     }
> - *     ...
> - *   }
> - * }
> - * ```
> - */
> -void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm,
> -                        const char *path, const struct mg_str mime_type,
> -                        const struct mg_str extra_headers);
> -
> -#if MG_ENABLE_HTTP_STREAMING_MULTIPART
> -
> -/* Callback prototype for `mg_file_upload_handler()`. */
> -typedef struct mg_str (*mg_fu_fname_fn)(struct mg_connection *nc,
> -                                        struct mg_str fname);
> -
> -/*
> - * File upload handler.
> - * This handler can be used to implement file uploads with minimum code.
> - * This handler will process MG_EV_HTTP_PART_* events and store file data into
> - * a local file.
> - * `local_name_fn` will be invoked with whatever name was provided by the client
> - * and will expect the name of the local file to open. A return value of NULL
> - * will abort file upload (client will get a "403 Forbidden" response). If
> - * non-null, the returned string must be heap-allocated and will be freed by
> - * the caller.
> - * Exception: it is ok to return the same string verbatim.
> - *
> - * Example:
> - *
> - * ```c
> - * struct mg_str upload_fname(struct mg_connection *nc, struct mg_str fname) {
> - *   // Just return the same filename. Do not actually do this except in test!
> - *   // fname is user-controlled and needs to be sanitized.
> - *   return fname;
> - * }
> - * void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
> - *   switch (ev) {
> - *     ...
> - *     case MG_EV_HTTP_PART_BEGIN:
> - *     case MG_EV_HTTP_PART_DATA:
> - *     case MG_EV_HTTP_PART_END:
> - *       mg_file_upload_handler(nc, ev, ev_data, upload_fname);
> - *       break;
> - *   }
> - * }
> - * ```
> - */
> -void mg_file_upload_handler(struct mg_connection *nc, int ev, void *ev_data,
> -                            mg_fu_fname_fn local_name_fn
> -                                MG_UD_ARG(void *user_data));
> -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */
> -#endif /* MG_ENABLE_FILESYSTEM */
> -
> -/*
> - * Registers a callback for a specified http endpoint
> - * Note: if callback is registered it is called instead of the
> - * callback provided in mg_bind
> - *
> - * Example code snippet:
> - *
> - * ```c
> - * static void handle_hello1(struct mg_connection *nc, int ev, void *ev_data) {
> - *   (void) ev; (void) ev_data;
> - *   mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello1]");
> - *  nc->flags |= MG_F_SEND_AND_CLOSE;
> - * }
> - *
> - * static void handle_hello2(struct mg_connection *nc, int ev, void *ev_data) {
> - *  (void) ev; (void) ev_data;
> - *   mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello2]");
> - *  nc->flags |= MG_F_SEND_AND_CLOSE;
> - * }
> - *
> - * void init() {
> - *   nc = mg_bind(&mgr, local_addr, cb1);
> - *   mg_register_http_endpoint(nc, "/hello1", handle_hello1);
> - *   mg_register_http_endpoint(nc, "/hello1/hello2", handle_hello2);
> - * }
> - * ```
> - */
> -void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path,
> -                               MG_CB(mg_event_handler_t handler,
> -                                     void *user_data));
> -
> -struct mg_http_endpoint_opts {
> -  void *user_data;
> -  /* Authorization domain (realm) */
> -  const char *auth_domain;
> -  const char *auth_file;
> +struct mg_timer {
> +  unsigned long period_ms;  // Timer period in milliseconds
> +  unsigned flags;           // Possible flags values below
> +  void (*fn)(void *);       // Function to call
> +  void *arg;                // Function argument
> +  unsigned long expire;     // Expiration timestamp in milliseconds
> +  struct mg_timer *next;    // Linkage in g_timers list
>   };
>   
> -void mg_register_http_endpoint_opt(struct mg_connection *nc,
> -                                   const char *uri_path,
> -                                   mg_event_handler_t handler,
> -                                   struct mg_http_endpoint_opts opts);
> -
> -/*
> - * Authenticates a HTTP request against an opened password file.
> - * Returns 1 if authenticated, 0 otherwise.
> - */
> -int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain,
> -                              FILE *fp);
> -
> -/*
> - * Authenticates given response params against an opened password file.
> - * Returns 1 if authenticated, 0 otherwise.
> - *
> - * It's used by mg_http_check_digest_auth().
> - */
> -int mg_check_digest_auth(struct mg_str method, struct mg_str uri,
> -                         struct mg_str username, struct mg_str cnonce,
> -                         struct mg_str response, struct mg_str qop,
> -                         struct mg_str nc, struct mg_str nonce,
> -                         struct mg_str auth_domain, FILE *fp);
> -
> -/*
> - * Sends buffer `buf` of size `len` to the client using chunked HTTP encoding.
> - * This function sends the buffer size as hex number + newline first, then
> - * the buffer itself, then the newline. For example,
> - * `mg_send_http_chunk(nc, "foo", 3)` will append the `3\r\nfoo\r\n` string
> - * to the `nc->send_mbuf` output IO buffer.
> - *
> - * NOTE: The HTTP header "Transfer-Encoding: chunked" should be sent prior to
> - * using this function.
> - *
> - * NOTE: do not forget to send an empty chunk at the end of the response,
> - * to tell the client that everything was sent. Example:
> - *
> - * ```
> - *   mg_printf_http_chunk(nc, "%s", "my response!");
> - *   mg_send_http_chunk(nc, "", 0); // Tell the client we're finished
> - * ```
> - */
> -void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len);
> -
> -/*
> - * Sends a printf-formatted HTTP chunk.
> - * Functionality is similar to `mg_send_http_chunk()`.
> - */
> -void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...);
> -
> -/*
> - * Sends the response status line.
> - * If `extra_headers` is not NULL, then `extra_headers` are also sent
> - * after the response line. `extra_headers` must NOT end end with new line.
> - * Example:
> - *
> - *      mg_send_response_line(nc, 200, "Access-Control-Allow-Origin: *");
> - *
> - * Will result in:
> - *
> - *      HTTP/1.1 200 OK\r\n
> - *      Access-Control-Allow-Origin: *\r\n
> - */
> -void mg_send_response_line(struct mg_connection *nc, int status_code,
> -                           const char *extra_headers);
> -
> -/*
> - * Sends an error response. If reason is NULL, the message will be inferred
> - * from the error code (if supported).
> - */
> -void mg_http_send_error(struct mg_connection *nc, int code, const char *reason);
> -
> -/*
> - * Sends a redirect response.
> - * `status_code` should be either 301 or 302 and `location` point to the
> - * new location.
> - * If `extra_headers` is not empty, then `extra_headers` are also sent
> - * after the response line. `extra_headers` must NOT end end with new line.
> - *
> - * Example:
> - *
> - *      mg_http_send_redirect(nc, 302, mg_mk_str("/login"), mg_mk_str(NULL));
> - */
> -void mg_http_send_redirect(struct mg_connection *nc, int status_code,
> -                           const struct mg_str location,
> -                           const struct mg_str extra_headers);
> -
> -/*
> - * Sends the response line and headers.
> - * This function sends the response line with the `status_code`, and
> - * automatically
> - * sends one header: either "Content-Length" or "Transfer-Encoding".
> - * If `content_length` is negative, then "Transfer-Encoding: chunked" header
> - * is sent, otherwise, "Content-Length" header is sent.
> - *
> - * NOTE: If `Transfer-Encoding` is `chunked`, then message body must be sent
> - * using `mg_send_http_chunk()` or `mg_printf_http_chunk()` functions.
> - * Otherwise, `mg_send()` or `mg_printf()` must be used.
> - * Extra headers could be set through `extra_headers`. Note `extra_headers`
> - * must NOT be terminated by a new line.
> - */
> -void mg_send_head(struct mg_connection *n, int status_code,
> -                  int64_t content_length, const char *extra_headers);
> -
> -/*
> - * Sends a printf-formatted HTTP chunk, escaping HTML tags.
> - */
> -void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...);
> -
> -#if MG_ENABLE_HTTP_URL_REWRITES
> -/*
> - * Proxies a given request to a given upstream http server. The path prefix
> - * in `mount` will be stripped of the path requested to the upstream server,
> - * e.g. if mount is /api and upstream is http://localhost:8001/foo
> - * then an incoming request to /api/bar will cause a request to
> - * http://localhost:8001/foo/bar
> - *
> - * EXPERIMENTAL API. Please use http_serve_http + url_rewrites if a static
> - * mapping is good enough.
> - */
> -void mg_http_reverse_proxy(struct mg_connection *nc,
> -                           const struct http_message *hm, struct mg_str mount,
> -                           struct mg_str upstream);
> -#endif
> +#define MG_TIMER_REPEAT 1   // Call function periodically, otherwise run once
> +#define MG_TIMER_RUN_NOW 2  // Call immediately when timer is set
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> +extern struct mg_timer *g_timers;  // Global list of timers
>   
> -#endif /* MG_ENABLE_HTTP */
> +void mg_timer_init(struct mg_timer *, unsigned long ms, unsigned,
> +                   void (*fn)(void *), void *);
> +void mg_timer_free(struct mg_timer *);
> +void mg_timer_poll(unsigned long uptime_ms);
>   
> -#endif /* CS_MONGOOSE_SRC_HTTP_SERVER_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_http_client.h"
> -#endif
> -/*
> - * === Client API reference
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_HTTP_CLIENT_H_
> -#define CS_MONGOOSE_SRC_HTTP_CLIENT_H_
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/*
> - * Helper function that creates an outbound HTTP connection.
> - *
> - * `url` is the URL to fetch. It must be properly URL-encoded, e.g. have
> - * no spaces, etc. By default, `mg_connect_http()` sends the Connection and
> - * Host headers. `extra_headers` is an extra HTTP header to send, e.g.
> - * `"User-Agent: my-app\r\n"`.
> - * If `post_data` is NULL, then a GET request is created. Otherwise, a POST
> - * request is created with the specified POST data. Note that if the data being
> - * posted is a form submission, the `Content-Type` header should be set
> - * accordingly (see example below).
> - *
> - * Examples:
> - *
> - * ```c
> - *   nc1 = mg_connect_http(mgr, ev_handler_1, "http://www.google.com", NULL,
> - *                         NULL);
> - *   nc2 = mg_connect_http(mgr, ev_handler_1, "https://github.com", NULL, NULL);
> - *   nc3 = mg_connect_http(
> - *       mgr, ev_handler_1, "my_server:8000/form_submit/",
> - *       "Content-Type: application/x-www-form-urlencoded\r\n",
> - *       "var_1=value_1&var_2=value_2");
> - * ```
> - */
> -struct mg_connection *mg_connect_http(
> -    struct mg_mgr *mgr,
> -    MG_CB(mg_event_handler_t event_handler, void *user_data), const char *url,
> -    const char *extra_headers, const char *post_data);
> -
> -/*
> - * Helper function that creates an outbound HTTP connection.
> - *
> - * Mostly identical to mg_connect_http, but allows you to provide extra
> - *parameters
> - * (for example, SSL parameters)
> - */
> -struct mg_connection *mg_connect_http_opt(
> -    struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data),
> -    struct mg_connect_opts opts, const char *url, const char *extra_headers,
> -    const char *post_data);
> -
> -/* Creates digest authentication header for a client request. */
> -int mg_http_create_digest_auth_header(char *buf, size_t buf_len,
> -                                      const char *method, const char *uri,
> -                                      const char *auth_domain, const char *user,
> -                                      const char *passwd, const char *nonce);
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* CS_MONGOOSE_SRC_HTTP_CLIENT_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_mqtt.h"
> -#endif
>   
> -/*
> - * === MQTT API reference
> - */
> +char *mg_file_read(const char *path, size_t *size);
> +bool mg_file_write(const char *path, const void *buf, size_t len);
> +bool mg_file_printf(const char *path, const char *fmt, ...);
> +void mg_random(void *buf, size_t len);
> +bool mg_globmatch(const char *pattern, size_t plen, const char *s, size_t n);
> +bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v);
> +uint16_t mg_ntohs(uint16_t net);
> +uint32_t mg_ntohl(uint32_t net);
> +uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len);
> +char *mg_hexdump(const void *buf, size_t len);
> +char *mg_hex(const void *buf, size_t len, char *dst);
> +void mg_unhex(const char *buf, size_t len, unsigned char *to);
> +unsigned long mg_unhexn(const char *s, size_t len);
> +int mg_asprintf(char **buf, size_t size, const char *fmt, ...);
> +int mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap);
> +int64_t mg_to64(struct mg_str str);
> +int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip);
> +double mg_time(void);
> +unsigned long mg_millis(void);
> +void mg_usleep(unsigned long usecs);
>   
> -#ifndef CS_MONGOOSE_SRC_MQTT_H_
> -#define CS_MONGOOSE_SRC_MQTT_H_
> +#define mg_htons(x) mg_ntohs(x)
> +#define mg_htonl(x) mg_ntohl(x)
>   
> -/* Amalgamated: #include "mg_net.h" */
> +// Expands to a string representation of its argument: e.g.
> +// MG_STRINGIFY_LITERAL(5) expands to "5"
> +#if !defined(_MSC_VER) || _MSC_VER >= 1900
> +#define MG_STRINGIFY_LITERAL(...) #__VA_ARGS__
> +#else
> +#define MG_STRINGIFY_LITERAL(x) #x
> +#endif
> +// Expands to a string representation of its argument, which can be a macro:
> +// #define FOO 123
> +// MG_STRINGIFY_MACRO(FOO)  // Expands to 123
> +#define MG_STRINGIFY_MACRO(x) MG_STRINGIFY_LITERAL(x)
> +
> +// Linked list management macros
> +#define LIST_ADD_HEAD(type_, head_, elem_) \
> +  do {                                     \
> +    (elem_)->next = (*head_);              \
> +    *(head_) = (elem_);                    \
> +  } while (0)
> +
> +#define LIST_ADD_TAIL(type_, head_, elem_) \
> +  do {                                     \
> +    type_ **h = head_;                     \
> +    while (*h != NULL) h = &(*h)->next;    \
> +    *h = (elem_);                          \
> +  } while (0)
> +
> +#define LIST_DELETE(type_, head_, elem_)   \
> +  do {                                     \
> +    type_ **h = head_;                     \
> +    while (*h != (elem_)) h = &(*h)->next; \
> +    *h = (elem_)->next;                    \
> +  } while (0)
>   
> -struct mg_mqtt_message {
> -  int cmd;
> -  int qos;
> -  int len; /* message length in the IO buffer */
> -  struct mg_str topic;
> -  struct mg_str payload;
> -
> -  uint8_t connack_ret_code; /* connack */
> -  uint16_t message_id;      /* puback */
> -
> -  /* connect */
> -  uint8_t protocol_version;
> -  uint8_t connect_flags;
> -  uint16_t keep_alive_timer;
> -  struct mg_str protocol_name;
> -  struct mg_str client_id;
> -  struct mg_str will_topic;
> -  struct mg_str will_message;
> -  struct mg_str user_name;
> -  struct mg_str password;
> -};
>   
> -struct mg_mqtt_topic_expression {
> -  const char *topic;
> -  uint8_t qos;
> -};
>   
> -struct mg_send_mqtt_handshake_opts {
> -  unsigned char flags; /* connection flags */
> -  uint16_t keep_alive;
> -  const char *will_topic;
> -  const char *will_message;
> -  const char *user_name;
> -  const char *password;
> +
> +enum { MG_FS_READ = 1, MG_FS_WRITE = 2, MG_FS_DIR = 4 };
> +
> +// Filesystem API functions
> +// stat() returns MG_FS_* flags and populates file size and modification time
> +// list() calls fn() for every directory entry, allowing to list a directory
> +struct mg_fs {
> +  int (*stat)(const char *path, size_t *size, time_t *mtime);
> +  void (*list)(const char *path, void (*fn)(const char *, void *), void *);
> +  struct mg_fd *(*open)(const char *path, int flags);      // Open file
> +  void (*close)(struct mg_fd *fd);                         // Close file
> +  size_t (*read)(void *fd, void *buf, size_t len);         // Read file
> +  size_t (*write)(void *fd, const void *buf, size_t len);  // Write file
> +  size_t (*seek)(void *fd, size_t offset);                 // Set file position
>   };
>   
> -/* mg_mqtt_proto_data should be in header to allow external access to it */
> -struct mg_mqtt_proto_data {
> -  uint16_t keep_alive;
> -  double last_control_time;
> +// File descriptor
> +struct mg_fd {
> +  void *fd;
> +  struct mg_fs *fs;
>   };
>   
> -/* Message types */
> -#define MG_MQTT_CMD_CONNECT 1
> -#define MG_MQTT_CMD_CONNACK 2
> -#define MG_MQTT_CMD_PUBLISH 3
> -#define MG_MQTT_CMD_PUBACK 4
> -#define MG_MQTT_CMD_PUBREC 5
> -#define MG_MQTT_CMD_PUBREL 6
> -#define MG_MQTT_CMD_PUBCOMP 7
> -#define MG_MQTT_CMD_SUBSCRIBE 8
> -#define MG_MQTT_CMD_SUBACK 9
> -#define MG_MQTT_CMD_UNSUBSCRIBE 10
> -#define MG_MQTT_CMD_UNSUBACK 11
> -#define MG_MQTT_CMD_PINGREQ 12
> -#define MG_MQTT_CMD_PINGRESP 13
> -#define MG_MQTT_CMD_DISCONNECT 14
> -
> -/* MQTT event types */
> -#define MG_MQTT_EVENT_BASE 200
> -#define MG_EV_MQTT_CONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNECT)
> -#define MG_EV_MQTT_CONNACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNACK)
> -#define MG_EV_MQTT_PUBLISH (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBLISH)
> -#define MG_EV_MQTT_PUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBACK)
> -#define MG_EV_MQTT_PUBREC (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREC)
> -#define MG_EV_MQTT_PUBREL (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREL)
> -#define MG_EV_MQTT_PUBCOMP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBCOMP)
> -#define MG_EV_MQTT_SUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBSCRIBE)
> -#define MG_EV_MQTT_SUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBACK)
> -#define MG_EV_MQTT_UNSUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBSCRIBE)
> -#define MG_EV_MQTT_UNSUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBACK)
> -#define MG_EV_MQTT_PINGREQ (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGREQ)
> -#define MG_EV_MQTT_PINGRESP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGRESP)
> -#define MG_EV_MQTT_DISCONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_DISCONNECT)
> -
> -/* Message flags */
> -#define MG_MQTT_RETAIN 0x1
> -#define MG_MQTT_QOS(qos) ((qos) << 1)
> -#define MG_MQTT_GET_QOS(flags) (((flags) &0x6) >> 1)
> -#define MG_MQTT_SET_QOS(flags, qos) (flags) = ((flags) & ~0x6) | ((qos) << 1)
> -#define MG_MQTT_DUP 0x8
> -
> -/* Connection flags */
> -#define MG_MQTT_CLEAN_SESSION 0x02
> -#define MG_MQTT_HAS_WILL 0x04
> -#define MG_MQTT_WILL_RETAIN 0x20
> -#define MG_MQTT_HAS_PASSWORD 0x40
> -#define MG_MQTT_HAS_USER_NAME 0x80
> -#define MG_MQTT_GET_WILL_QOS(flags) (((flags) &0x18) >> 3)
> -#define MG_MQTT_SET_WILL_QOS(flags, qos) \
> -  (flags) = ((flags) & ~0x18) | ((qos) << 3)
> -
> -/* CONNACK return codes */
> -#define MG_EV_MQTT_CONNACK_ACCEPTED 0
> -#define MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION 1
> -#define MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED 2
> -#define MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE 3
> -#define MG_EV_MQTT_CONNACK_BAD_AUTH 4
> -#define MG_EV_MQTT_CONNACK_NOT_AUTHORIZED 5
> +extern struct mg_fs mg_fs_posix;   // POSIX open/close/read/write/seek
> +extern struct mg_fs mg_fs_packed;  // Packed FS, see examples/complete
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/*
> - * Attaches a built-in MQTT event handler to the given connection.
> - *
> - * The user-defined event handler will receive following extra events:
> - *
> - * - MG_EV_MQTT_CONNACK
> - * - MG_EV_MQTT_PUBLISH
> - * - MG_EV_MQTT_PUBACK
> - * - MG_EV_MQTT_PUBREC
> - * - MG_EV_MQTT_PUBREL
> - * - MG_EV_MQTT_PUBCOMP
> - * - MG_EV_MQTT_SUBACK
> - */
> -void mg_set_protocol_mqtt(struct mg_connection *nc);
> -
> -/* Sends an MQTT handshake. */
> -void mg_send_mqtt_handshake(struct mg_connection *nc, const char *client_id);
> -
> -/* Sends an MQTT handshake with optional parameters. */
> -void mg_send_mqtt_handshake_opt(struct mg_connection *nc, const char *client_id,
> -                                struct mg_send_mqtt_handshake_opts);
> -
> -/* Publishes a message to a given topic. */
> -void mg_mqtt_publish(struct mg_connection *nc, const char *topic,
> -                     uint16_t message_id, int flags, const void *data,
> -                     size_t len);
> -
> -/* Subscribes to a bunch of topics. */
> -void mg_mqtt_subscribe(struct mg_connection *nc,
> -                       const struct mg_mqtt_topic_expression *topics,
> -                       size_t topics_len, uint16_t message_id);
> -
> -/* Unsubscribes from a bunch of topics. */
> -void mg_mqtt_unsubscribe(struct mg_connection *nc, char **topics,
> -                         size_t topics_len, uint16_t message_id);
> -
> -/* Sends a DISCONNECT command. */
> -void mg_mqtt_disconnect(struct mg_connection *nc);
> -
> -/* Sends a CONNACK command with a given `return_code`. */
> -void mg_mqtt_connack(struct mg_connection *nc, uint8_t return_code);
> -
> -/* Sends a PUBACK command with a given `message_id`. */
> -void mg_mqtt_puback(struct mg_connection *nc, uint16_t message_id);
> -
> -/* Sends a PUBREC command with a given `message_id`. */
> -void mg_mqtt_pubrec(struct mg_connection *nc, uint16_t message_id);
> -
> -/* Sends a PUBREL command with a given `message_id`. */
> -void mg_mqtt_pubrel(struct mg_connection *nc, uint16_t message_id);
> -
> -/* Sends a PUBCOMP command with a given `message_id`. */
> -void mg_mqtt_pubcomp(struct mg_connection *nc, uint16_t message_id);
> -
> -/*
> - * Sends a SUBACK command with a given `message_id`
> - * and a sequence of granted QoSs.
> - */
> -void mg_mqtt_suback(struct mg_connection *nc, uint8_t *qoss, size_t qoss_len,
> -                    uint16_t message_id);
> -
> -/* Sends a UNSUBACK command with a given `message_id`. */
> -void mg_mqtt_unsuback(struct mg_connection *nc, uint16_t message_id);
> -
> -/* Sends a PINGREQ command. */
> -void mg_mqtt_ping(struct mg_connection *nc);
> -
> -/* Sends a PINGRESP command. */
> -void mg_mqtt_pong(struct mg_connection *nc);
> -
> -/*
> - * Extracts the next topic expression from a SUBSCRIBE command payload.
> - *
> - * The topic expression name will point to a string in the payload buffer.
> - * Returns the pos of the next topic expression or -1 when the list
> - * of topics is exhausted.
> - */
> -int mg_mqtt_next_subscribe_topic(struct mg_mqtt_message *msg,
> -                                 struct mg_str *topic, uint8_t *qos, int pos);
> -
> -/*
> - * Matches a topic against a topic expression
> - *
> - * Returns 1 if it matches; 0 otherwise.
> - */
> -int mg_mqtt_match_topic_expression(struct mg_str exp, struct mg_str topic);
> -
> -/*
> - * Same as `mg_mqtt_match_topic_expression()`, but takes `exp` as a
> - * NULL-terminated string.
> - */
> -int mg_mqtt_vmatch_topic_expression(const char *exp, struct mg_str topic);
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
>   
> -#endif /* CS_MONGOOSE_SRC_MQTT_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_mqtt_server.h"
> -#endif
> +unsigned short mg_url_port(const char *url);
> +int mg_url_is_ssl(const char *url);
> +struct mg_str mg_url_host(const char *url);
> +struct mg_str mg_url_user(const char *url);
> +struct mg_str mg_url_pass(const char *url);
> +const char *mg_url_uri(const char *url);
>   
> -/*
> - * === MQTT Server API reference
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_MQTT_BROKER_H_
> -#define CS_MONGOOSE_SRC_MQTT_BROKER_H_
> +#include <stddef.h>
>   
> -#if MG_ENABLE_MQTT_BROKER
> +struct mg_iobuf {
> +  unsigned char *buf;  // Pointer to stored data
> +  size_t size;         // Total size available
> +  size_t len;          // Current number of bytes
> +};
>   
> -/* Amalgamated: #include "common/queue.h" */
> -/* Amalgamated: #include "mg_mqtt.h" */
> +int mg_iobuf_init(struct mg_iobuf *, size_t);
> +int mg_iobuf_resize(struct mg_iobuf *, size_t);
> +void mg_iobuf_free(struct mg_iobuf *);
> +size_t mg_iobuf_add(struct mg_iobuf *, size_t, const void *, size_t, size_t);
> +size_t mg_iobuf_del(struct mg_iobuf *, size_t ofs, size_t len);
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> +int mg_base64_update(unsigned char p, char *to, int len);
> +int mg_base64_final(char *to, int len);
> +int mg_base64_encode(const unsigned char *p, int n, char *to);
> +int mg_base64_decode(const char *src, int n, char *dst);
>   
> -#ifndef MG_MQTT_MAX_SESSION_SUBSCRIPTIONS
> -#define MG_MQTT_MAX_SESSION_SUBSCRIPTIONS 512
> -#endif
>   
> -struct mg_mqtt_broker;
>   
> -/* MQTT session (Broker side). */
> -struct mg_mqtt_session {
> -  struct mg_mqtt_broker *brk;       /* Broker */
> -  LIST_ENTRY(mg_mqtt_session) link; /* mg_mqtt_broker::sessions linkage */
> -  struct mg_connection *nc;         /* Connection with the client */
> -  size_t num_subscriptions;         /* Size of `subscriptions` array */
> -  void *user_data;                  /* User data */
> -  struct mg_mqtt_topic_expression *subscriptions;
> -};
>   
> -/* MQTT broker. */
> -struct mg_mqtt_broker {
> -  LIST_HEAD(_mg_sesshead, mg_mqtt_session) sessions; /* Session list */
> -  void *user_data;                                   /* User data */
> -};
> +typedef struct {
> +  uint32_t buf[4];
> +  uint32_t bits[2];
> +  unsigned char in[64];
> +} mg_md5_ctx;
>   
> -/* Initialises a MQTT broker. */
> -void mg_mqtt_broker_init(struct mg_mqtt_broker *brk, void *user_data);
> -
> -/*
> - * Processes a MQTT broker message.
> - *
> - * The listening connection expects a pointer to an initialised
> - * `mg_mqtt_broker` structure in the `user_data` field.
> - *
> - * Basic usage:
> - *
> - * ```c
> - * mg_mqtt_broker_init(&brk, NULL);
> - *
> - * if ((nc = mg_bind(&mgr, address, mg_mqtt_broker)) == NULL) {
> - *   // fail;
> - * }
> - * nc->user_data = &brk;
> - * ```
> - *
> - * New incoming connections will receive a `mg_mqtt_session` structure
> - * in the connection `user_data`. The original `user_data` will be stored
> - * in the `user_data` field of the session structure. This allows the user
> - * handler to store user data before `mg_mqtt_broker` creates the session.
> - *
> - * Since only the MG_EV_ACCEPT message is processed by the listening socket,
> - * for most events the `user_data` will thus point to a `mg_mqtt_session`.
> - */
> -void mg_mqtt_broker(struct mg_connection *brk, int ev, void *data);
> -
> -/*
> - * Iterates over all MQTT session connections. Example:
> - *
> - * ```c
> - * struct mg_mqtt_session *s;
> - * for (s = mg_mqtt_next(brk, NULL); s != NULL; s = mg_mqtt_next(brk, s)) {
> - *   // Do something
> - * }
> - * ```
> - */
> -struct mg_mqtt_session *mg_mqtt_next(struct mg_mqtt_broker *brk,
> -                                     struct mg_mqtt_session *s);
> +void mg_md5_init(mg_md5_ctx *c);
> +void mg_md5_update(mg_md5_ctx *c, const unsigned char *data, size_t len);
> +void mg_md5_final(mg_md5_ctx *c, unsigned char[16]);
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
>   
> -#endif /* MG_ENABLE_MQTT_BROKER */
> -#endif /* CS_MONGOOSE_SRC_MQTT_BROKER_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_dns.h"
> -#endif
>   
> -/*
> - * === DNS API reference
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_DNS_H_
> -#define CS_MONGOOSE_SRC_DNS_H_
> +typedef struct {
> +  uint32_t state[5];
> +  uint32_t count[2];
> +  unsigned char buffer[64];
> +} mg_sha1_ctx;
>   
> -/* Amalgamated: #include "mg_net.h" */
> +void mg_sha1_init(mg_sha1_ctx *);
> +void mg_sha1_update(mg_sha1_ctx *, const unsigned char *data, size_t len);
> +void mg_sha1_final(unsigned char digest[20], mg_sha1_ctx *);
> +void mg_hmac_sha1(const unsigned char *key, size_t key_len,
> +                  const unsigned char *text, size_t text_len,
> +                  unsigned char out[20]);
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -#define MG_DNS_A_RECORD 0x01     /* Lookup IP address */
> -#define MG_DNS_CNAME_RECORD 0x05 /* Lookup CNAME */
> -#define MG_DNS_PTR_RECORD 0x0c   /* Lookup PTR */
> -#define MG_DNS_TXT_RECORD 0x10   /* Lookup TXT */
> -#define MG_DNS_AAAA_RECORD 0x1c  /* Lookup IPv6 address */
> -#define MG_DNS_SRV_RECORD 0x21   /* Lookup SRV */
> -#define MG_DNS_MX_RECORD 0x0f    /* Lookup mail server for domain */
> -#define MG_DNS_ANY_RECORD 0xff
> -#define MG_DNS_NSEC_RECORD 0x2f
> -
> -#define MG_MAX_DNS_QUESTIONS 32
> -#define MG_MAX_DNS_ANSWERS 32
> -
> -#define MG_DNS_MESSAGE 100 /* High-level DNS message event */
> -
> -enum mg_dns_resource_record_kind {
> -  MG_DNS_INVALID_RECORD = 0,
> -  MG_DNS_QUESTION,
> -  MG_DNS_ANSWER
> -};
>   
> -/* DNS resource record. */
> -struct mg_dns_resource_record {
> -  struct mg_str name; /* buffer with compressed name */
> -  int rtype;
> -  int rclass;
> -  int ttl;
> -  enum mg_dns_resource_record_kind kind;
> -  struct mg_str rdata; /* protocol data (can be a compressed name) */
> +struct mg_connection;
> +typedef void (*mg_event_handler_t)(struct mg_connection *, int ev,
> +                                   void *ev_data, void *fn_data);
> +void mg_call(struct mg_connection *c, int ev, void *ev_data);
> +void mg_error(struct mg_connection *c, const char *fmt, ...);
> +
> +enum {
> +  MG_EV_ERROR,       // Error                        char *error_message
> +  MG_EV_POLL,        // mg_mgr_poll iteration        unsigned long *millis
> +  MG_EV_RESOLVE,     // Host name is resolved        NULL
> +  MG_EV_CONNECT,     // Connection established       NULL
> +  MG_EV_ACCEPT,      // Connection accepted          NULL
> +  MG_EV_READ,        // Data received from socket    struct mg_str *
> +  MG_EV_WRITE,       // Data written to socket       long *bytes_written
> +  MG_EV_CLOSE,       // Connection closed            NULL
> +  MG_EV_HTTP_MSG,    // HTTP request/response        struct mg_http_message *
> +  MG_EV_HTTP_CHUNK,  // HTTP chunk (partial msg)     struct mg_http_message *
> +  MG_EV_WS_OPEN,     // Websocket handshake done     struct mg_http_message *
> +  MG_EV_WS_MSG,      // Websocket msg, text or bin   struct mg_ws_message *
> +  MG_EV_WS_CTL,      // Websocket control msg        struct mg_ws_message *
> +  MG_EV_MQTT_CMD,    // MQTT low-level command       struct mg_mqtt_message *
> +  MG_EV_MQTT_MSG,    // MQTT PUBLISH received        struct mg_mqtt_message *
> +  MG_EV_MQTT_OPEN,   // MQTT CONNACK received        int *connack_status_code
> +  MG_EV_SNTP_TIME,   // SNTP time received           struct timeval *
> +  MG_EV_USER,        // Starting ID for user events
>   };
>   
> -/* DNS message (request and response). */
> -struct mg_dns_message {
> -  struct mg_str pkt; /* packet body */
> -  uint16_t flags;
> -  uint16_t transaction_id;
> -  int num_questions;
> -  int num_answers;
> -  struct mg_dns_resource_record questions[MG_MAX_DNS_QUESTIONS];
> -  struct mg_dns_resource_record answers[MG_MAX_DNS_ANSWERS];
> -};
>   
> -struct mg_dns_resource_record *mg_dns_next_record(
> -    struct mg_dns_message *msg, int query, struct mg_dns_resource_record *prev);
> -
> -/*
> - * Parses the record data from a DNS resource record.
> - *
> - *  - A:     struct in_addr *ina
> - *  - AAAA:  struct in6_addr *ina
> - *  - CNAME: char buffer
> - *
> - * Returns -1 on error.
> - *
> - * TODO(mkm): MX
> - */
> -int mg_dns_parse_record_data(struct mg_dns_message *msg,
> -                             struct mg_dns_resource_record *rr, void *data,
> -                             size_t data_len);
> -
> -/*
> - * Sends a DNS query to the remote end.
> - */
> -void mg_send_dns_query(struct mg_connection *nc, const char *name,
> -                       int query_type);
> -
> -/*
> - * Inserts a DNS header to an IO buffer.
> - *
> - * Returns the number of bytes inserted.
> - */
> -int mg_dns_insert_header(struct mbuf *io, size_t pos,
> -                         struct mg_dns_message *msg);
> -
> -/*
> - * Appends already encoded questions from an existing message.
> - *
> - * This is useful when generating a DNS reply message which includes
> - * all question records.
> - *
> - * Returns the number of appended bytes.
> - */
> -int mg_dns_copy_questions(struct mbuf *io, struct mg_dns_message *msg);
> -
> -/*
> - * Encodes and appends a DNS resource record to an IO buffer.
> - *
> - * The record metadata is taken from the `rr` parameter, while the name and data
> - * are taken from the parameters, encoded in the appropriate format depending on
> - * record type and stored in the IO buffer. The encoded values might contain
> - * offsets within the IO buffer. It's thus important that the IO buffer doesn't
> - * get trimmed while a sequence of records are encoded while preparing a DNS
> - * reply.
> - *
> - * This function doesn't update the `name` and `rdata` pointers in the `rr`
> - * struct because they might be invalidated as soon as the IO buffer grows
> - * again.
> - *
> - * Returns the number of bytes appended or -1 in case of error.
> - */
> -int mg_dns_encode_record(struct mbuf *io, struct mg_dns_resource_record *rr,
> -                         const char *name, size_t nlen, const void *rdata,
> -                         size_t rlen);
> -
> -/*
> - * Encodes a DNS name.
> - */
> -int mg_dns_encode_name(struct mbuf *io, const char *name, size_t len);
> -int mg_dns_encode_name_s(struct mbuf *io, struct mg_str name);
> -
> -/* Low-level: parses a DNS response. */
> -int mg_parse_dns(const char *buf, int len, struct mg_dns_message *msg);
> -
> -/*
> - * Uncompresses a DNS compressed name.
> - *
> - * The containing DNS message is required because of the compressed encoding
> - * and reference suffixes present elsewhere in the packet.
> - *
> - * If the name is less than `dst_len` characters long, the remainder
> - * of `dst` is terminated with `\0` characters. Otherwise, `dst` is not
> - * terminated.
> - *
> - * If `dst_len` is 0 `dst` can be NULL.
> - * Returns the uncompressed name length.
> - */
> -size_t mg_dns_uncompress_name(struct mg_dns_message *msg, struct mg_str *name,
> -                              char *dst, int dst_len);
> -
> -/*
> - * Attaches a built-in DNS event handler to the given listening connection.
> - *
> - * The DNS event handler parses the incoming UDP packets, treating them as DNS
> - * requests. If an incoming packet gets successfully parsed by the DNS event
> - * handler, a user event handler will receive an `MG_DNS_REQUEST` event, with
> - * `ev_data` pointing to the parsed `struct mg_dns_message`.
> - *
> - * See
> - * [captive_dns_server](https://github.com/cesanta/mongoose/tree/master/examples/captive_dns_server)
> - * example on how to handle DNS request and send DNS reply.
> - */
> -void mg_set_protocol_dns(struct mg_connection *nc);
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* CS_MONGOOSE_SRC_DNS_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_dns_server.h"
> -#endif
>   
> -/*
> - * === DNS server API reference
> - *
> - * Disabled by default; enable with `-DMG_ENABLE_DNS_SERVER`.
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_DNS_SERVER_H_
> -#define CS_MONGOOSE_SRC_DNS_SERVER_H_
>   
> -#if MG_ENABLE_DNS_SERVER
>   
> -/* Amalgamated: #include "mg_dns.h" */
> +struct mg_dns {
> +  const char *url;          // DNS server URL
> +  struct mg_connection *c;  // DNS server connection
> +};
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> +struct mg_addr {
> +  uint16_t port;    // TCP or UDP port in network byte order
> +  uint32_t ip;      // IP address in network byte order
> +  uint8_t ip6[16];  // IPv6 address
> +  bool is_ip6;      // True when address is IPv6 address
> +};
>   
> -#define MG_DNS_SERVER_DEFAULT_TTL 3600
> +struct mg_mgr {
> +  struct mg_connection *conns;  // List of active connections
> +  struct mg_dns dns4;           // DNS for IPv4
> +  struct mg_dns dns6;           // DNS for IPv6
> +  int dnstimeout;               // DNS resolve timeout in milliseconds
> +  unsigned long nextid;         // Next connection ID
> +  void *userdata;               // Arbitrary user data pointer
> +#if MG_ARCH == MG_ARCH_FREERTOS_TCP
> +  SocketSet_t ss;  // NOTE(lsm): referenced from socket struct
> +#endif
> +};
>   
> -struct mg_dns_reply {
> -  struct mg_dns_message *msg;
> -  struct mbuf *io;
> -  size_t start;
> +struct mg_connection {
> +  struct mg_connection *next;  // Linkage in struct mg_mgr :: connections
> +  struct mg_mgr *mgr;          // Our container
> +  struct mg_addr peer;         // Remote address. For listeners, local address
> +  void *fd;                    // Connected socket, or LWIP data
> +  unsigned long id;            // Auto-incrementing unique connection ID
> +  struct mg_iobuf recv;        // Incoming data
> +  struct mg_iobuf send;        // Outgoing data
> +  mg_event_handler_t fn;       // User-specified event handler function
> +  void *fn_data;               // User-specified function parameter
> +  mg_event_handler_t pfn;      // Protocol-specific handler function
> +  void *pfn_data;              // Protocol-specific function parameter
> +  char label[50];              // Arbitrary label
> +  void *tls;                   // TLS specific data
> +  unsigned is_listening : 1;   // Listening connection
> +  unsigned is_client : 1;      // Outbound (client) connection
> +  unsigned is_accepted : 1;    // Accepted (server) connection
> +  unsigned is_resolving : 1;   // Non-blocking DNS resolution is in progress
> +  unsigned is_connecting : 1;  // Non-blocking connect is in progress
> +  unsigned is_tls : 1;         // TLS-enabled connection
> +  unsigned is_tls_hs : 1;      // TLS handshake is in progress
> +  unsigned is_udp : 1;         // UDP connection
> +  unsigned is_websocket : 1;   // WebSocket connection
> +  unsigned is_hexdumping : 1;  // Hexdump in/out traffic
> +  unsigned is_draining : 1;    // Send remaining data, then close and free
> +  unsigned is_closing : 1;     // Close and free the connection immediately
> +  unsigned is_readable : 1;    // Connection is ready to read
> +  unsigned is_writable : 1;    // Connection is ready to write
>   };
>   
> -/*
> - * Creates a DNS reply.
> - *
> - * The reply will be based on an existing query message `msg`.
> - * The query body will be appended to the output buffer.
> - * "reply + recursion allowed" will be added to the message flags and the
> - * message's num_answers will be set to 0.
> - *
> - * Answer records can be appended with `mg_dns_send_reply` or by lower
> - * level function defined in the DNS API.
> - *
> - * In order to send a reply use `mg_dns_send_reply`.
> - * It's possible to use a connection's send buffer as reply buffer,
> - * and it will work for both UDP and TCP connections.
> - *
> - * Example:
> - *
> - * ```c
> - * reply = mg_dns_create_reply(&nc->send_mbuf, msg);
> - * for (i = 0; i < msg->num_questions; i++) {
> - *   rr = &msg->questions[i];
> - *   if (rr->rtype == MG_DNS_A_RECORD) {
> - *     mg_dns_reply_record(&reply, rr, 3600, &dummy_ip_addr, 4);
> - *   }
> - * }
> - * mg_dns_send_reply(nc, &reply);
> - * ```
> - */
> -struct mg_dns_reply mg_dns_create_reply(struct mbuf *io,
> -                                        struct mg_dns_message *msg);
> -
> -/*
> - * Appends a DNS reply record to the IO buffer and to the DNS message.
> - *
> - * The message's num_answers field will be incremented. It's the caller's duty
> - * to ensure num_answers is properly initialised.
> - *
> - * Returns -1 on error.
> - */
> -int mg_dns_reply_record(struct mg_dns_reply *reply,
> -                        struct mg_dns_resource_record *question,
> -                        const char *name, int rtype, int ttl, const void *rdata,
> -                        size_t rdata_len);
> -
> -/*
> - * Sends a DNS reply through a connection.
> - *
> - * The DNS data is stored in an IO buffer pointed by reply structure in `r`.
> - * This function mutates the content of that buffer in order to ensure that
> - * the DNS header reflects the size and flags of the message, that might have
> - * been updated either with `mg_dns_reply_record` or by direct manipulation of
> - * `r->message`.
> - *
> - * Once sent, the IO buffer will be trimmed unless the reply IO buffer
> - * is the connection's send buffer and the connection is not in UDP mode.
> - */
> -void mg_dns_send_reply(struct mg_connection *nc, struct mg_dns_reply *r);
> +void mg_mgr_poll(struct mg_mgr *, int ms);
> +void mg_mgr_init(struct mg_mgr *);
> +void mg_mgr_free(struct mg_mgr *);
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> +struct mg_connection *mg_listen(struct mg_mgr *, const char *url,
> +                                mg_event_handler_t fn, void *fn_data);
> +struct mg_connection *mg_connect(struct mg_mgr *, const char *url,
> +                                 mg_event_handler_t fn, void *fn_data);
> +bool mg_send(struct mg_connection *, const void *, size_t);
> +int mg_printf(struct mg_connection *, const char *fmt, ...);
> +int mg_vprintf(struct mg_connection *, const char *fmt, va_list ap);
> +char *mg_straddr(struct mg_connection *, char *, size_t);
> +bool mg_aton(struct mg_str str, struct mg_addr *addr);
> +char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len);
>   
> -#endif /* MG_ENABLE_DNS_SERVER */
> -#endif /* CS_MONGOOSE_SRC_DNS_SERVER_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_resolv.h"
> -#endif
> +struct mg_connection *mg_mkpipe(struct mg_mgr *, mg_event_handler_t, void *);
> +void mg_mgr_wakeup(struct mg_connection *pipe);
>   
> -/*
> - * === API reference
> - */
>   
> -#ifndef CS_MONGOOSE_SRC_RESOLV_H_
> -#define CS_MONGOOSE_SRC_RESOLV_H_
>   
> -/* Amalgamated: #include "mg_dns.h" */
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
>   
> -enum mg_resolve_err {
> -  MG_RESOLVE_OK = 0,
> -  MG_RESOLVE_NO_ANSWERS = 1,
> -  MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2,
> -  MG_RESOLVE_TIMEOUT = 3
> -};
>   
> -typedef void (*mg_resolve_callback_t)(struct mg_dns_message *dns_message,
> -                                      void *user_data, enum mg_resolve_err);
> -
> -/* Options for `mg_resolve_async_opt`. */
> -struct mg_resolve_async_opts {
> -  const char *nameserver;
> -  int max_retries;    /* defaults to 2 if zero */
> -  int timeout;        /* in seconds; defaults to 5 if zero */
> -  int accept_literal; /* pseudo-resolve literal ipv4 and ipv6 addrs */
> -  int only_literal;   /* only resolves literal addrs; sync cb invocation */
> -  struct mg_connection **dns_conn; /* return DNS connection */
> -};
>   
> -/* See `mg_resolve_async_opt()` */
> -int mg_resolve_async(struct mg_mgr *mgr, const char *name, int query,
> -                     mg_resolve_callback_t cb, void *data);
> -
> -/* Set default DNS server */
> -void mg_set_nameserver(struct mg_mgr *mgr, const char *nameserver);
> -
> -/*
> - * Resolved a DNS name asynchronously.
> - *
> - * Upon successful resolution, the user callback will be invoked
> - * with the full DNS response message and a pointer to the user's
> - * context `data`.
> - *
> - * In case of timeout while performing the resolution the callback
> - * will receive a NULL `msg`.
> - *
> - * The DNS answers can be extracted with `mg_next_record` and
> - * `mg_dns_parse_record_data`:
> - *
> - * [source,c]
> - * ----
> - * struct in_addr ina;
> - * struct mg_dns_resource_record *rr = mg_next_record(msg, MG_DNS_A_RECORD,
> - *   NULL);
> - * mg_dns_parse_record_data(msg, rr, &ina, sizeof(ina));
> - * ----
> - */
> -int mg_resolve_async_opt(struct mg_mgr *mgr, const char *name, int query,
> -                         mg_resolve_callback_t cb, void *data,
> -                         struct mg_resolve_async_opts opts);
> -
> -/*
> - * Resolve a name from `/etc/hosts`.
> - *
> - * Returns 0 on success, -1 on failure.
> - */
> -int mg_resolve_from_hosts_file(const char *host, union socket_address *usa);
> +struct mg_http_header {
> +  struct mg_str name;   // Header name
> +  struct mg_str value;  // Header value
> +};
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> -#endif /* CS_MONGOOSE_SRC_RESOLV_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_coap.h"
> -#endif
> +struct mg_http_message {
> +  struct mg_str method, uri, query, proto;             // Request/response line
> +  struct mg_http_header headers[MG_MAX_HTTP_HEADERS];  // Headers
> +  struct mg_str body;                                  // Body
> +  struct mg_str head;                                  // Request + headers
> +  struct mg_str chunk;    // Chunk for chunked encoding,  or partial body
> +  struct mg_str message;  // Request + headers + body
> +};
>   
> -/*
> - * === CoAP API reference
> - *
> - * CoAP message format:
> - *
> - * ```
> - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
> - * |Ver| T | TKL | Code | Message ID | Token (if any, TKL bytes) ...
> - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
> - * | Options (if any) ...            |1 1 1 1 1 1 1 1| Payload (if any) ...
> - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
> - * ```
> - */
> -
> -#ifndef CS_MONGOOSE_SRC_COAP_H_
> -#define CS_MONGOOSE_SRC_COAP_H_
> -
> -#if MG_ENABLE_COAP
> -
> -#define MG_COAP_MSG_TYPE_FIELD 0x2
> -#define MG_COAP_CODE_CLASS_FIELD 0x4
> -#define MG_COAP_CODE_DETAIL_FIELD 0x8
> -#define MG_COAP_MSG_ID_FIELD 0x10
> -#define MG_COAP_TOKEN_FIELD 0x20
> -#define MG_COAP_OPTIOMG_FIELD 0x40
> -#define MG_COAP_PAYLOAD_FIELD 0x80
> -
> -#define MG_COAP_ERROR 0x10000
> -#define MG_COAP_FORMAT_ERROR (MG_COAP_ERROR | 0x20000)
> -#define MG_COAP_IGNORE (MG_COAP_ERROR | 0x40000)
> -#define MG_COAP_NOT_ENOUGH_DATA (MG_COAP_ERROR | 0x80000)
> -#define MG_COAP_NETWORK_ERROR (MG_COAP_ERROR | 0x100000)
> -
> -#define MG_COAP_MSG_CON 0
> -#define MG_COAP_MSG_NOC 1
> -#define MG_COAP_MSG_ACK 2
> -#define MG_COAP_MSG_RST 3
> -#define MG_COAP_MSG_MAX 3
> -
> -#define MG_COAP_CODECLASS_REQUEST 0
> -#define MG_COAP_CODECLASS_RESP_OK 2
> -#define MG_COAP_CODECLASS_CLIENT_ERR 4
> -#define MG_COAP_CODECLASS_SRV_ERR 5
> -
> -#define MG_COAP_EVENT_BASE 300
> -#define MG_EV_COAP_CON (MG_COAP_EVENT_BASE + MG_COAP_MSG_CON)
> -#define MG_EV_COAP_NOC (MG_COAP_EVENT_BASE + MG_COAP_MSG_NOC)
> -#define MG_EV_COAP_ACK (MG_COAP_EVENT_BASE + MG_COAP_MSG_ACK)
> -#define MG_EV_COAP_RST (MG_COAP_EVENT_BASE + MG_COAP_MSG_RST)
> -
> -/*
> - * CoAP options.
> - * Use mg_coap_add_option and mg_coap_free_options
> - * for creation and destruction.
> - */
> -struct mg_coap_option {
> -  struct mg_coap_option *next;
> -  uint32_t number;
> -  struct mg_str value;
> +// Parameter for mg_http_serve_dir()
> +struct mg_http_serve_opts {
> +  const char *root_dir;       // Web root directory, must be non-NULL
> +  const char *ssi_pattern;    // SSI file name pattern, e.g. #.shtml
> +  const char *extra_headers;  // Extra HTTP headers to add in responses
> +  const char *mime_types;     // Extra mime types, ext1=type1,ext2=type2,..
> +  struct mg_fs *fs;           // Filesystem implementation. Use NULL for POSIX
>   };
>   
> -/* CoAP message. See RFC 7252 for details. */
> -struct mg_coap_message {
> -  uint32_t flags;
> -  uint8_t msg_type;
> -  uint8_t code_class;
> -  uint8_t code_detail;
> -  uint16_t msg_id;
> -  struct mg_str token;
> -  struct mg_coap_option *options;
> -  struct mg_str payload;
> -  struct mg_coap_option *optiomg_tail;
> +// Parameter for mg_http_next_multipart
> +struct mg_http_part {
> +  struct mg_str name;      // Form field name
> +  struct mg_str filename;  // Filename for file uploads
> +  struct mg_str body;      // Part contents
>   };
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/* Sets CoAP protocol handler - triggers CoAP specific events. */
> -int mg_set_protocol_coap(struct mg_connection *nc);
> -
> -/*
> - * Adds a new option to mg_coap_message structure.
> - * Returns pointer to the newly created option.
> - * Note: options must be freed by using mg_coap_free_options
> - */
> -struct mg_coap_option *mg_coap_add_option(struct mg_coap_message *cm,
> -                                          uint32_t number, char *value,
> -                                          size_t len);
> -
> -/*
> - * Frees the memory allocated for options.
> - * If the cm parameter doesn't contain any option it does nothing.
> - */
> -void mg_coap_free_options(struct mg_coap_message *cm);
> -
> -/*
> - * Composes a CoAP message from `mg_coap_message`
> - * and sends it into `nc` connection.
> - * Returns 0 on success. On error, it is a bitmask:
> - *
> - * - `#define MG_COAP_ERROR 0x10000`
> - * - `#define MG_COAP_FORMAT_ERROR (MG_COAP_ERROR | 0x20000)`
> - * - `#define MG_COAP_IGNORE (MG_COAP_ERROR | 0x40000)`
> - * - `#define MG_COAP_NOT_ENOUGH_DATA (MG_COAP_ERROR | 0x80000)`
> - * - `#define MG_COAP_NETWORK_ERROR (MG_COAP_ERROR | 0x100000)`
> - */
> -uint32_t mg_coap_send_message(struct mg_connection *nc,
> -                              struct mg_coap_message *cm);
> -
> -/*
> - * Composes CoAP acknowledgement from `mg_coap_message`
> - * and sends it into `nc` connection.
> - * Return value: see `mg_coap_send_message()`
> - */
> -uint32_t mg_coap_send_ack(struct mg_connection *nc, uint16_t msg_id);
> -
> -/*
> - * Parses CoAP message and fills mg_coap_message and returns cm->flags.
> - * This is a helper function.
> - *
> - * NOTE: usually CoAP works over UDP, so lack of data means format error.
> - * But, in theory, it is possible to use CoAP over TCP (according to RFC)
> - *
> - * The caller has to check results and treat COAP_NOT_ENOUGH_DATA according to
> - * underlying protocol:
> - *
> - * - in case of UDP COAP_NOT_ENOUGH_DATA means COAP_FORMAT_ERROR,
> - * - in case of TCP client can try to receive more data
> - *
> - * Return value: see `mg_coap_send_message()`
> - */
> -uint32_t mg_coap_parse(struct mbuf *io, struct mg_coap_message *cm);
> -
> -/*
> - * Composes CoAP message from mg_coap_message structure.
> - * This is a helper function.
> - * Return value: see `mg_coap_send_message()`
> - */
> -uint32_t mg_coap_compose(struct mg_coap_message *cm, struct mbuf *io);
> +int mg_http_parse(const char *s, size_t len, struct mg_http_message *);
> +int mg_http_get_request_len(const unsigned char *buf, size_t buf_len);
> +void mg_http_printf_chunk(struct mg_connection *cnn, const char *fmt, ...);
> +void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len);
> +void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm);
> +struct mg_connection *mg_http_listen(struct mg_mgr *, const char *url,
> +                                     mg_event_handler_t fn, void *fn_data);
> +struct mg_connection *mg_http_connect(struct mg_mgr *, const char *url,
> +                                      mg_event_handler_t fn, void *fn_data);
> +void mg_http_serve_dir(struct mg_connection *, struct mg_http_message *hm,
> +                       struct mg_http_serve_opts *opts);
> +void mg_http_serve_file(struct mg_connection *, struct mg_http_message *hm,
> +                        const char *path, struct mg_http_serve_opts *opts);
> +void mg_http_reply(struct mg_connection *, int status_code, const char *headers,
> +                   const char *body_fmt, ...);
> +struct mg_str *mg_http_get_header(struct mg_http_message *, const char *name);
> +int mg_http_get_var(const struct mg_str *, const char *name, char *, size_t);
> +int mg_url_decode(const char *s, size_t n, char *to, size_t to_len, int form);
> +size_t mg_url_encode(const char *s, size_t n, char *buf, size_t len);
> +void mg_http_creds(struct mg_http_message *, char *, size_t, char *, size_t);
> +bool mg_http_match_uri(const struct mg_http_message *, const char *glob);
> +int mg_http_upload(struct mg_connection *, struct mg_http_message *hm,
> +                   const char *dir);
> +void mg_http_bauth(struct mg_connection *, const char *user, const char *pass);
> +struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v);
> +size_t mg_http_next_multipart(struct mg_str, size_t, struct mg_http_part *);
> +
> +
> +void mg_http_serve_ssi(struct mg_connection *c, const char *root,
> +                       const char *fullpath);
> +
> +
> +
> +struct mg_tls_opts {
> +  const char *ca;         // CA certificate file. For both listeners and clients
> +  const char *cert;       // Certificate
> +  const char *certkey;    // Certificate key
> +  const char *ciphers;    // Cipher list
> +  struct mg_str srvname;  // If not empty, enables server name verification
> +};
>   
> -#ifdef __cplusplus
> -}
> -#endif /* __cplusplus */
> +void mg_tls_init(struct mg_connection *, struct mg_tls_opts *);
> +void mg_tls_free(struct mg_connection *);
> +long mg_tls_send(struct mg_connection *, const void *buf, size_t len);
> +long mg_tls_recv(struct mg_connection *, void *buf, size_t len);
> +void mg_tls_handshake(struct mg_connection *);
>   
> -#endif /* MG_ENABLE_COAP */
>   
> -#endif /* CS_MONGOOSE_SRC_COAP_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_sntp.h"
> -#endif
> +#define WEBSOCKET_OP_CONTINUE 0
> +#define WEBSOCKET_OP_TEXT 1
> +#define WEBSOCKET_OP_BINARY 2
> +#define WEBSOCKET_OP_CLOSE 8
> +#define WEBSOCKET_OP_PING 9
> +#define WEBSOCKET_OP_PONG 10
>   
> -#ifndef CS_MONGOOSE_SRC_SNTP_H_
> -#define CS_MONGOOSE_SRC_SNTP_H_
>   
> -#if MG_ENABLE_SNTP
>   
> -#define MG_SNTP_EVENT_BASE 500
> +struct mg_ws_message {
> +  struct mg_str data;  // Websocket message data
> +  uint8_t flags;       // Websocket message flags
> +};
>   
> -/*
> - * Received reply from time server. Event handler parameter contains
> - * pointer to mg_sntp_message structure
> - */
> -#define MG_SNTP_REPLY (MG_SNTP_EVENT_BASE + 1)
> +struct mg_connection *mg_ws_connect(struct mg_mgr *, const char *url,
> +                                    mg_event_handler_t fn, void *fn_data,
> +                                    const char *fmt, ...);
> +void mg_ws_upgrade(struct mg_connection *, struct mg_http_message *,
> +                   const char *fmt, ...);
> +size_t mg_ws_send(struct mg_connection *, const char *buf, size_t len, int op);
> +size_t mg_ws_wrap(struct mg_connection *, size_t len, int op);
>   
> -/* Received malformed SNTP packet */
> -#define MG_SNTP_MALFORMED_REPLY (MG_SNTP_EVENT_BASE + 2)
>   
> -/* Failed to get time from server (timeout etc) */
> -#define MG_SNTP_FAILED (MG_SNTP_EVENT_BASE + 3)
>   
> -struct mg_sntp_message {
> -  /* if server sends this flags, user should not send requests to it */
> -  int kiss_of_death;
> -  /* usual mg_time */
> -  double time;
> -};
>   
> -/* Establishes connection to given sntp server */
> -struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr,
> -                                      MG_CB(mg_event_handler_t event_handler,
> -                                            void *user_data),
> -                                      const char *sntp_server_name);
> -
> -/* Sends time request to given connection */
> -void mg_sntp_send_request(struct mg_connection *c);
> -
> -/*
> - * Helper function
> - * Establishes connection to time server, tries to send request
> - * repeats sending SNTP_ATTEMPTS times every SNTP_TIMEOUT sec
> - * (if needed)
> - * See sntp_client example
> - */
> -struct mg_connection *mg_sntp_get_time(struct mg_mgr *mgr,
> -                                       mg_event_handler_t event_handler,
> -                                       const char *sntp_server_name);
> +struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, const char *url,
> +                                      mg_event_handler_t fn, void *fn_data);
> +void mg_sntp_send(struct mg_connection *c, unsigned long utc);
> +int mg_sntp_parse(const unsigned char *buf, size_t len, struct timeval *tv);
>   
> -#endif
>   
> -#endif /* CS_MONGOOSE_SRC_SNTP_H_ */
> -#ifdef MG_MODULE_LINES
> -#line 1 "mongoose/src/mg_socks.h"
> -#endif
>   
> -#ifndef CS_MONGOOSE_SRC_SOCKS_H_
> -#define CS_MONGOOSE_SRC_SOCKS_H_
>   
> -#if MG_ENABLE_SOCKS
>   
> -#define MG_SOCKS_VERSION 5
> +#define MQTT_CMD_CONNECT 1
> +#define MQTT_CMD_CONNACK 2
> +#define MQTT_CMD_PUBLISH 3
> +#define MQTT_CMD_PUBACK 4
> +#define MQTT_CMD_PUBREC 5
> +#define MQTT_CMD_PUBREL 6
> +#define MQTT_CMD_PUBCOMP 7
> +#define MQTT_CMD_SUBSCRIBE 8
> +#define MQTT_CMD_SUBACK 9
> +#define MQTT_CMD_UNSUBSCRIBE 10
> +#define MQTT_CMD_UNSUBACK 11
> +#define MQTT_CMD_PINGREQ 12
> +#define MQTT_CMD_PINGRESP 13
> +#define MQTT_CMD_DISCONNECT 14
>   
> -#define MG_SOCKS_HANDSHAKE_DONE MG_F_USER_1
> -#define MG_SOCKS_CONNECT_DONE MG_F_USER_2
> +#define MQTT_QOS(qos) ((qos) << 1)
> +#define MQTT_GET_QOS(flags) (((flags) &0x6) >> 1)
> +#define MQTT_SET_QOS(flags, qos) (flags) = ((flags) & ~0x6) | ((qos) << 1)
>   
> -/* SOCKS5 handshake methods */
> -enum mg_socks_handshake_method {
> -  MG_SOCKS_HANDSHAKE_NOAUTH = 0,     /* Handshake method - no authentication */
> -  MG_SOCKS_HANDSHAKE_GSSAPI = 1,     /* Handshake method - GSSAPI auth */
> -  MG_SOCKS_HANDSHAKE_USERPASS = 2,   /* Handshake method - user/password auth */
> -  MG_SOCKS_HANDSHAKE_FAILURE = 0xff, /* Handshake method - failure */
> +struct mg_mqtt_opts {
> +  struct mg_str client_id;     // Client ID
> +  struct mg_str will_topic;    // Will topic
> +  struct mg_str will_message;  // Will message
> +  uint8_t qos;                 // Quality of service
> +  bool will_retain;            // Retain last will
> +  bool clean;                  // Use clean session, 0 or 1
> +  uint16_t keepalive;          // Keep-alive timer in seconds
>   };
>   
> -/* SOCKS5 commands */
> -enum mg_socks_command {
> -  MG_SOCKS_CMD_CONNECT = 1,       /* Command: CONNECT */
> -  MG_SOCKS_CMD_BIND = 2,          /* Command: BIND */
> -  MG_SOCKS_CMD_UDP_ASSOCIATE = 3, /* Command: UDP ASSOCIATE */
> +struct mg_mqtt_message {
> +  struct mg_str topic;  // Parsed topic
> +  struct mg_str data;   // Parsed message
> +  struct mg_str dgram;  // Whole MQTT datagram, including headers
> +  uint16_t id;  // Set for PUBACK, PUBREC, PUBREL, PUBCOMP, SUBACK, PUBLISH
> +  uint8_t cmd;  // MQTT command, one of MQTT_CMD_*
> +  uint8_t qos;  // Quality of service
> +  uint8_t ack;  // Connack return code. 0 - success
>   };
>   
> -/* SOCKS5 address types */
> -enum mg_socks_address_type {
> -  MG_SOCKS_ADDR_IPV4 = 1,   /* Address type: IPv4 */
> -  MG_SOCKS_ADDR_DOMAIN = 3, /* Address type: Domain name */
> -  MG_SOCKS_ADDR_IPV6 = 4,   /* Address type: IPv6 */
> +struct mg_connection *mg_mqtt_connect(struct mg_mgr *, const char *url,
> +                                      struct mg_mqtt_opts *opts,
> +                                      mg_event_handler_t fn, void *fn_data);
> +struct mg_connection *mg_mqtt_listen(struct mg_mgr *mgr, const char *url,
> +                                     mg_event_handler_t fn, void *fn_data);
> +void mg_mqtt_login(struct mg_connection *c, const char *url,
> +                   struct mg_mqtt_opts *opts);
> +void mg_mqtt_pub(struct mg_connection *c, struct mg_str *topic,
> +                 struct mg_str *data, int qos, bool retain);
> +void mg_mqtt_sub(struct mg_connection *, struct mg_str *topic, int qos);
> +int mg_mqtt_parse(const uint8_t *buf, size_t len, struct mg_mqtt_message *m);
> +void mg_mqtt_send_header(struct mg_connection *, uint8_t cmd, uint8_t flags,
> +                         uint32_t len);
> +size_t mg_mqtt_next_sub(struct mg_mqtt_message *msg, struct mg_str *topic,
> +                        uint8_t *qos, size_t pos);
> +size_t mg_mqtt_next_unsub(struct mg_mqtt_message *msg, struct mg_str *topic,
> +                          size_t pos);
> +void mg_mqtt_ping(struct mg_connection *);
> +void mg_mqtt_pong(struct mg_connection *);
> +void mg_mqtt_disconnect(struct mg_connection *);
> +
> +
> +
> +
> +
> +// Mongoose sends DNS queries that contain only one question:
> +// either A (IPv4) or AAAA (IPv6) address lookup.
> +// Therefore, we expect zero or one answer.
> +// If `resolved` is true, then `addr` contains resolved IPv4 or IPV6 address.
> +struct mg_dns_message {
> +  uint16_t txnid;       // Transaction ID
> +  bool resolved;        // Resolve successful, addr is set
> +  struct mg_addr addr;  // Resolved address
> +  char name[256];       // Host name
>   };
>   
> -/* SOCKS5 response codes */
> -enum mg_socks_response {
> -  MG_SOCKS_SUCCESS = 0,            /* Response: success */
> -  MG_SOCKS_FAILURE = 1,            /* Response: failure */
> -  MG_SOCKS_NOT_ALLOWED = 2,        /* Response: connection not allowed */
> -  MG_SOCKS_NET_UNREACHABLE = 3,    /* Response: network unreachable */
> -  MG_SOCKS_HOST_UNREACHABLE = 4,   /* Response: network unreachable */
> -  MG_SOCKS_CONN_REFUSED = 5,       /* Response: network unreachable */
> -  MG_SOCKS_TTL_EXPIRED = 6,        /* Response: network unreachable */
> -  MG_SOCKS_CMD_NOT_SUPPORTED = 7,  /* Response: network unreachable */
> -  MG_SOCKS_ADDR_NOT_SUPPORTED = 8, /* Response: network unreachable */
> +struct mg_dns_header {
> +  uint16_t txnid;  // Transaction ID
> +  uint16_t flags;
> +  uint16_t num_questions;
> +  uint16_t num_answers;
> +  uint16_t num_authority_prs;
> +  uint16_t num_other_prs;
>   };
>   
> -#ifdef __cplusplus
> -extern "C" {
> -#endif /* __cplusplus */
> -
> -/* Turn the connection into the SOCKS server */
> -void mg_set_protocol_socks(struct mg_connection *c);
> +// DNS resource record
> +struct mg_dns_rr {
> +  uint16_t nlen;    // Name or pointer length
> +  uint16_t atype;   // Address type
> +  uint16_t aclass;  // Address class
> +  uint16_t alen;    // Address length
> +};
>   
> -/* Create socks tunnel for the client connection */
> -struct mg_iface *mg_socks_mk_iface(struct mg_mgr *, const char *proxy_addr);
> +void mg_resolve(struct mg_connection *, struct mg_str *, int);
> +void mg_resolve_cancel(struct mg_connection *);
> +bool mg_dns_parse(const uint8_t *buf, size_t len, struct mg_dns_message *);
> +size_t mg_dns_parse_rr(const uint8_t *buf, size_t len, size_t ofs,
> +                       bool is_question, struct mg_dns_rr *);
> +size_t mg_dns_decode_name(const uint8_t *, size_t, size_t, char *, size_t);
>   
>   #ifdef __cplusplus
>   }
> -#endif /* __cplusplus */
> -
> -#endif
>   #endif
> +#endif  // MONGOOSE_H
>