#include "mongoose.h"

#ifdef MG_MODULE_LINES

#line 0 "./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/src/net.h" */

/* Amalgamated: #include "mongoose/src/http.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, 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);

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

#endif

#ifdef _WIN32

/* Retur value is the same as for MultiByteToWideChar. */

int 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

struct ctl_msg {

mg_event_handler_t callback;

char message[MG_CTL_MSG_MESSAGE_SIZE];

};

/* Forward declarations for testing. */

extern void *(*test_malloc)(size_t size);

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

#endif /* MG_INTERNAL_HEADER_INCLUDED */

#ifdef MG_MODULE_LINES

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

#endif

/*

* Copyright (c) 2014 Cesanta Software Limited

* All rights reserved

*/

#ifndef EXCLUDE_COMMON

/* Amalgamated: #include "common/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

#ifndef CS_DISABLE_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_DISABLE_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) {

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 MG_MODULE_LINES

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

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

enum cs_log_level s_cs_log_level =

#ifdef CS_ENABLE_DEBUG

LL_VERBOSE_DEBUG;

#else

LL_ERROR;

#endif

#ifdef CS_LOG_TS_DIFF

double cs_log_ts;

#endif

#ifndef CS_DISABLE_STDIO

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

va_list ap;

#ifdef CS_LOG_TS_DIFF

double now = cs_time();

fprintf(stderr, "%7u ", (unsigned int) ((now - cs_log_ts) * 1000000));

#endif

va_start(ap, fmt);

vfprintf(stderr, fmt, ap);

va_end(ap);

fputc('\n', stderr);

#ifdef CS_LOG_TS_DIFF

cs_log_ts = now;

#endif

fflush(stderr);

}

#endif /* !CS_DISABLE_STDIO */

void cs_log_set_level(enum cs_log_level level) {

s_cs_log_level = level;

#ifdef CS_LOG_TS_DIFF

cs_log_ts = cs_time();

#endif

}

#ifdef MG_MODULE_LINES

#line 0 "./src/../../common/cs_dirent.c"

#endif

/*

* Copyright (c) 2015 Cesanta Software Limited

* All rights reserved

*/

#ifndef EXCLUDE_COMMON

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

*/

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

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

#ifdef CS_ENABLE_SPIFFS

DIR *opendir(const char *dir_name) {

DIR *dir = NULL;

extern spiffs fs;

if (dir_name != NULL && (dir = (DIR *) malloc(sizeof(*dir))) != NULL &&

SPIFFS_opendir(&fs, (char *) dir_name, &dir->dh) == NULL) {

free(dir);

dir = NULL;

}

return dir;

}

int closedir(DIR *dir) {

if (dir != NULL) {

SPIFFS_closedir(&dir->dh);

free(dir);

}

return 0;

}

struct dirent *readdir(DIR *dir) {

return SPIFFS_readdir(&dir->dh, &dir->de);

}

/* SPIFFs doesn't support directory operations */

int rmdir(const char *path) {

(void) path;

return ENOTDIR;

}

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;

}

#endif /* CS_ENABLE_SPIFFS */

#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 0 "./src/../../common/cs_time.c"

#endif

/*

* Copyright (c) 2014-2016 Cesanta Software Limited

* All rights reserved

*/

#ifndef _WIN32

#include <stddef.h>

#ifndef MG_CC3200

#include <sys/time.h>

#endif

#else

#include <windows.h>

#endif

double cs_time() {

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

now = GetTickCount() / 1000.0;

#endif

return now;

}

#ifdef MG_MODULE_LINES

#line 0 "./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 <http://cesanta.com/products.html>.

*/

#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 test_no_skip(struct frozen *f, int expected) {

int ch = cur(f);

if (ch == expected) {

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

int ret = 0;

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

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

if (0 == (ret = test_no_skip(f, '{'))) {

TRY(parse_object(f));

} else if (0 == (ret = test_no_skip(f, '['))) {

TRY(parse_array(f));

} else {

return ret;

}

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;