#include "mongoose.h"

#ifdef MG_MODULE_LINES

#line 1 "mongoose/src/internal.h"

#endif

/*

* Copyright (c) 2014 Cesanta Software Limited

* All rights reserved

*/

#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 "mongoose/src/http.h" */

/* Amalgamated: #include "mongoose/src/net.h" */

#define MG_CTL_MSG_MESSAGE_SIZE 8192

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

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;

/*

* 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

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

#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

}

#endif

#endif /* CS_COMMON_MG_MEM_H_ */

#ifdef MG_MODULE_LINES

#line 1 "common/cs_base64.c"

#endif

/*

* Copyright (c) 2014 Cesanta Software Limited

* All rights reserved

*/

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

} else {

ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/',

ctx->user_data);

}

}

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

}

}

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;

}

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;

}

}

}

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

}

}

}

#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"

#endif

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

#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_ENABLE_TS_DIFF

#define CS_LOG_ENABLE_TS_DIFF 0

#endif

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

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,

};

/* Set log level. */

void cs_log_set_level(enum cs_log_level level);

/* Set log filter. NULL (a default) logs everything. */

void cs_log_set_filter(const char *source_file_name);

int cs_log_print_prefix(enum cs_log_level level, const char *func,

const char *filename);

extern enum cs_log_level cs_log_threshold;

#if CS_ENABLE_STDIO

void cs_log_set_file(FILE *file);

void cs_log_printf(const char *fmt, ...)

#ifdef __GNUC__

__attribute__((format(printf, 1, 2)))

#endif

;

#define LOG(l, x) \

do { \

if (cs_log_print_prefix(l, __func__, __FILE__)) cs_log_printf x; \

} while (0)

#ifndef CS_NDEBUG

#define DBG(x) LOG(LL_VERBOSE_DEBUG, x)

#else /* NDEBUG */

#define DBG(x)

#endif

#else /* CS_ENABLE_STDIO */

#define LOG(l, x)

#define DBG(x)

#endif

#ifdef __cplusplus

}

#endif /* __cplusplus */

#endif /* CS_COMMON_CS_DBG_H_ */

#ifdef MG_MODULE_LINES

#line 1 "common/cs_dbg.c"

#endif

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

/* 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" */

enum cs_log_level cs_log_threshold WEAK =

#if CS_ENABLE_DEBUG

LL_VERBOSE_DEBUG;

#else

LL_ERROR;

#endif

static char *s_filter_pattern = NULL;

static size_t s_filter_pattern_len;

#if CS_ENABLE_STDIO

FILE *cs_log_file WEAK = NULL;

#if CS_LOG_ENABLE_TS_DIFF

double cs_log_ts WEAK;

#endif

enum cs_log_level cs_log_cur_msg_level WEAK = LL_NONE;

void cs_log_set_filter(const char *str) WEAK;

void cs_log_set_filter(const char *str) {

free(s_filter_pattern);

if (str != NULL) {

s_filter_pattern = strdup(str);

s_filter_pattern_len = strlen(str);

} else {

s_filter_pattern = NULL;

s_filter_pattern_len = 0;

}

}

int cs_log_print_prefix(enum cs_log_level, const char *, const char *) WEAK;

int cs_log_print_prefix(enum cs_log_level level, const char *func,

const char *filename) {

char prefix[21];

if (level > cs_log_threshold) return 0;

if (s_filter_pattern != NULL &&

mg_match_prefix(s_filter_pattern, s_filter_pattern_len, func) < 0 &&

mg_match_prefix(s_filter_pattern, s_filter_pattern_len, filename) < 0) {

return 0;

}

strncpy(prefix, func, 20);

prefix[20] = '\0';

if (cs_log_file == NULL) cs_log_file = stderr;

cs_log_cur_msg_level = level;

fprintf(cs_log_file, "%-20s ", prefix);

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

}

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;

}

void cs_log_set_file(FILE *file) WEAK;

void cs_log_set_file(FILE *file) {

cs_log_file = file;

}

#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_threshold = level;

#if CS_LOG_ENABLE_TS_DIFF && CS_ENABLE_STDIO

cs_log_ts = cs_time();

#endif

}

#ifdef MG_MODULE_LINES

#line 1 "common/cs_dirent.h"

#endif

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

#ifndef CS_COMMON_CS_DIRENT_H_

#define CS_COMMON_CS_DIRENT_H_

#include <limits.h>

/* Amalgamated: #include "common/platform.h" */

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

#ifdef CS_DEFINE_DIRENT

typedef struct { int dummy; } DIR;

struct dirent {

int d_ino;

#ifdef _WIN32

char d_name[MAX_PATH];

#else

/* TODO(rojer): Use PATH_MAX but make sure it's sane on every platform */

char d_name[256];

#endif

};

DIR *opendir(const char *dir_name);

int closedir(DIR *dir);

struct dirent *readdir(DIR *dir);

#endif /* CS_DEFINE_DIRENT */

#ifdef __cplusplus

}

#endif /* __cplusplus */

#endif /* CS_COMMON_CS_DIRENT_H_ */

#ifdef MG_MODULE_LINES

#line 1 "common/cs_dirent.c"

#endif

/*

* Copyright (c) 2015 Cesanta Software Limited

* All rights reserved

*/

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

HANDLE handle;

WIN32_FIND_DATAW info;

struct dirent result;

};

DIR *opendir(const char *name) {

struct win32_dir *dir = 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) {

SetLastError(ERROR_NOT_ENOUGH_MEMORY);

} else {

to_wchar(name, wpath, ARRAY_SIZE(wpath));

attrs = GetFileAttributesW(wpath);

if (attrs != 0xFFFFFFFF && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {

(void) wcscat(wpath, L"\\*");

dir->handle = FindFirstFileW(wpath, &dir->info);

dir->result.d_name[0] = '\0';

} else {

MG_FREE(dir);

dir = NULL;

}

}

return (DIR *) dir;

}

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

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

}

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

#endif

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

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

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

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