#include <string.h>

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <float.h>

#include <limits.h>

#include <ctype.h>

#include "cJSON.h"

typedef int cjbool;

#define true ((cjbool)1)

#define false ((cjbool)0)

static const unsigned char *global_ep = NULL;

CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)

{

return (const char*) global_ep;

}

#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 3) || (CJSON_VERSION_PATCH != 0)

#error cJSON.h and cJSON.c have different versions. Make sure that both have the same.

CJSON_PUBLIC(const char*) cJSON_Version(void)

{

static char version[15];

sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);

return version;

}

static int cJSON_strcasecmp(const unsigned char *s1, const unsigned char *s2)

{

if (!s1)

{

return (s1 == s2) ? 0 : 1; /* both NULL? */

}

if (!s2)

{

return 1;

}

for(; tolower(*s1) == tolower(*s2); ++s1, ++s2)

{

if (*s1 == '\0')

{

return 0;

}

}

return tolower(*s1) - tolower(*s2);

}

typedef struct internal_hooks

} internal_hooks;

static internal_hooks global_hooks = { malloc, free, realloc };

static unsigned char* cJSON_strdup(const unsigned char* str, const internal_hooks * const hooks)

{

size_t len = 0;

unsigned char *copy = NULL;

if (str == NULL)

{

return NULL;

}

len = strlen((const char*)str) + 1;

if (!(copy = (unsigned char*)hooks->allocate(len)))

{

return NULL;

}

memcpy(copy, str, len);

return copy;

}

CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)

{

if (hooks == NULL)

{

/* Reset hooks */

global_hooks.allocate = malloc;

global_hooks.deallocate = free;

global_hooks.reallocate = realloc;

return;

}

global_hooks.allocate = malloc;

if (hooks->malloc_fn != NULL)

{

global_hooks.allocate = hooks->malloc_fn;

}

global_hooks.deallocate = free;

if (hooks->free_fn != NULL)

{

global_hooks.deallocate = hooks->free_fn;

}

/* use realloc only if both free and malloc are used */

global_hooks.reallocate = NULL;

if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))

{

global_hooks.reallocate = realloc;

}

}

static cJSON *cJSON_New_Item(const internal_hooks * const hooks)

{

cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));

if (node)

{

memset(node, '\0', sizeof(cJSON));

}

return node;

}

CJSON_PUBLIC(void) cJSON_Delete(cJSON *c)

{

cJSON *next = NULL;

while (c)

{

next = c->next;

if (!(c->type & cJSON_IsReference) && c->child)

{

cJSON_Delete(c->child);

}

if (!(c->type & cJSON_IsReference) && c->valuestring)

{

global_hooks.deallocate(c->valuestring);

}

if (!(c->type & cJSON_StringIsConst) && c->string)

{

global_hooks.deallocate(c->string);

}

global_hooks.deallocate(c);

c = next;

}

}

static const unsigned char *parse_number(cJSON * const item, const unsigned char * const input)

{

double number = 0;

unsigned char *after_end = NULL;

if (input == NULL)

{

return NULL;

}

number = strtod((const char*)input, (char**)&after_end);

if (input == after_end)

{

return NULL; /* parse_error */

}

item->valuedouble = number;

/* use saturation in case of overflow */

if (number >= INT_MAX)

{

item->valueint = INT_MAX;

}

else if (number <= INT_MIN)

{

item->valueint = INT_MIN;

}

else

{

item->valueint = (int)number;

}

item->type = cJSON_Number;

return after_end;

}

CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)

{

if (number >= INT_MAX)

{

object->valueint = INT_MAX;

}

else if (number <= INT_MIN)

{

object->valueint = INT_MIN;

}

else

{

object->valueint = cJSON_Number;

}

return object->valuedouble = number;

}

typedef struct

{

unsigned char *buffer;

size_t length;

size_t offset;

cjbool noalloc;

} printbuffer;

static unsigned char* ensure(printbuffer * const p, size_t needed, const internal_hooks * const hooks)

{

unsigned char *newbuffer = NULL;

size_t newsize = 0;

if ((p == NULL) || (p->buffer == NULL))

{

return NULL;

}

if (needed > INT_MAX)

{

/* sizes bigger than INT_MAX are currently not supported */

return NULL;

}

needed += p->offset;

if (needed <= p->length)

{

return p->buffer + p->offset;

}

if (p->noalloc) {

return NULL;

}

/* calculate new buffer size */

newsize = needed * 2;

if (newsize > INT_MAX)

{

/* overflow of int, use INT_MAX if possible */

if (needed <= INT_MAX)

{

newsize = INT_MAX;

}

else

{

return NULL;

}

}

if (hooks->reallocate != NULL)

{

/* reallocate with realloc if available */

newbuffer = (unsigned char*)hooks->reallocate(p->buffer, newsize);

}

else

{

/* otherwise reallocate manually */

newbuffer = (unsigned char*)hooks->allocate(newsize);

if (!newbuffer)

{

hooks->deallocate(p->buffer);

p->length = 0;

p->buffer = NULL;

return NULL;

}

if (newbuffer)

{

memcpy(newbuffer, p->buffer, p->offset + 1);

}

hooks->deallocate(p->buffer);

}

p->length = newsize;

p->buffer = newbuffer;

return newbuffer + p->offset;

}

static void update_offset(printbuffer * const buffer)

{

const unsigned char *buffer_pointer = NULL;

if ((buffer == NULL) || (buffer->buffer == NULL))

{

return;

}

buffer_pointer = buffer->buffer + buffer->offset;

buffer->offset += strlen((const char*)buffer_pointer);

}

static unsigned char *print_number(const cJSON * const item, printbuffer * const output_buffer, const internal_hooks * const hooks)

{

unsigned char *output_pointer = NULL;

double d = item->valuedouble;

if (output_buffer == NULL)

{

return NULL;

}

/* value is an int */

if ((fabs(((double)item->valueint) - d) <= DBL_EPSILON) && (d <= INT_MAX) && (d >= INT_MIN))

{

/* 2^64+1 can be represented in 21 chars. */

output_pointer = ensure(output_buffer, 21, hooks);

if (output_pointer != NULL)

{

sprintf((char*)output_pointer, "%d", item->valueint);

}

}

/* value is a floating point number */

else

{

/* This is a nice tradeoff. */

output_pointer = ensure(output_buffer, 64, hooks);

if (output_pointer != NULL)

{

/* This checks for NaN and Infinity */

if ((d * 0) != 0)

{

sprintf((char*)output_pointer, "null");

}

else if ((fabs(floor(d) - d) <= DBL_EPSILON) && (fabs(d) < 1.0e60))

{

sprintf((char*)output_pointer, "%.0f", d);

}

else if ((fabs(d) < 1.0e-6) || (fabs(d) > 1.0e9))

{

sprintf((char*)output_pointer, "%e", d);

}

else

{

sprintf((char*)output_pointer, "%f", d);

}

}

}

return output_pointer;

}

static unsigned parse_hex4(const unsigned char * const input)

{

unsigned int h = 0;

size_t i = 0;

for (i = 0; i < 4; i++)

{

/* parse digit */

if ((input[i] >= '0') && (input[i] <= '9'))

{

h += (unsigned int) input[i] - '0';

}

else if ((input[i] >= 'A') && (input[i] <= 'F'))

{

h += (unsigned int) 10 + input[i] - 'A';

}

else if ((input[i] >= 'a') && (input[i] <= 'f'))

{

h += (unsigned int) 10 + input[i] - 'a';

}

else /* invalid */

{

return 0;

}

if (i < 3)

{

/* shift left to make place for the next nibble */

h = h << 4;

}

}

return h;

}

static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer, const unsigned char **error_pointer)

{

/* first bytes of UTF8 encoding for a given length in bytes */

static const unsigned char firstByteMark[5] =

{

0x00, /* should never happen */

0x00, /* 0xxxxxxx */

0xC0, /* 110xxxxx */

0xE0, /* 1110xxxx */

0xF0 /* 11110xxx */

};

long unsigned int codepoint = 0;

unsigned int first_code = 0;

const unsigned char *first_sequence = input_pointer;

unsigned char utf8_length = 0;

unsigned char sequence_length = 0;

/* get the first utf16 sequence */

first_code = parse_hex4(first_sequence + 2);

if ((input_end - first_sequence) < 6)

{

/* input ends unexpectedly */

*error_pointer = first_sequence;

goto fail;

}

/* check that the code is valid */

if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)) || (first_code == 0))

{

*error_pointer = first_sequence;

goto fail;

}

/* UTF16 surrogate pair */

if ((first_code >= 0xD800) && (first_code <= 0xDBFF))

{

const unsigned char *second_sequence = first_sequence + 6;

unsigned int second_code = 0;

sequence_length = 12; /* \uXXXX\uXXXX */

if ((input_end - second_sequence) < 6)

{

/* input ends unexpectedly */

*error_pointer = first_sequence;

goto fail;

}

if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))

{

/* missing second half of the surrogate pair */

*error_pointer = first_sequence;

goto fail;

}

/* get the second utf16 sequence */

second_code = parse_hex4(second_sequence + 2);

/* check that the code is valid */

if ((second_code < 0xDC00) || (second_code > 0xDFFF))

{

/* invalid second half of the surrogate pair */

*error_pointer = first_sequence;

goto fail;

}

/* calculate the unicode codepoint from the surrogate pair */

codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));

}

else

{

sequence_length = 6; /* \uXXXX */

codepoint = first_code;

}

/* encode as UTF-8

if (codepoint < 0x80)

{

/* normal ascii, encoding 0xxxxxxx */

utf8_length = 1;

}

else if (codepoint < 0x800)

{

/* two bytes, encoding 110xxxxx 10xxxxxx */

utf8_length = 2;

}

else if (codepoint < 0x10000)

{

/* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */

utf8_length = 3;

}

else if (codepoint <= 0x10FFFF)

{

/* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */

utf8_length = 4;

}

else

{

/* invalid unicode codepoint */

*error_pointer = first_sequence;

goto fail;

}

/* encode as utf8 */

switch (utf8_length)

{

case 4:

/* 10xxxxxx */

(*output_pointer)[3] = (unsigned char)((codepoint | 0x80) & 0xBF);

codepoint >>= 6;

case 3:

/* 10xxxxxx */

(*output_pointer)[2] = (unsigned char)((codepoint | 0x80) & 0xBF);

codepoint >>= 6;

case 2:

(*output_pointer)[1] = (unsigned char)((codepoint | 0x80) & 0xBF);

codepoint >>= 6;

case 1:

/* depending on the length in bytes this determines the

(*output_pointer)[0] = (unsigned char)((codepoint | firstByteMark[utf8_length]) & 0xFF);

break;

default:

*error_pointer = first_sequence;

goto fail;

}

*output_pointer += utf8_length;

return sequence_length;

fail:

return 0;

}

static const unsigned char *parse_string(cJSON * const item, const unsigned char * const input, const unsigned char ** const error_pointer, const internal_hooks * const hooks)

{

const unsigned char *input_pointer = input + 1;

const unsigned char *input_end = input + 1;

unsigned char *output_pointer = NULL;

unsigned char *output = NULL;

/* not a string */

if (*input != '\"')

{

*error_pointer = input;

goto fail;

}

{

/* calculate approximate size of the output (overestimate) */

size_t allocation_length = 0;

size_t skipped_bytes = 0;

while ((*input_end != '\"') && (*input_end != '\0'))

{

/* is escape sequence */

if (input_end[0] == '\\')

{

if (input_end[1] == '\0')

{

/* prevent buffer overflow when last input character is a backslash */

goto fail;

}

skipped_bytes++;

input_end++;

}

input_end++;

}

if (*input_end == '\0')

{

goto fail; /* string ended unexpectedly */

}

/* This is at most how much we need for the output */

allocation_length = (size_t) (input_end - input) - skipped_bytes;

output = (unsigned char*)hooks->allocate(allocation_length + sizeof('\0'));

if (output == NULL)

{

goto fail; /* allocation failure */

}

}

output_pointer = output;

/* loop through the string literal */

while (input_pointer < input_end)

{

if (*input_pointer != '\\')

{

*output_pointer++ = *input_pointer++;

}

/* escape sequence */

else

{

unsigned char sequence_length = 2;

switch (input_pointer[1])

{

case 'b':

*output_pointer++ = '\b';

break;

case 'f':

*output_pointer++ = '\f';

break;

case 'n':

*output_pointer++ = '\n';

break;

case 'r':

*output_pointer++ = '\r';

break;

case 't':

*output_pointer++ = '\t';

break;

case '\"':

case '\\':

case '/':

*output_pointer++ = input_pointer[1];

break;

/* UTF-16 literal */

case 'u':

sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer, error_pointer);

if (sequence_length == 0)

{

/* failed to convert UTF16-literal to UTF-8 */

goto fail;

}

break;

default:

*error_pointer = input_pointer;

goto fail;

}

input_pointer += sequence_length;

}

}

/* zero terminate the output */

*output_pointer = '\0';

item->type = cJSON_String;

item->valuestring = (char*)output;

return input_end + 1;

fail:

if (output != NULL)

{

hooks->deallocate(output);

}

return NULL;

}

static unsigned char *print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer, const internal_hooks * const hooks)

{

const unsigned char *input_pointer = NULL;

unsigned char *output = NULL;

unsigned char *output_pointer = NULL;

size_t output_length = 0;

/* numbers of additional characters needed for escaping */

size_t escape_characters = 0;

if (output_buffer == NULL)

{

return NULL;

}

/* empty string */

if (input == NULL)

{

output = ensure(output_buffer, sizeof("\"\""), hooks);

if (output == NULL)

{

return NULL;

}

strcpy((char*)output, "\"\"");

return output;

}

/* set "flag" to 1 if something needs to be escaped */

for (input_pointer = input; *input_pointer; input_pointer++)

{

if (strchr("\"\\\b\f\n\r\t", *input_pointer))

{

/* one character escape sequence */

escape_characters++;

}

else if (*input_pointer < 32)

{

/* UTF-16 escape sequence uXXXX */

escape_characters += 5;

}

}

output_length = (size_t)(input_pointer - input) + escape_characters;

output = ensure(output_buffer, output_length + sizeof("\"\""), hooks);

if (output == NULL)

{

return NULL;

}

/* no characters have to be escaped */

if (escape_characters == 0)

{

output[0] = '\"';

memcpy(output + 1, input, output_length);

output[output_length + 1] = '\"';

output[output_length + 2] = '\0';

return output;

}

output[0] = '\"';

output_pointer = output + 1;

/* copy the string */

for (input_pointer = input; *input_pointer != '\0'; input_pointer++, output_pointer++)

{

if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))

{

/* normal character, copy */

*output_pointer = *input_pointer;

}

else

{

/* character needs to be escaped */

*output_pointer++ = '\\';

switch (*input_pointer)

{

case '\\':

*output_pointer = '\\';

break;

case '\"':

*output_pointer = '\"';

break;

case '\b':

*output_pointer = 'b';

break;

case '\f':

*output_pointer = 'f';

break;

case '\n':

*output_pointer = 'n';

break;

case '\r':

*output_pointer = 'r';

break;

case '\t':

*output_pointer = 't';

break;

default:

/* escape and print as unicode codepoint */

sprintf((char*)output_pointer, "u%04x", *input_pointer);

output_pointer += 4;

break;

}

}

}

output[output_length + 1] = '\"';

output[output_length + 2] = '\0';

return output;

}

static unsigned char *print_string(const cJSON * const item, printbuffer * const p, const internal_hooks * const hooks)

{

return print_string_ptr((unsigned char*)item->valuestring, p, hooks);

}

static const unsigned char *parse_value(cJSON * const item, const unsigned char * const input, const unsigned char ** const ep, const internal_hooks * const hooks);

static unsigned char *print_value(const cJSON * const item, const size_t depth, const cjbool format, printbuffer * const output_buffer, const internal_hooks * const hooks);

static const unsigned char *parse_array(cJSON * const item, const unsigned char *input, const unsigned char ** const ep, const internal_hooks * const hooks);

static unsigned char *print_array(const cJSON * const item, const size_t depth, const cjbool format, printbuffer * const output_buffer, const internal_hooks * const hooks);

static const unsigned char *parse_object(cJSON * const item, const unsigned char *input, const unsigned char ** const ep, const internal_hooks * const hooks);

static unsigned char *print_object(const cJSON * const item, const size_t depth, const cjbool format, printbuffer * const output_buffer, const internal_hooks * const hooks);

static const unsigned char *skip_whitespace(const unsigned char *in)

{

while (in && *in && (*in <= 32))

{

in++;

}

return in;

}

CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cjbool require_null_terminated)

{

const unsigned char *end = NULL;

/* use global error pointer if no specific one was given */

const unsigned char **ep = return_parse_end ? (const unsigned char**)return_parse_end : &global_ep;

cJSON *c = cJSON_New_Item(&global_hooks);

*ep = NULL;

if (!c) /* memory fail */

{

return NULL;

}

end = parse_value(c, skip_whitespace((const unsigned char*)value), ep, &global_hooks);

if (!end)

{

/* parse failure. ep is set. */

cJSON_Delete(c);

return NULL;

}

/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */

if (require_null_terminated)

{

end = skip_whitespace(end);

if (*end)

{

cJSON_Delete(c);

*ep = end;

return NULL;

}

}

if (return_parse_end)

{

*return_parse_end = (const char*)end;

}

return c;

}

CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)

{

return cJSON_ParseWithOpts(value, 0, 0);

}

#define min(a, b) ((a < b) ? a : b)

static unsigned char *print(const cJSON * const item, cjbool format, const internal_hooks * const hooks)

{

printbuffer buffer[1];

unsigned char *printed = NULL;

memset(buffer, 0, sizeof(buffer));

/* create buffer */

buffer->buffer = (unsigned char*) hooks->allocate(256);

if (buffer->buffer == NULL)

{

goto fail;

}

/* print the value */

if (print_value(item, 0, format, buffer, hooks) == NULL)

{

goto fail;

}

update_offset(buffer);

/* copy the buffer over to a new one */

printed = (unsigned char*) hooks->allocate(buffer->offset + 1);

if (printed == NULL)

{

goto fail;

}

strncpy((char*)printed, (char*)buffer->buffer, min(buffer->length, buffer->offset + 1));

printed[buffer->offset] = '\0'; /* just to be sure */

/* free the buffer */

hooks->deallocate(buffer->buffer);

return printed;

fail:

if (buffer->buffer != NULL)

{

hooks->deallocate(buffer->buffer);

}

if (printed != NULL)

{

hooks->deallocate(printed);

}

return NULL;

}

CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)

{

return (char*)print(item, true, &global_hooks);

}

CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)

{

return (char*)print(item, false, &global_hooks);

}

CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cjbool fmt)

{

printbuffer p;

if (prebuffer < 0)

{

return NULL;

}

p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);

if (!p.buffer)

{

return NULL;

}

p.length = (size_t)prebuffer;

p.offset = 0;

p.noalloc = false;

return (char*)print_value(item, 0, fmt, &p, &global_hooks);

}

CJSON_PUBLIC(int) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cjbool fmt)

{

printbuffer p;

if (len < 0)

{

return false;

}

p.buffer = (unsigned char*)buf;

p.length = (size_t)len;

p.offset = 0;

p.noalloc = true;

return print_value(item, 0, fmt, &p, &global_hooks) != NULL;

}

static const unsigned char *parse_value(cJSON * const item, const unsigned char * const input, const unsigned char ** const error_pointer, const internal_hooks * const hooks)

{

if (input == NULL)

{

return NULL; /* no input */

}

/* parse the different types of values */

/* null */

if (!strncmp((const char*)input, "null", 4))

{

item->type = cJSON_NULL;

return input + 4;

}

/* false */

if (!strncmp((const char*)input, "false", 5))

{

item->type = cJSON_False;

return input + 5;

}

/* true */

if (!strncmp((const char*)input, "true", 4))

{

item->type = cJSON_True;

item->valueint = 1;

return input + 4;

}

/* string */

if (*input == '\"')

{

return parse_string(item, input, error_pointer, hooks);

}

/* number */

if ((*input == '-') || ((*input >= '0') && (*input <= '9')))

{

return parse_number(item, input);

}

/* array */

if (*input == '[')

{

return parse_array(item, input, error_pointer, hooks);

}

/* object */

if (*input == '{')

{

return parse_object(item, input, error_pointer, hooks);

}