#include "mongoose.h"

#ifdef NS_MODULE_LINES

#line 1 "src/internal.h"

/**/

#endif

/*

* Copyright (c) 2014 Cesanta Software Limited

* All rights reserved

*/

#ifndef MG_INTERNAL_HEADER_INCLUDED

#define MG_INTERNAL_HEADER_INCLUDED

#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

#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

#if !defined(MG_MGR_EV_MGR)

/*

* Switches between different methods of handling sockets. Supported values:

* 0 - select()

* 1 - epoll() (Linux only)

*/

#define MG_MGR_EV_MGR 0 /* select() */

#endif

#ifdef PICOTCP

#define NO_LIBC

#define MG_DISABLE_FILESYSTEM

#define MG_DISABLE_POPEN

#define MG_DISABLE_CGI

#define MG_DISABLE_DIRECTORY_LISTING

#define MG_DISABLE_SOCKETPAIR

#define MG_DISABLE_PFS

#endif

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

/* 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, int ev, void *ev_data);

MG_INTERNAL void mg_forward(struct mg_connection *, struct mg_connection *);

MG_INTERNAL void mg_add_conn(struct mg_mgr *mgr, struct mg_connection *c);

MG_INTERNAL void mg_remove_conn(struct mg_connection *c);

#ifndef MG_DISABLE_FILESYSTEM

MG_INTERNAL int find_index_file(char *, size_t, const char *, cs_stat_t *);

#endif

#ifdef _WIN32

void to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len);

#endif

/*

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

#ifndef MG_DISABLE_FILESYSTEM

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

/* Forward declarations for testing. */

extern void *(*test_malloc)(size_t);

extern void *(*test_calloc)(size_t, size_t);

#endif /* MG_INTERNAL_HEADER_INCLUDED */

#ifdef NS_MODULE_LINES

#line 1 "src/../../common/base64.c"

/**/

#endif

/*

* Copyright (c) 2014 Cesanta Software Limited

* All rights reserved

*/

#ifndef EXCLUDE_COMMON

/* Amalgamated: #include "base64.h" */

#include <string.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

#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

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

unsigned char a, b, c, d;

int orig_len = len;

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;

return orig_len - len;

}

#endif /* EXCLUDE_COMMON */

#ifdef NS_MODULE_LINES

#line 1 "src/../../common/cs_dbg.c"

/**/

#endif

/* Amalgamated: #include "cs_dbg.h" */

#include <stdarg.h>

#include <stdio.h>

enum cs_log_level s_cs_log_level =

#ifdef CS_ENABLE_DEBUG

LL_DEBUG;

#else

LL_ERROR;

#endif

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

va_list ap;

va_start(ap, fmt);

vfprintf(stderr, fmt, ap);

va_end(ap);

fputc('\n', stderr);

fflush(stderr);

}

void cs_log_set_level(enum cs_log_level level) {

s_cs_log_level = level;

}

#ifdef NS_MODULE_LINES

#line 1 "src/../../common/dirent.c"

/**/

#endif

/*

* Copyright (c) 2015 Cesanta Software Limited

* All rights reserved

*/

#ifndef EXCLUDE_COMMON

/* Amalgamated: #include "osdep.h" */

/*

* This file contains POSIX opendir/closedir/readdir API implementation

* for systems which do not natively support it (e.g. Windows).

*/

#ifndef MG_FREE

#define MG_FREE free

#endif

#ifndef MG_MALLOC

#define MG_MALLOC malloc

#endif

#ifdef _WIN32

DIR *opendir(const char *name) {

DIR *dir = NULL;

wchar_t wpath[MAX_PATH];

DWORD attrs;

if (name == NULL) {

SetLastError(ERROR_BAD_ARGUMENTS);

} else if ((dir = (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;

}

int closedir(DIR *dir) {

int result = 0;

if (dir != NULL) {

if (dir->handle != INVALID_HANDLE_VALUE)

result = FindClose(dir->handle) ? 0 : -1;

MG_FREE(dir);

} else {

result = -1;

SetLastError(ERROR_BAD_ARGUMENTS);

}

return result;

}

struct dirent *readdir(DIR *dir) {

struct dirent *result = 0;

if (dir) {

if (dir->handle != INVALID_HANDLE_VALUE) {

result = &dir->result;

(void) WideCharToMultiByte(CP_UTF8, 0, dir->info.cFileName, -1,

result->d_name, sizeof(result->d_name), NULL,

NULL);

if (!FindNextFileW(dir->handle, &dir->info)) {

(void) FindClose(dir->handle);

dir->handle = INVALID_HANDLE_VALUE;

}

} else {

SetLastError(ERROR_FILE_NOT_FOUND);

}

} else {

SetLastError(ERROR_BAD_ARGUMENTS);

}

return result;

}

#endif

#endif /* EXCLUDE_COMMON */

#ifdef NS_MODULE_LINES

#line 1 "src/../deps/frozen/frozen.c"

/**/

#endif

/*

* Copyright (c) 2004-2013 Sergey Lyubka <valenok@gmail.com>

* Copyright (c) 2013 Cesanta Software Limited

* All rights reserved

*

* This library 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 library 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 library under a commercial

* license, as set out in <https://www.cesanta.com/license>.

*/

#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005+ */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

/* Amalgamated: #include "frozen.h" */

#ifdef _WIN32

#define snprintf _snprintf

#endif

#ifndef FROZEN_REALLOC

#define FROZEN_REALLOC realloc

#endif

#ifndef FROZEN_FREE

#define FROZEN_FREE free

#endif

struct frozen {

const char *end;

const char *cur;

struct json_token *tokens;

int max_tokens;

int num_tokens;

int do_realloc;

};

static int parse_object(struct frozen *f);

static int parse_value(struct frozen *f);

#define EXPECT(cond, err_code) do { if (!(cond)) return (err_code); } while (0)

#define TRY(expr) do { int _n = expr; if (_n < 0) return _n; } while (0)

#define END_OF_STRING (-1)

static int left(const struct frozen *f) {

return f->end - f->cur;

}

static int is_space(int ch) {

return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';

}

static void skip_whitespaces(struct frozen *f) {

while (f->cur < f->end && is_space(*f->cur)) f->cur++;

}

static int cur(struct frozen *f) {

skip_whitespaces(f);

return f->cur >= f->end ? END_OF_STRING : * (unsigned char *) f->cur;

}

static int test_and_skip(struct frozen *f, int expected) {

int ch = cur(f);

if (ch == expected) { f->cur++; return 0; }

return ch == END_OF_STRING ? JSON_STRING_INCOMPLETE : JSON_STRING_INVALID;

}

static int is_alpha(int ch) {

return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');

}

static int is_digit(int ch) {

return ch >= '0' && ch <= '9';

}

static int is_hex_digit(int ch) {

return is_digit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');

}

static int get_escape_len(const char *s, int len) {

switch (*s) {

case 'u':

return len < 6 ? JSON_STRING_INCOMPLETE :

is_hex_digit(s[1]) && is_hex_digit(s[2]) &&

is_hex_digit(s[3]) && is_hex_digit(s[4]) ? 5 : JSON_STRING_INVALID;

case '"': case '\\': case '/': case 'b':

case 'f': case 'n': case 'r': case 't':

return len < 2 ? JSON_STRING_INCOMPLETE : 1;

default:

return JSON_STRING_INVALID;

}

}

static int capture_ptr(struct frozen *f, const char *ptr, enum json_type type) {

if (f->do_realloc && f->num_tokens >= f->max_tokens) {

int new_size = f->max_tokens == 0 ? 100 : f->max_tokens * 2;

void *p = FROZEN_REALLOC(f->tokens, new_size * sizeof(f->tokens[0]));

if (p == NULL) return JSON_TOKEN_ARRAY_TOO_SMALL;

f->max_tokens = new_size;

f->tokens = (struct json_token *) p;

}

if (f->tokens == NULL || f->max_tokens == 0) return 0;

if (f->num_tokens >= f->max_tokens) return JSON_TOKEN_ARRAY_TOO_SMALL;

f->tokens[f->num_tokens].ptr = ptr;

f->tokens[f->num_tokens].type = type;

f->num_tokens++;

return 0;

}

static int capture_len(struct frozen *f, int token_index, const char *ptr) {

if (f->tokens == 0 || f->max_tokens == 0) return 0;

EXPECT(token_index >= 0 && token_index < f->max_tokens, JSON_STRING_INVALID);

f->tokens[token_index].len = ptr - f->tokens[token_index].ptr;

f->tokens[token_index].num_desc = (f->num_tokens - 1) - token_index;

return 0;

}

/* identifier = letter { letter | digit | '_' } */

static int parse_identifier(struct frozen *f) {

EXPECT(is_alpha(cur(f)), JSON_STRING_INVALID);

TRY(capture_ptr(f, f->cur, JSON_TYPE_STRING));

while (f->cur < f->end &&

(*f->cur == '_' || is_alpha(*f->cur) || is_digit(*f->cur))) {

f->cur++;

}

capture_len(f, f->num_tokens - 1, f->cur);

return 0;

}

static int get_utf8_char_len(unsigned char ch) {

if ((ch & 0x80) == 0) return 1;

switch (ch & 0xf0) {

case 0xf0: return 4;

case 0xe0: return 3;

default: return 2;

}

}

/* string = '"' { quoted_printable_chars } '"' */

static int parse_string(struct frozen *f) {

int n, ch = 0, len = 0;

TRY(test_and_skip(f, '"'));

TRY(capture_ptr(f, f->cur, JSON_TYPE_STRING));

for (; f->cur < f->end; f->cur += len) {

ch = * (unsigned char *) f->cur;

len = get_utf8_char_len((unsigned char) ch);

EXPECT(ch >= 32 && len > 0, JSON_STRING_INVALID); /* No control chars */

EXPECT(len < left(f), JSON_STRING_INCOMPLETE);

if (ch == '\\') {

EXPECT((n = get_escape_len(f->cur + 1, left(f))) > 0, n);

len += n;

} else if (ch == '"') {

capture_len(f, f->num_tokens - 1, f->cur);

f->cur++;

break;

};

}

return ch == '"' ? 0 : JSON_STRING_INCOMPLETE;

}

/* number = [ '-' ] digit+ [ '.' digit+ ] [ ['e'|'E'] ['+'|'-'] digit+ ] */

static int parse_number(struct frozen *f) {

int ch = cur(f);

TRY(capture_ptr(f, f->cur, JSON_TYPE_NUMBER));

if (ch == '-') f->cur++;

EXPECT(f->cur < f->end, JSON_STRING_INCOMPLETE);

EXPECT(is_digit(f->cur[0]), JSON_STRING_INVALID);

while (f->cur < f->end && is_digit(f->cur[0])) f->cur++;

if (f->cur < f->end && f->cur[0] == '.') {

f->cur++;

EXPECT(f->cur < f->end, JSON_STRING_INCOMPLETE);

EXPECT(is_digit(f->cur[0]), JSON_STRING_INVALID);

while (f->cur < f->end && is_digit(f->cur[0])) f->cur++;

}

if (f->cur < f->end && (f->cur[0] == 'e' || f->cur[0] == 'E')) {

f->cur++;

EXPECT(f->cur < f->end, JSON_STRING_INCOMPLETE);

if ((f->cur[0] == '+' || f->cur[0] == '-')) f->cur++;

EXPECT(f->cur < f->end, JSON_STRING_INCOMPLETE);

EXPECT(is_digit(f->cur[0]), JSON_STRING_INVALID);

while (f->cur < f->end && is_digit(f->cur[0])) f->cur++;

}

capture_len(f, f->num_tokens - 1, f->cur);

return 0;

}

/* array = '[' [ value { ',' value } ] ']' */

static int parse_array(struct frozen *f) {

int ind;

TRY(test_and_skip(f, '['));

TRY(capture_ptr(f, f->cur - 1, JSON_TYPE_ARRAY));

ind = f->num_tokens - 1;

while (cur(f) != ']') {

TRY(parse_value(f));

if (cur(f) == ',') f->cur++;

}

TRY(test_and_skip(f, ']'));

capture_len(f, ind, f->cur);

return 0;

}

static int compare(const char *s, const char *str, int len) {

int i = 0;

while (i < len && s[i] == str[i]) i++;

return i == len ? 1 : 0;

}

static int expect(struct frozen *f, const char *s, int len, enum json_type t) {

int i, n = left(f);

TRY(capture_ptr(f, f->cur, t));

for (i = 0; i < len; i++) {

if (i >= n) return JSON_STRING_INCOMPLETE;

if (f->cur[i] != s[i]) return JSON_STRING_INVALID;

}

f->cur += len;

TRY(capture_len(f, f->num_tokens - 1, f->cur));

return 0;

}

/* value = 'null' | 'true' | 'false' | number | string | array | object */

static int parse_value(struct frozen *f) {

int ch = cur(f);

switch (ch) {

case '"': TRY(parse_string(f)); break;

case '{': TRY(parse_object(f)); break;

case '[': TRY(parse_array(f)); break;

case 'n': TRY(expect(f, "null", 4, JSON_TYPE_NULL)); break;

case 't': TRY(expect(f, "true", 4, JSON_TYPE_TRUE)); break;

case 'f': TRY(expect(f, "false", 5, JSON_TYPE_FALSE)); break;

case '-': case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

TRY(parse_number(f));

break;

default:

return ch == END_OF_STRING ? JSON_STRING_INCOMPLETE : JSON_STRING_INVALID;

}

return 0;

}

/* key = identifier | string */

static int parse_key(struct frozen *f) {

int ch = cur(f);

#if 0

printf("%s 1 [%.*s]\n", __func__, (int) (f->end - f->cur), f->cur);

#endif

if (is_alpha(ch)) {

TRY(parse_identifier(f));

} else if (ch == '"') {

TRY(parse_string(f));

} else {

return ch == END_OF_STRING ? JSON_STRING_INCOMPLETE : JSON_STRING_INVALID;

}

return 0;

}

/* pair = key ':' value */

static int parse_pair(struct frozen *f) {

TRY(parse_key(f));

TRY(test_and_skip(f, ':'));

TRY(parse_value(f));

return 0;

}

/* object = '{' pair { ',' pair } '}' */

static int parse_object(struct frozen *f) {

int ind;

TRY(test_and_skip(f, '{'));

TRY(capture_ptr(f, f->cur - 1, JSON_TYPE_OBJECT));

ind = f->num_tokens - 1;

while (cur(f) != '}') {

TRY(parse_pair(f));

if (cur(f) == ',') f->cur++;

}

TRY(test_and_skip(f, '}'));

capture_len(f, ind, f->cur);

return 0;

}

static int doit(struct frozen *f) {

if (f->cur == 0 || f->end < f->cur) return JSON_STRING_INVALID;

if (f->end == f->cur) return JSON_STRING_INCOMPLETE;

TRY(parse_object(f));

TRY(capture_ptr(f, f->cur, JSON_TYPE_EOF));

capture_len(f, f->num_tokens, f->cur);

return 0;

}

/* json = object */

int parse_json(const char *s, int s_len, struct json_token *arr, int arr_len) {

struct frozen frozen;

memset(&frozen, 0, sizeof(frozen));

frozen.end = s + s_len;

frozen.cur = s;

frozen.tokens = arr;

frozen.max_tokens = arr_len;

TRY(doit(&frozen));

return frozen.cur - s;

}

struct json_token *parse_json2(const char *s, int s_len) {

struct frozen frozen;

memset(&frozen, 0, sizeof(frozen));

frozen.end = s + s_len;

frozen.cur = s;

frozen.do_realloc = 1;

if (doit(&frozen) < 0) {

FROZEN_FREE((void *) frozen.tokens);

frozen.tokens = NULL;

}

return frozen.tokens;

}

static int path_part_len(const char *p) {

int i = 0;

while (p[i] != '\0' && p[i] != '[' && p[i] != '.') i++;

return i;

}

struct json_token *find_json_token(struct json_token *toks, const char *path) {

while (path != 0 && path[0] != '\0') {

int i, ind2 = 0, ind = -1, skip = 2, n = path_part_len(path);

if (path[0] == '[') {

if (toks->type != JSON_TYPE_ARRAY || !is_digit(path[1])) return 0;

for (ind = 0, n = 1; path[n] != ']' && path[n] != '\0'; n++) {

if (!is_digit(path[n])) return 0;

ind *= 10;

ind += path[n] - '0';

}

if (path[n++] != ']') return 0;

skip = 1; /* In objects, we skip 2 elems while iterating, in arrays 1. */

} else if (toks->type != JSON_TYPE_OBJECT) return 0;

toks++;

for (i = 0; i < toks[-1].num_desc; i += skip, ind2++) {

/* ind == -1 indicated that we're iterating an array, not object */

if (ind == -1 && toks[i].type != JSON_TYPE_STRING) return 0;

if (ind2 == ind ||

(ind == -1 && toks[i].len == n && compare(path, toks[i].ptr, n))) {

i += skip - 1;

break;

};

if (toks[i - 1 + skip].type == JSON_TYPE_ARRAY ||

toks[i - 1 + skip].type == JSON_TYPE_OBJECT) {

i += toks[i - 1 + skip].num_desc;

}

}

if (i == toks[-1].num_desc) return 0;

path += n;

if (path[0] == '.') path++;

if (path[0] == '\0') return &toks[i];

toks += i;

}

return 0;

}

int json_emit_long(char *buf, int buf_len, long int value) {

char tmp[20];

int n = snprintf(tmp, sizeof(tmp), "%ld", value);

strncpy(buf, tmp, buf_len > 0 ? buf_len : 0);

return n;

}

int json_emit_double(char *buf, int buf_len, double value) {

char tmp[20];

int n = snprintf(tmp, sizeof(tmp), "%g", value);

strncpy(buf, tmp, buf_len > 0 ? buf_len : 0);

return n;

}

int json_emit_quoted_str(char *s, int s_len, const char *str, int len) {

const char *begin = s, *end = s + s_len, *str_end = str + len;

char ch;

#define EMIT(x) do { if (s < end) *s = x; s++; } while (0)

EMIT('"');

while (str < str_end) {

ch = *str++;

switch (ch) {

case '"': EMIT('\\'); EMIT('"'); break;

case '\\': EMIT('\\'); EMIT('\\'); break;

case '\b': EMIT('\\'); EMIT('b'); break;

case '\f': EMIT('\\'); EMIT('f'); break;

case '\n': EMIT('\\'); EMIT('n'); break;

case '\r': EMIT('\\'); EMIT('r'); break;

case '\t': EMIT('\\'); EMIT('t'); break;

default: EMIT(ch);

}

}

EMIT('"');

if (s < end) {

*s = '\0';

}

return s - begin;

}

int json_emit_unquoted_str(char *buf, int buf_len, const char *str, int len) {

if (buf_len > 0 && len > 0) {

int n = len < buf_len ? len : buf_len;

memcpy(buf, str, n);

if (n < buf_len) {

buf[n] = '\0';

}

}

return len;

}

int json_emit_va(char *s, int s_len, const char *fmt, va_list ap) {

const char *end = s + s_len, *str, *orig = s;

size_t len;

while (*fmt != '\0') {

switch (*fmt) {

case '[': case ']': case '{': case '}': case ',': case ':':

case ' ': case '\r': case '\n': case '\t':

if (s < end) {

*s = *fmt;

}

s++;

break;

case 'i':

s += json_emit_long(s, end - s, va_arg(ap, long));

break;

case 'f':

s += json_emit_double(s, end - s, va_arg(ap, double));

break;

case 'v':

str = va_arg(ap, char *);

len = va_arg(ap, size_t);

s += json_emit_quoted_str(s, end - s, str, len);

break;

case 'V':

str = va_arg(ap, char *);

len = va_arg(ap, size_t);

s += json_emit_unquoted_str(s, end - s, str, len);

break;

case 's':

str = va_arg(ap, char *);

s += json_emit_quoted_str(s, end - s, str, strlen(str));

break;

case 'S':

str = va_arg(ap, char *);

s += json_emit_unquoted_str(s, end - s, str, strlen(str));

break;

case 'T':

s += json_emit_unquoted_str(s, end - s, "true", 4);

break;

case 'F':

s += json_emit_unquoted_str(s, end - s, "false", 5);

break;

case 'N':

s += json_emit_unquoted_str(s, end - s, "null", 4);

break;

default:

return 0;

}

fmt++;

}

/* Best-effort to 0-terminate generated string */

if (s < end) {

*s = '\0';

}

return s - orig;

}

int json_emit(char *buf, int buf_len, const char *fmt, ...) {

int len;

va_list ap;

va_start(ap, fmt);

len = json_emit_va(buf, buf_len, fmt, ap);

va_end(ap);

return len;

}

#ifdef NS_MODULE_LINES

#line 1 "src/../../common/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.

*/

#if !defined(DISABLE_MD5) && !defined(EXCLUDE_COMMON)

/* Amalgamated: #include "md5.h" */

#ifndef CS_ENABLE_NATIVE_MD5

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 MD5_Init(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;

}