// 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_ENABLE_LINES

#line 1 "src/private.h"

#endif

void mg_connect_resolved(struct mg_connection *);

#ifdef MG_ENABLE_LINES

#line 1 "src/base64.c"

#endif

#include <string.h>

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 {

return -1;

}

}

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;

}

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;

}

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;

}

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;

}

#ifdef MG_ENABLE_LINES

#line 1 "src/dns.c"

#endif

struct dns_data {

struct dns_data *next;

struct mg_connection *c;

unsigned long expire;

uint16_t txnid;

};

static struct dns_data *s_reqs; // Active DNS requests

static void mg_sendnsreq(struct mg_connection *, struct mg_str *, int,

struct mg_dns *, bool);

static void mg_dns_free(struct dns_data *d) {

LIST_DELETE(struct dns_data, &s_reqs, d);

free(d);

}

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);

}

}

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;

}

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);

}

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];

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

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);

}

}

#ifdef MG_ENABLE_LINES

#line 1 "src/event.c"

#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);

}

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;

}

#ifdef MG_ENABLE_LINES

#line 1 "src/http.c"

#endif

// 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;

// Init part params

if (part != NULL) part->name = part->filename = part->body = mg_str_n(0, 0);

// 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));

// 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++;

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;

}

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));

}

}

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;

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;

}

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;

}

} 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;

}

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;

}

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;

}

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;

}

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;

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;

}

// 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;

}

return req_len;

}

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);

}

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);

}

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);

}

// 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[100], *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);

}

#if MG_ENABLE_FS

static void http_cb(struct mg_connection *, int, void *, void *);

static void restore_http_cb(struct mg_connection *c) {

if (c->pfn_data != NULL) fclose((FILE *) c->pfn_data);

c->pfn_data = NULL;

c->pfn = http_cb;

}

char *mg_http_etag(char *buf, size_t len, mg_stat_t *st) {

snprintf(buf, len, "\"%lx." MG_INT64_FMT "\"", (unsigned long) st->st_mtime,

(int64_t) st->st_size);

return buf;

}

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 = mg_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;

}

}

}

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) {

FILE *fp = (FILE *) 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 = fread(c->send.buf + c->send.len, 1, c->send.size - c->send.len, fp);

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;

}

static const char *guess_content_type(const char *filename) {

size_t n = strlen(filename);

#define MIME_ENTRY(_ext, _type) \

{ _ext, sizeof(_ext) - 1, _type }

const struct {

const char *ext;

size_t ext_len;

const char *type;

} * t, types[] = {

MIME_ENTRY("html", "text/html; charset=utf-8"),

MIME_ENTRY("htm", "text/html; charset=utf-8"),

MIME_ENTRY("shtml", "text/html; charset=utf-8"),

MIME_ENTRY("css", "text/css"),

MIME_ENTRY("js", "text/javascript"),

MIME_ENTRY("mjs", "text/javascript"),

MIME_ENTRY("json", "application/json"),

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; charset=utf-8"),

MIME_ENTRY("wav", "audio/wav"),

MIME_ENTRY("mp3", "audio/mpeg"),

MIME_ENTRY("mid", "audio/mid"),

MIME_ENTRY("ogg", "application/ogg"),

MIME_ENTRY("xml", "application/xml"),

MIME_ENTRY("ttf", "font/ttf"),

MIME_ENTRY("json", "application/json"),

MIME_ENTRY("xsl", "application/xml"),

MIME_ENTRY("doc", "application/msword"),

MIME_ENTRY("exe", "application/octet-stream"),

MIME_ENTRY("zip", "application/zip"),

MIME_ENTRY("xls", "application/excel"),

MIME_ENTRY("tgz", "application/tar-gz"),

MIME_ENTRY("tar", "application/tar"),

MIME_ENTRY("gz", "application/gzip"),

MIME_ENTRY("rar", "application/rar"),

MIME_ENTRY("rtf", "application/rtf"),

MIME_ENTRY("pdf", "application/pdf"),

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("avi", "video/x-msvideo"),

MIME_ENTRY("csv", "text/csv"),

MIME_ENTRY("bmp", "image/bmp"),

MIME_ENTRY("bin", "application/octet-stream"),

MIME_ENTRY("wasm", "application/wasm"),

{NULL, 0, NULL},

};

for (t = types; t->ext != NULL; t++) {

if (n < t->ext_len + 2) continue;

if (mg_ncasecmp(t->ext, &filename[n - t->ext_len], t->ext_len)) continue;

return t->type;

}

return "text/plain; charset=utf-8";

}

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, const char *mime, const char *hdrs) {

struct mg_str *inm = mg_http_get_header(hm, "If-None-Match");

mg_stat_t st;

char etag[64];

FILE *fp = mg_fopen(path, "rb");

if (fp == NULL || mg_stat(path, &st) != 0 ||

mg_http_etag(etag, sizeof(etag), &st) != etag) {

LOG(LL_DEBUG,

("404 [%.*s] [%s] %p", (int) hm->uri.len, hm->uri.ptr, path, fp));

mg_http_reply(c, 404, "", "%s", "Not found\n");

if (fp != NULL) fclose(fp);

} else if (inm != NULL && mg_vcasecmp(inm, etag) == 0) {

fclose(fp);

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 = st.st_size;

// 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) st.st_size);

} else {

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) st.st_size);

#if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \

_XOPEN_SOURCE >= 600

fseeko(fp, (off_t) r1, SEEK_SET);

#else

fseek(fp, (long) r1, SEEK_SET);

#endif

}

}

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), mime, etag, cl, range,

hdrs ? hdrs : "");

if (mg_vcasecmp(&hm->method, "HEAD") == 0) {

fclose(fp);

} else {

c->pfn = static_cb;

c->pfn_data = fp;

}

}

}

#if MG_ARCH == MG_ARCH_ESP32 || MG_ARCH == MG_ARCH_ESP8266 || \

MG_ARCH == MG_ARCH_FREERTOS_TCP

char *realpath(const char *src, char *dst) {

int len = strlen(src);

if (len > MG_PATH_MAX - 1) len = MG_PATH_MAX - 1;

strncpy(dst, src, len);

dst[len] = '\0';

LOG(LL_DEBUG, ("[%s] -> [%s]", src, dst));

return dst;

}

#endif

// Allow user to override this function

bool mg_is_dir(const char *path) WEAK;

bool mg_is_dir(const char *path) {

#if MG_ARCH == MG_ARCH_FREERTOS_TCP && defined(MG_ENABLE_FF)

struct FF_STAT st;

return (ff_stat(path, &st) == 0) && (st.st_mode & FF_IFDIR);

#else

mg_stat_t st;

return mg_stat(path, &st) == 0 && S_ISDIR(st.st_mode);

#endif

}