diff --git a/evaluation/demonstration/Makefile b/evaluation/demonstration/Makefile index 1028623c556e60b6dca800f0908b666d81429542..2e275b26821cc2d3dbe4a5287e0d113b613e7ce0 100644 --- a/evaluation/demonstration/Makefile +++ b/evaluation/demonstration/Makefile @@ -5,17 +5,17 @@ TARGETS=client server middlebox all: $(TARGETS) -client: client.o common.o +client: client.o common.o cJSON.o $(CC) $(LDFLAGS) -o $@ $^ $(LIBS) - -server: server.o common.o + +server: server.o common.o cJSON.o $(CC) $(LDFLAGS) -o $@ $^ $(LIBS) - -middlebox: middlebox.o common.o + +middlebox: middlebox.o common.o cJSON.o $(CC) $(LDFLAGS) -o $@ $^ $(LIBS) %.o: %.c $(CC) $(CFLAGS) -c -o $@ $< - + clean: - rm -f *.o $(TARGETS) \ No newline at end of file + rm -f *.o $(TARGETS) diff --git a/evaluation/demonstration/cJSON.c b/evaluation/demonstration/cJSON.c new file mode 100644 index 0000000000000000000000000000000000000000..db39ff5f70ebe43a817d41952b4ef8c911d83284 --- /dev/null +++ b/evaluation/demonstration/cJSON.c @@ -0,0 +1,2932 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#define true ((cJSON_bool)1) +#define false ((cJSON_bool)0) + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item) { + if (!cJSON_IsString(item)) { + return NULL; + } + + return item->valuestring; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 7) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +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; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(*allocate)(size_t size); + void (*deallocate)(void *pointer); + void *(*reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dillimport '...' is not static */ +static void *internal_malloc(size_t size) +{ + return malloc(size); +} +static void internal_free(void *pointer) +{ + free(pointer); +} +static void *internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + 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; + } +} + +/* Internal constructor. */ +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; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* 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; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +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 = (int)number; + } + + return object->valuedouble = number; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + if (newbuffer) + { + memcpy(newbuffer, p->buffer, p->offset + 1); + } + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the 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); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26]; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if ((d * 0) != 0) + { + length = sprintf((char*)number_buffer, "null"); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || ((double)test != d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occured */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +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; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + 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 */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + 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 */ + 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 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + 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; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + 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); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + 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 false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* 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 true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)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 true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = strlen((const char*)value) + sizeof(""); + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +#define cjson_min(a, b) ((a < b) ? a : b) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_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; +} + +/* Render a cJSON item/entity/structure to text. */ +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, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + 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; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((len < 0) || (buf == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buf; + p.length = (size_t)len; + p.offset = 0; + p.noalloc = true; + p.format = fmt; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* faile to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = (size_t) ((output_buffer->format ? 1 : 0) + (current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL)) + { + return false; + } + + child = array->child; + + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + } + else + { + /* append to the end */ + while (child->next) + { + child = child->next; + } + suffix_object(child, item); + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return; + } + + add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return; + } + + add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } + + if (item->prev != NULL) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0) + { + return; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + add_item_to_array(array, newitem); + return; + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (parent->child == item) + { + parent->child = replacement; + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return; + } + + cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + replacement->type &= ~cJSON_StringIsConst; + + cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); + + return true; +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool b) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = b ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0;a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + return a; +} + +/* Duplication */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + unsigned char *into = (unsigned char*)json; + + if (json == NULL) + { + return; + } + + while (*json) + { + if (*json == ' ') + { + json++; + } + else if (*json == '\t') + { + /* Whitespace characters. */ + json++; + } + else if (*json == '\r') + { + json++; + } + else if (*json=='\n') + { + json++; + } + else if ((*json == '/') && (json[1] == '/')) + { + /* double-slash comments, to end of line. */ + while (*json && (*json != '\n')) + { + json++; + } + } + else if ((*json == '/') && (json[1] == '*')) + { + /* multiline comments. */ + while (*json && !((*json == '*') && (json[1] == '/'))) + { + json++; + } + json += 2; + } + else if (*json == '\"') + { + /* string literals, which are \" sensitive. */ + *into++ = (unsigned char)*json++; + while (*json && (*json != '\"')) + { + if (*json == '\\') + { + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + else + { + /* All other characters. */ + *into++ = (unsigned char)*json++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a)) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (a->valuedouble == b->valuedouble) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); +} \ No newline at end of file diff --git a/evaluation/demonstration/cJSON.h b/evaluation/demonstration/cJSON.h new file mode 100644 index 0000000000000000000000000000000000000000..95dd50f82d1b7b8e83bf6b8413691d8e6578f251 --- /dev/null +++ b/evaluation/demonstration/cJSON.h @@ -0,0 +1,277 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 7 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + void *(*malloc_fn)(size_t sz); + void (*free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 2 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type __stdcall +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall +#endif +#else /* !WIN32 */ +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *c); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check if the item is a string and return its valuestring */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/arrray that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detatch items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will +need to be released. With recurse!=0, it will duplicate any children connected to the item. +The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + + +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/evaluation/demonstration/client b/evaluation/demonstration/client new file mode 100755 index 0000000000000000000000000000000000000000..fb6abc464486bf24d3df1f95a91dd4ba5768733c Binary files /dev/null and b/evaluation/demonstration/client differ diff --git a/evaluation/demonstration/client.c b/evaluation/demonstration/client.c index 8bd37aac1d6135add7c8513e66b257c4314c3750..d59df01828703c3a63d1711b267ef840a46c6393 100644 --- a/evaluation/demonstration/client.c +++ b/evaluation/demonstration/client.c @@ -1,9 +1,20 @@ +#define DEBUG + #include #include #include #include "common.h" #include #include +#include +#include +#include "cJSON.h" + +#ifdef DEBUG +#define DEBUG_PRINT(...) do{ fprintf( stdout, __VA_ARGS__ ); } while( false ) +#else +#define DEBUG_PRINT(...) do{ } while ( false ) +#endif const char *USAGE="client [-v | -V logfile ] [ -k keylog ] [-c context_list] [-s server] [-m middlebox_list | -M middlebox_list_file]\n" "\tcontext list must be comma-separated list of context names, defaults to \"header,body\"\n" @@ -13,9 +24,12 @@ const char *USAGE="client [-v | -V logfile ] [ -k keylog ] [-c context_list] [-s "\t\tdefault \"127.0.0.1:" xstr(DEFAULT_MBOX_PORT) "\n" "Input to send to the server is taken from stdin in lines of the form context:command\n"; +// TO-DO: Accept input file as command line argument + const char *ARG_TYPES="v:V:k:c:s:m:M"; -typedef struct ClientConfigST { +typedef struct ClientConfigST +{ FILE *vlog; FILE *fIn; FILE *fOut; @@ -24,6 +38,8 @@ typedef struct ClientConfigST { const char *contextDescs[50]; int numMiddleboxes; const char *MiddleboxURLs[50]; + int middleboxReadRights[50][50]; // This is horrible + int middleboxWriteRights[50][50]; // This is horrible and has a silly name const char *serverURL; char myKeyFile[1024]; char myPassword[1024]; @@ -43,8 +59,6 @@ client_SetDefaults(ClientConfig *ptC) strcpy(ptC->myKeyFile,"client.pem"); strcpy(ptC->myPassword,"password"); ptC->serverURL="127.0.0.1:" xstr(DEFAULT_SERVER_PORT); - ptC->numMiddleboxes=1; - ptC->MiddleboxURLs[0]="127.0.0.1:" xstr(DEFAULT_MBOX_PORT); } extern char *optarg; @@ -131,16 +145,27 @@ client_Connect(SSL_CTX *ptSSLctx, ClientConfig *ptConf) /*step 1 - create the contexts*/ iStatus=COMMON_InitMulticontextSet(ptConf->pSSL); assert(iStatus==SUCCESS); - if(ptConf->numContexts==0) { + + if(ptConf->numContexts==0) + { + DEBUG_PRINT("[CLIENT DEBUG] No contexts specified, adding default\n"); iStatus=COMMON_AppendContext(ptConf->pSSL,"default"); - } else { + assert(iStatus==SUCCESS); + } + else + { + DEBUG_PRINT("[CLIENT DEBUG] Appending %d context\n", ptConf->numContexts); /*Iterate through the context descriptions and create each one*/ - for(i=0;i!=ptConf->numContexts && iStatus==SUCCESS;i++) { + for(i=0;i!=ptConf->numContexts && iStatus==SUCCESS;i++) + { + DEBUG_PRINT(" [CLIENT DEBUG] Appending context %s\n", ptConf->contextDescs[i]); iStatus=COMMON_AppendContext(ptConf->pSSL,ptConf->contextDescs[i]); + assert(iStatus==SUCCESS); } } - if(iStatus!=SUCCESS) { + if(iStatus!=SUCCESS) + { /*TODO*/ assert(0); } @@ -150,35 +175,60 @@ client_Connect(SSL_CTX *ptSSLctx, ClientConfig *ptConf) assert(iStatus==SUCCESS); /*step 2.0? - do we need to insert client as middlebox 0? - TODO confirm*/ /*step 2.1 - iterate through middlebox list */ - for(i=0;i!=ptConf->numMiddleboxes;i++) { + DEBUG_PRINT("[CLIENT DEBUG] Appending %d middleboxes\n", ptConf->numMiddleboxes ); + for(i=0;i!=ptConf->numMiddleboxes;i++) + { + DEBUG_PRINT(" [CLIENT DEBUG] Appending middlbox %d (%s)\n", i, ptConf->MiddleboxURLs[i]); iStatus=COMMON_AppendProxy(ptConf->pSSL,ptConf->MiddleboxURLs[i]); } /*step 2.2 - add server url*/ + + DEBUG_PRINT("[CLIENT DEBUG] Setting server URL { %s }\n", ptConf->serverURL); iStatus=COMMON_SetServer(ptConf->pSSL,ptConf->serverURL); - /*step 3 - set the middlebox access permissions*/ - /*for demonstration purposed, we will set by the following rule: - * Middleboxes with an even port number get read-only access - * Middleboxes with an odd port number get write access - * This is for demonstration only - there is no sensible - * reason why this rule would ever be real-world implemented! - */ - for(j=0;j!=ptConf->numContexts;j++) { + DEBUG_PRINT("[CLIENT DEBUG] Setting middlebox access permissions\n"); + for(j=0;j!=ptConf->numContexts;j++) + { /*grant client if included*/ /*grant server*/ - iStatus=COMMON_SetProxyAccessPermissionByID(ptConf->pSSL,ptConf->pSSL->slices[j]->slice_id, ptConf->numMiddleboxes-1, - 1,1); - for(i=0;i!=ptConf->numMiddleboxes/*-1*/;i++) { /*change to i=1 if client included*/ + DEBUG_PRINT(" [CLIENT DEBUG] Setting permissions for slice %d (%s)\n", ptConf->pSSL->slices[j]->slice_id,ptConf->pSSL->slices[j]->purpose); + //DEBUG_PRINT(" [CLIENT DEBUG] Setting full permissions for server (%d)\n", ptConf->numMiddleboxes-1); + //iStatus=COMMON_SetProxyAccessPermissionByID(ptConf->pSSL,ptConf->pSSL->slices[j]->slice_id, ptConf->numMiddleboxes-1, + // 1,1); + for(i=0;i!=ptConf->numMiddleboxes/*-1*/;i++) + { /*change to i=1 if client included*/ char *sMBoxUrl=ptConf->pSSL->proxies[i]->address; char *sPort=strchr(sMBoxUrl,':'); + int writePermission = ptConf->middleboxWriteRights[i][j]; + int readPermission = ptConf->middleboxReadRights[i][j]; assert(sPort); sPort++; int iPort=atoi(sPort); + DEBUG_PRINT(" [CLIENT DEBUG] Setting permissions for middlebox %d (%s) R = %d W = %d\n", i, sMBoxUrl, readPermission, writePermission); iStatus=COMMON_SetProxyAccessPermissionByID(ptConf->pSSL,ptConf->pSSL->slices[j]->slice_id, i, - 1,iPort%2); + readPermission, writePermission); } } + #ifdef DEBUG + printf ("----------------------------\n"); + for (int q = 0; q < ptConf->pSSL->proxies_len; q++) + { + printf ("Proxy %d: \n", q); + printf (" WriteSliceIDs: \n"); + for (int p = 0; p < ptConf->pSSL->proxies[0]->write_slice_ids_len; p++) + { + printf (" [%d]: %d\n", p, ptConf->pSSL->proxies[0]->write_slice_ids[p]); + } + printf (" ReadSliceISs: \n"); + for (int p = 0; p < ptConf->pSSL->proxies[0]->read_slice_ids_len; p++) + { + printf (" [%d]: %d\n", p, ptConf->pSSL->proxies[0]->read_slice_ids[p]); + } + } + printf ("----------------------------\n"); + #endif + /*step 4? - do we need to create a socket to first middlebox?*/ // TCP Connect char* sAddress = (char*)malloc(strlen(ptConf->pSSL->proxies[0]->address) + 1); // Large enough for string+\0 @@ -186,6 +236,7 @@ client_Connect(SSL_CTX *ptSSLctx, ClientConfig *ptConf) char *sHost = strtok(sAddress, ":"); int iPort = atoi(strtok(NULL, ":")); int iSock; + DEBUG_PRINT ("[CLIENT DEBUG] Connecting to %s\n", sHost); COMMON_TcpConnect(&iSock, sHost, iPort); // Connect TCP socket to SSL socket ptSBio = BIO_new_socket(iSock, BIO_NOCLOSE); @@ -200,25 +251,22 @@ client_Connect(SSL_CTX *ptSSLctx, ClientConfig *ptConf) if (SSL_connect(ptConf->pSSL) <= 0) { iStatus=NETWORK_CONNECT_FAIL; } + + X509* client_cert = SSL_get_certificate(ptConf->pSSL); + printf ("[CLIENT] Client certificate:\n"); + COMMON_PrintCertificateDetails(client_cert); + X509_free(client_cert); + + X509* server_cert = SSL_get_peer_certificate(ptConf->pSSL); + printf ("[CLIENT] Server certificate:\n"); + COMMON_PrintCertificateDetails(server_cert); + X509_free(server_cert); + return SUCCESS; + // MC: Do we really want to return SUCCESS regardless of the value of iStatus? } -int giSignal=0; -int giDone=0; -static pthread_t gtParent_thread; -static pthread_t gtSending_thread; -static pthread_t gtReceiving_thread; - -static void -client_sighandler(int sig) { - if(giSignal==0) giSignal=sig; - giDone=1; - /*note: pthread_kill is a signal sending method - not a - * "Die now" method. Unfortunate naming - */ - pthread_kill(gtSending_thread,sig); - pthread_kill(gtReceiving_thread,sig); -} +int intCount = 0; struct iobuffer { int iUsed; @@ -229,151 +277,130 @@ struct iobuffer { char z;/*force null termination of string*/ }; -static void * -client_sendThread(void *pvArg) +int main(const int iArgC, char *papsArgV[]) { - int iNewLine=0; - int iCurrentSlice=0; - ERROR_STATUS iStatus=SUCCESS; - int iBytesRead; - int iBytesToSend; - int iBytesSent; - struct iobuffer tInBuff; - const ClientConfig *ptCConf=(const ClientConfig *)pvArg; - char *sCurrent,*sEnd,sChunk; - char sContext[MAX_CONTEXT_LEN]; - int iFIn=fileno(ptCConf->fIn); - - memset(&tInBuff,0,sizeof(tInBuff)); - - while(!giDone && iStatus==SUCCESS) { - /*wait until we have data to read*/ - /*we should always have an empty buffer at this point*/ - tInBuff.iUsed=0; - memset(tInBuff.aucBuffer,0,sizeof(tInBuff.aucBuffer)); - iStatus=COMMON_ReadWaitFD(iFIn); - /*Read as much data as possible*/ - iBytesRead=read(iFIn,tInBuff.aucBuffer,sizeof(tInBuff.aucBuffer)); - assert(iBytesRead>0); /*should be as we waited for it*/ - iBytesToSend=iBytesRead; - - iNewLine=(tInBuff.aucBuffer[0]=='\n'); - - while(iStatus==SUCCESS && iBytesToSend>0) { - if(iNewLine) { - /*we hit a new line - advance to next context*/ - iCurrentSlice=(iCurrentSlice+1)%ptCConf->pSSL->slices_len; - ptCConf->pSSL->write_slice=SPP_get_slice_by_id(ptCConf->pSSL,ptCConf->pSSL->slices[iCurrentSlice]->slice_id); - tInBuff.iUsed++; - iBytesToSend--; - iNewLine=(tInBuff.aucBuffer[tInBuff.iUsed]=='\n'); /*should only happen on \n\n*/ - /*note - line above may overflow if \n happens to be last byte read - * this is guaranteed safe due to the additional null terminator char - * and the next iteration of the top loop will reset correctly*/ - } else if((sEnd=strchr(tInBuff.stext+tInBuff.iUsed,'\n'))==NULL) { - /*entire buffer to output in this context*/ - iBytesSent=SSL_write(ptCConf->pSSL,tInBuff.stext+tInBuff.iUsed,iBytesToSend); - /*todo - handle error sending*/ - assert(iBytesSent>0); - tInBuff.iUsed+=iBytesSent; - iBytesToSend-=iBytesSent; - } else { - /*send entire buffer up to and including new line*/ - /*advance buffer up to new line only - context change on next iteration - * of this loop*/ - iBytesSent=SSL_write(ptCConf->pSSL,tInBuff.stext+tInBuff.iUsed,sEnd-(tInBuff.stext+tInBuff.iUsed)+1); - /*todo - handle error sending*/ - tInBuff.iUsed=sEnd-tInBuff.stext; - iBytesToSend-=sEnd-(tInBuff.stext+tInBuff.iUsed); - iNewLine=1; - assert(iBytesSent==(sEnd-(tInBuff.stext+tInBuff.iUsed))+1); - } + DEBUG_PRINT ("[CLIENT DEBUG] Client starting\n"); + + ClientConfig tConfig; + SSL_CTX *ptSSLctx=NULL; + int iStatus; + + client_SetDefaults(&tConfig); + + char* inputFile = "inputData.json"; + DEBUG_PRINT ("[CLIENT DEBUG] Reading input data from %s\n", inputFile); + cJSON* json = COMMON_ReadJSONFile(inputFile); + cJSON* item = NULL; + + char* configStr = cJSON_Print(json); + DEBUG_PRINT("%s\n", configStr); + free(configStr); + + // TO DO bounds, null or error checking of any kind at all + cJSON* contextNames = cJSON_GetObjectItem(json, "contexts"); + int contextCount = 0; + cJSON_ArrayForEach(item, contextNames) + { + tConfig.contextDescs[contextCount] = strdup(item->valuestring); + contextCount++; + } + tConfig.numContexts = contextCount; + + + cJSON* middleboxes = cJSON_GetObjectItem(json, "middleboxes"); + int mboxCount = 0; + cJSON_ArrayForEach(item, middleboxes) + { + tConfig.MiddleboxURLs[mboxCount] = strdup(cJSON_GetObjectItem(item, "url")->valuestring); + cJSON* readAccessItem = NULL; + cJSON_ArrayForEach(readAccessItem, cJSON_GetObjectItem(item, "readAccess")) + { + tConfig.middleboxReadRights[mboxCount][readAccessItem->valueint] = 1; + } + cJSON* writeAccessItem = NULL; + cJSON_ArrayForEach(writeAccessItem, cJSON_GetObjectItem(item, "writeAccess")) + { + tConfig.middleboxWriteRights[mboxCount][writeAccessItem->valueint] = 1; } + mboxCount++; } - /*signal to the parent so all other threads are woken*/ - pthread_kill(gtParent_thread,SIGINT); - pthread_exit(NULL); - return NULL; + tConfig.numMiddleboxes = mboxCount; + + iStatus=client_ParseArgs(iArgC,papsArgV, &tConfig); + COMMON_CheckLogErrorAndExit(iStatus,stderr,"%s\n",USAGE); -} + iStatus=client_CreateContext(&ptSSLctx,&tConfig); + iStatus=client_Connect(ptSSLctx,&tConfig); + + DEBUG_PRINT("[CLIENT DEBUG] Connected\n"); -static void * -client_receiveThread(void *pvArg) -{ - ERROR_STATUS iStatus=SUCCESS; struct iobuffer tInBuff; - int iBytesRead=1; - const ClientConfig *ptCConf=(const ClientConfig *)pvArg; - BIO *sock_bio=ptCConf->pSSL->rbio; - int rfd; - SPP_SLICE *pSlice; - SPP_CTX *pCtx; - - BIO_get_fd(sock_bio,&rfd); - memset(&tInBuff,0,sizeof(tInBuff)); - - while(iBytesRead>0 && iStatus==SUCCESS) { - /*wait until we have data to read*/ - iStatus=COMMON_ReadWaitFD(rfd); - iBytesRead = SSL_read(ptCConf->pSSL,tInBuff.aucBuffer,sizeof(tInBuff.aucBuffer)); - pSlice = ptCConf->pSSL->read_slice; - pCtx = ptCConf->pSSL->spp_read_ctx; - ptCConf->pSSL->read_slice = NULL; - ptCConf->pSSL->spp_read_ctx = NULL; - - if(iBytesRead>0) { - /*print out what we got and from where*/ - fprintf(ptCConf->fOut,"<%s(%d)>:%s",pSlice->purpose,pSlice->slice_id,tInBuff.stext); - } else { - fprintf(ptCConf->fOut,"zero bytes read - closing"); - } - } + cJSON* slicedData = cJSON_GetObjectItem(json, "slicedData"); + cJSON_ArrayForEach(item, slicedData) + { + cJSON *slice = cJSON_GetObjectItem(item, "slice"); + cJSON *text = cJSON_GetObjectItem(item, "data"); + if (slice->valueint >= tConfig.numContexts) + { + printf("[CLIENT ERROR] Data specified for slice id %d, which is out of bounds\n", slice->valueint); + exit(-1); + } + tConfig.pSSL->write_slice=SPP_get_slice_by_id(tConfig.pSSL,tConfig.pSSL->slices[slice->valueint]->slice_id); + if (tConfig.pSSL->write_slice == NULL) + { + printf("[CLIENT ERROR] Data specified for slice id %d which is not found\n", slice->valueint); + exit(-1); + } + int iBytesSent=SSL_write(tConfig.pSSL, text->valuestring, strlen(text->valuestring)); + printf ("[CLIENT DEBUG] Sent %d bytes { %s }\n", iBytesSent, text->valuestring); + } + cJSON_Delete(json); - /*signal to the parent so all other threads are woken*/ - pthread_kill(gtParent_thread,SIGINT); - pthread_exit(NULL); - return NULL; -} + int iBytesRead = 1; -ERROR_STATUS -client_RunClient(const ClientConfig *ptConf) -{ - void *pvUnused; - ERROR_STATUS iStatus=SUCCESS; + cJSON* recvData = cJSON_CreateObject(); + cJSON* sliceDataArray = cJSON_AddArrayToObject(recvData, "slices"); - /*set an interrupt signal handler to kill the process*/ - signal(SIGINT,client_sighandler); - signal(SIGTERM,client_sighandler); + SPP_SLICE* slice; + SPP_CTX* ctx; + int slicesSeen = 0; - gtParent_thread=pthread_self(); - /*create the send and recioeve threads*/ - pthread_create(>Receiving_thread, NULL, client_receiveThread, (void *)ptConf); - pthread_create(>Sending_thread, NULL, client_sendThread, (void *)ptConf); + while ((iBytesRead > 0) && (slicesSeen < tConfig.numContexts)) + { + DEBUG_PRINT ("[CLIENT DEBUG] Waiting for response\n"); + //iBytesRead = SSL_read(tConfig.pSSL,tInBuff.aucBuffer,sizeof(tInBuff.aucBuffer)); + iBytesRead = SPP_read_record(tConfig.pSSL, tInBuff.aucBuffer, sizeof(tInBuff.aucBuffer), &slice, &ctx); - /*wait for both to finish*/ - pthread_join(gtReceiving_thread,&pvUnused); - pthread_join(gtSending_thread,&pvUnused); - return SUCCESS; -} + if (iBytesRead > 0) + { + cJSON* jslice = cJSON_CreateObject(); + cJSON_AddNumberToObject(jslice, "slice", slice->slice_id ); + cJSON_AddStringToObject(jslice, "data", COMMON_MakeNullTerminatedCopy(tInBuff.aucBuffer, iBytesRead)); + cJSON_AddItemToArray(sliceDataArray, jslice); + DEBUG_PRINT ("[CLIENT DEBUG] Recv %d bytes [(%s)]\n", iBytesRead, tInBuff.aucBuffer); + } + else + { + DEBUG_PRINT ("[CLIENT DEBUG] SPP_read_record return zero bytes\n"); + break; + } -int -main(const int iArgC, char *papsArgV[]) -{ - ClientConfig tConfig; - SSL_CTX *ptSSLctx=NULL; - int iStatus; + slicesSeen++; + } - client_SetDefaults(&tConfig); + char* filename = COMMON_WriteJSONFile(recvData, "Client"); + DEBUG_PRINT("[CLIENT DEBUG] Data written to %s\n", filename); + free(filename); - iStatus=client_ParseArgs(iArgC,papsArgV, &tConfig); - COMMON_CheckLogErrorAndExit(iStatus,stderr,"%s\n",USAGE); + char* recvDataString = cJSON_Print(recvData); + printf("[CLIENT] Received\n%s\n", recvDataString); + free(recvDataString); - iStatus=client_CreateContext(&ptSSLctx,&tConfig); - iStatus=client_Connect(ptSSLctx,&tConfig); - iStatus=client_RunClient(&tConfig); + cJSON_Delete(recvData); + DEBUG_PRINT ("[CLIENT DEBUG] Exiting\n"); return iStatus; } diff --git a/evaluation/demonstration/common.c b/evaluation/demonstration/common.c index 8293861066fd34be98064003d8a000aaec29355e..afa0768c8bef1f9c1b4280af25ff31ac77766b4a 100644 --- a/evaluation/demonstration/common.c +++ b/evaluation/demonstration/common.c @@ -11,6 +11,8 @@ #include #include #include +#include +#include #define MAXSTRLEN (1024) @@ -172,7 +174,7 @@ COMMON_SetProxyAccessPermissionByID(SSL *ptSSL, int iSliceID, int iMiddleboxNum, int reads_insert_index, write_insert_index; int x,y,z; - if(ptSSL->proxies_lenslices_lenproxies_len<=iMiddleboxNum) return ARRAY_OVERFLOW; read_slices=ptSSL->proxies[iMiddleboxNum]->read_slice_ids; read_slice_len=&(ptSSL->proxies[iMiddleboxNum]->read_slice_ids_len); @@ -202,7 +204,7 @@ COMMON_SetProxyAccessPermissionByID(SSL *ptSSL, int iSliceID, int iMiddleboxNum, if(*read_slice_len>y) { /*we have higher number slices to move up*/ memmove(&read_slices[x+1],&read_slices[x],(*read_slice_len-y)*sizeof(*read_slices)); } - read_slices[x]=iSliceID; + read_slices[x+1]=iSliceID; (*read_slice_len)++; } /*else we are re-granted an already granted access - NOP*/ } else { /*we are removing the permission if it is granted*/ @@ -226,7 +228,7 @@ COMMON_SetProxyAccessPermissionByID(SSL *ptSSL, int iSliceID, int iMiddleboxNum, if(*write_slice_len>y) { /*we have higher number slices to move up*/ memmove(&write_slices[x+1],&write_slices[x],(*write_slice_len-y)*sizeof(*write_slices)); } - write_slices[x]=iSliceID; + write_slices[x+1]=iSliceID; (*write_slice_len)++; } /*else we are re-granted an already granted access - NOP*/ } else { /*we are removing the permission if it is granted*/ @@ -425,3 +427,172 @@ common_SigpipeHandle(int x) UNUSED(x); } +char* COMMON_MakeNullTerminatedCopy (const char* buf, const unsigned int length) +{ + char* retBuf = malloc(length + 1); + memcpy(retBuf, buf, length); + retBuf[length] = 0; + return retBuf; +} + +long getMicrotime() +{ + struct timeval currentTime; + gettimeofday(¤tTime, NULL); + return currentTime.tv_sec * (int)1e6 + currentTime.tv_usec; +} + +char* COMMON_WriteJSONFile (cJSON* data, char* source) +{ + char fileNameBuf[128]; + sprintf(fileNameBuf, "%s_%lu.json", source, getMicrotime()); + + FILE* f = fopen (fileNameBuf, "w"); + char* jsonString = cJSON_Print(data); + fwrite(jsonString, 1, strlen(jsonString), f); + + fclose(f); + free(jsonString); + + return strdup(fileNameBuf); +} + +cJSON* COMMON_ReadJSONFile (char* filename) +{ + FILE * f = fopen (filename, "r"); + fseek (f, 0, SEEK_END); + int length = ftell (f); + fseek (f, 0, SEEK_SET); + char* buffer = malloc (length); + if (buffer) + { + fread (buffer, 1, length, f); + } + fclose (f); + + cJSON* json = cJSON_Parse(buffer); + + free(buffer); + + return json; +} + +int COMMON_Base64Encode(const unsigned char* buffer, size_t length, char** b64text) +{ + BIO *bio, *b64; + BUF_MEM *bufferPtr; + + b64 = BIO_new(BIO_f_base64()); + bio = BIO_new(BIO_s_mem()); + bio = BIO_push(b64, bio); + + BIO_set_flags(bio, 0); // BIO_FLAGS_BASE64_NO_NL); //Ignore newlines - write everything in one line + BIO_write(bio, buffer, length); + BIO_flush(bio); + BIO_get_mem_ptr(bio, &bufferPtr); + BIO_set_close(bio, BIO_NOCLOSE); + BIO_free_all(bio); + + *b64text=(*bufferPtr).data; + + return (0); //success +} + +size_t common_calcDecodeLength(const char* b64input) +{ //Calculates the length of a decoded string + size_t len = strlen(b64input), + padding = 0; + + if (b64input[len-1] == '=' && b64input[len-2] == '=') //last two chars are = + padding = 2; + else if (b64input[len-1] == '=') //last char is = + padding = 1; + + return (len*3)/4 - padding; +} + + +int COMMON_Base64Decode(char* b64message, unsigned char** buffer, size_t* length) +{ + BIO *bio, *b64; + + int decodeLen = common_calcDecodeLength(b64message); + *buffer = (unsigned char*)malloc(decodeLen + 1); + (*buffer)[decodeLen] = '\0'; + + bio = BIO_new_mem_buf(b64message, -1); + b64 = BIO_new(BIO_f_base64()); + bio = BIO_push(b64, bio); + + BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer + *length = BIO_read(bio, *buffer, strlen(b64message)); + assert(*length == decodeLen); //length should equal decodeLen, else something went horribly wrong + BIO_free_all(bio); + + return (0); //success +} + +char* COMMON_CallExternalProcess(const char* commandString, unsigned int* length) +{ + FILE* p = popen(commandString, "r"); + + // Ugh. Do this better. + const unsigned int bufSize = 65536; + char* responseBuf = malloc(bufSize); + memset(responseBuf, 0, bufSize); + + char* ptr = responseBuf; + int ch; + unsigned int count = 0; + + while( (ch=fgetc(p)) != EOF) + { + *ptr++ = ch; + count++; + } + + int returnCode = WEXITSTATUS(pclose(p)); + *length = count; + return responseBuf; +} + +#define MAX_CERT_FIELD_LENGTH 1024 +#define SHA1LEN 20 + +void hex_encode(unsigned char* readbuf, void *writebuf, size_t len) +{ + for(size_t i=0; i < len; i++) { + char *l = (char*) (2*i + ((intptr_t) writebuf)); + sprintf(l, "%02x", readbuf[i]); + } +} + +void COMMON_PrintCertificateDetails (X509* cert) +{ + if (NULL == cert) { + printf ("\tNo certificate\n"); + return; + } + + char subj[MAX_CERT_FIELD_LENGTH+1]; + char issuer[MAX_CERT_FIELD_LENGTH+1]; + X509_NAME_oneline(X509_get_subject_name(cert), subj, MAX_CERT_FIELD_LENGTH); + X509_NAME_oneline(X509_get_issuer_name(cert), issuer, MAX_CERT_FIELD_LENGTH); + printf("\tSubject: %s\n", subj); + printf("\tIssuer: %s\n", issuer); + + char buf[SHA1LEN]; + + const EVP_MD *digest = EVP_sha1(); + unsigned len; + + int rc = X509_digest(cert, digest, (unsigned char*) buf, &len); + if (rc == 0 || len != SHA1LEN) { + printf ("\tFailed to get SHA1 fingerprint\n"); + } + + char strbuf[2*SHA1LEN+1]; + hex_encode(buf, strbuf, SHA1LEN); + printf ("\tFingerprint: %s\n", strbuf); +} + diff --git a/evaluation/demonstration/common.h b/evaluation/demonstration/common.h index 1259ba000617bf4830d50b7659a6a844083c8c75..43cf72f10c1f88f829d4e0f44e71275450ab6c49 100644 --- a/evaluation/demonstration/common.h +++ b/evaluation/demonstration/common.h @@ -7,6 +7,8 @@ #include #include #include +#include +#include "cJSON.h" #define DEFAULT_SERVER_PORT 4433 #define DEFAULT_MBOX_PORT 8423 @@ -90,8 +92,17 @@ ERROR_STATUS COMMON_InitializeSSLCtx(SSL_CTX **pptCtx, unsigned int iID); /*todo - check the name of this in spec - the byte that identifies the middlebox number, client or server*/ void COMMON_DestroyCtx(SSL_CTX *ptCtx); +char* COMMON_WriteJSONFile (cJSON* data, char* source); +cJSON* COMMON_ReadJSONFile (char* filename); +//char* COMMON_GetPrintableBuffer (char* inputBuf, int inputBufLen, int* wasBase64Encoded); +int COMMON_Base64Encode(const unsigned char* buffer, size_t length, char** b64text); +int COMMON_Base64Decode(char* b64message, unsigned char** buffer, size_t* length); +char* COMMON_CallExternalProcess(const char* commandString, unsigned int* lengt); + +char* COMMON_MakeNullTerminatedCopy (const char* buf, const unsigned int length); +void COMMON_PrintCertificateDetails (X509* cert); #endif diff --git a/evaluation/demonstration/middlebox b/evaluation/demonstration/middlebox new file mode 100755 index 0000000000000000000000000000000000000000..da3f03d053ddcfa4d6b6f8219d5a0c1a6fa24092 Binary files /dev/null and b/evaluation/demonstration/middlebox differ diff --git a/evaluation/demonstration/middlebox.c b/evaluation/demonstration/middlebox.c index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..110cd5af572385a671c6d53be74026f331f6a920 100644 --- a/evaluation/demonstration/middlebox.c +++ b/evaluation/demonstration/middlebox.c @@ -0,0 +1,567 @@ +#define DEBUG + +#include "common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define KEYFILE "server.pem" +#define CA_FILE "ca.pem" +#define PASSWORD "password" +#define DHFILE "dh1024.pem" +#define BUFSIZZ 20000 + +#ifdef DEBUG +#define DEBUG_PRINT(...) do{ fprintf( stdout, __VA_ARGS__ ); } while( false ) +#else +#define DEBUG_PRINT(...) do{ } while ( false ) +#endif + + +static int disable_nagle = 0; +char* middlebox_id = "Middlebox1"; +char* handler_command = NULL; //"./mboxHandler.sh"; + + +int tcp_listen(int port) +{ + int sock; + struct sockaddr_in sin; + int val=1; + + if((sock=socket(AF_INET,SOCK_STREAM,0))<0) + { + printf("[MBOX ERROR] Couldn't make socket\n"); + exit(-1); + } + + memset(&sin,0,sizeof(sin)); + sin.sin_addr.s_addr=INADDR_ANY; + sin.sin_family=AF_INET; + sin.sin_port=htons(port); + setsockopt(sock,SOL_SOCKET,SO_REUSEADDR, + &val,sizeof(val)); + +/* if (disable_nagle == 1) + set_nagle(sock, 1); */ + + if(bind(sock,(struct sockaddr *)&sin, + sizeof(sin))<0) + { + printf("[MBOX] Couldn't bind\n"); + exit(-1); + } + + listen(sock,5); + + DEBUG_PRINT("[MBOX] Listening at port: %d\n", port); + + return(sock); + } + + + // TCP connect function +int tcp_connect(char *host, int port) +{ + struct hostent *hp; + struct sockaddr_in addr; + int sock; + + // Resolve host + if(!(hp = gethostbyname(host))) + { + printf("[MBOX ERROR] Couldn't resolve host %s\n", host); + exit(-1); + } + DEBUG_PRINT("[MBOX DEBUG] Host %s resolved to %s port %d\n", host, hp->h_addr_list[0], port); + + memset(&addr, 0, sizeof(addr)); + addr.sin_addr = *(struct in_addr*) + hp->h_addr_list[0]; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + + if((sock=socket(AF_INET,SOCK_STREAM, IPPROTO_TCP))<0) + { + printf("[MBOX ERROR] Couldn't create socket\n"); + } + DEBUG_PRINT("[MBOX DEBUG] Socket created\n"); + +/* if (disable_nagle == 1) + set_nagle(sock, 1); */ + + if(connect(sock,(struct sockaddr *)&addr, sizeof(addr))<0) + { + printf("[MBOX ERROR] Couldn't connect socket\n"); + exit(-1); + } + DEBUG_PRINT("[MBOX DEBUG] Socket connected\n"); + + return sock; +} + +void load_dh_params(SSL_CTX *ctx, char *file) +{ + DH *ret=0; + BIO *bio; + + if ((bio=BIO_new_file(file,"r")) == NULL) + { + printf ("[MBOX ERROR] Couldn't open DH file %s\n", file); + exit(0); + } + + ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + if(SSL_CTX_set_tmp_dh(ctx,ret) < 0) + { + printf ("[MBOX ERROR] Couldn't set DH parameters\n"); + exit(0); + } +} + +// ------------------------------------------------------------- +// Check for SSL_write error (just write at this point) +// TO DO: check behavior per slice +// ------------------------------------------------------------- +void check_SSL_write_error(SSL *ssl, int r, int request_len) +{ + int errorCode = SSL_get_error(ssl, r); + switch(errorCode) + { + case SSL_ERROR_NONE: + if(request_len != r) + { + printf("[MBOX ERROR] Incomplete write!"); + exit(-1); + } + break; + + default: + { + printf("[MBOX ERROR] SSL write error %d", errorCode); + exit(-1); + } + } +} + + + +SSL* create_SSL_connection(char *address, char* method) +{ + DEBUG_PRINT("[MBOX DEBUG] Creating new spp conection to: %s\n", address); + + SSL_CTX *ctx; // SSL context + SSL *new_ssl; // SSL context + BIO *sbio; // ? + int sock; // socket + char* ipv4 = strtok(strdup(address), ":"); // ip + int port = atoi(strtok(NULL, ":")); // port + + DEBUG_PRINT("[MBOX DEBUG] Connecting to next hop: %s %d\n", ipv4, port); + + int status = COMMON_InitializeSSLCtx(&ctx, KEYFILE, PASSWORD, CA_FILE, ID_MIDDLEBOX_MIN ); + new_ssl = SSL_new(ctx); + sock = tcp_connect(ipv4, port); + sbio = BIO_new_socket(sock, BIO_NOCLOSE); + SSL_set_bio(new_ssl, sbio, sbio); + + return new_ssl; +} + +/* + Just creates a new SSL instance but it does not connect ! +*/ +SSL* SPP_Callback(SSL *ssl, char *address) +{ + return create_SSL_connection(address, "middlebox"); +} + + + +/* +This will terminate but NOT destroy a socket +*/ +int shut_down_connections(SSL* ssl) +{ + int r; + int socket; + + // get socket + socket = SSL_get_fd(ssl); + DEBUG_PRINT("[MBOX DEBUG] Shutting down connection!\n"); + + r = SSL_shutdown(ssl); + + if (r == 0) + { + DEBUG_PRINT("[MBOX DEBUG] r=0 trying again to shutdown\n"); + shutdown(socket, 1); + r = SSL_shutdown(ssl); + } + + // Verify that all went good + switch(r) + { + case 1: + DEBUG_PRINT("[MBOX DEBUG] Succesfully shut down connection!\n"); + break; // Success + case 0: + case -1: + default: // Error + printf("[MBOX ERROR] Connection shutdown failed\n"); + } + + // FIXME -- this should not be need it but ... + shutdown(SSL_get_fd(ssl), SHUT_WR); + + // close here + close(socket); + + // All good + return 0; +} + +cJSON* create_slice_record(char* direction, char* data, int dataLen, SPP_SLICE* slice) +{ + cJSON* sliceRecord = cJSON_CreateObject(); + + cJSON_AddStringToObject(sliceRecord, "direction", direction); + cJSON_AddStringToObject(sliceRecord, "middleboxid", middlebox_id); + cJSON_AddNumberToObject(sliceRecord, "slice", slice->slice_id); + cJSON_AddStringToObject(sliceRecord, "slicePurpose", slice->purpose); + cJSON_AddNumberToObject(sliceRecord, "readAccess", slice->read_access); + cJSON_AddNumberToObject(sliceRecord, "writeAccess", slice->write_access); + + if (slice->read_access) + { + char* dataStr = malloc(dataLen + 1); + memcpy(dataStr, data, dataLen); + dataStr[dataLen] = 0; + cJSON_AddStringToObject(sliceRecord, "data", dataStr); + free(dataStr); + } + else + { + char* printableStr = NULL; + COMMON_Base64Encode(data, dataLen, &printableStr); + cJSON_AddStringToObject(sliceRecord, "data", printableStr); + } + + return sliceRecord; +} + +cJSON* call_slice_handler (char* inputJsonFile) +{ + if (!handler_command) return NULL; + + DEBUG_PRINT("[MBOX DEBUG] Calling response handler with file %s\n", inputJsonFile); + + char commandBuf[256]; + sprintf(commandBuf, "%s %s", handler_command, inputJsonFile); + + int bufLen = 0; + char* response = COMMON_CallExternalProcess(commandBuf, &bufLen); + + DEBUG_PRINT ("[MBOX DEBUG] Received %lu bytes from handler (%s)\n", strlen(response), response); + cJSON* returnJson = cJSON_Parse(response); + if (returnJson) return returnJson; + + printf ("[MBOX ERROR] Could not parse json from command handler %s - received { %s }\n", handler_command, response); + return NULL; +} + +/* +Handles data from previous hop and forwards them to the next one. +TODO: in theory the two handlers can be merged in a single function... +*/ +int handle_previous_hop_data(SSL* prev_ssl, SSL* next_ssl) +{ + int r,w; + long status; + char buf[BUFSIZZ]; + SPP_SLICE *slice; + SPP_CTX *ctx; + + // Read HTTP GET (assuming a single read is enough) + while(1) + { + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Waiting to read data from previous hop\n"); + + r = SPP_read_record(prev_ssl, buf, BUFSIZZ, &slice, &ctx); + DEBUG_PRINT("[MBOX DEBUG PREVHOP] SPP_read_record returned\n"); + + status = SSL_get_error(prev_ssl, r); + if (status == SSL_ERROR_ZERO_RETURN || status != SSL_ERROR_NONE) + { + printf ("[MBOX ERROR PREVHOP] Error code %ld\n", status); + ERR_print_errors_fp(stdout); + char tempBuf[100]; + ERR_error_string(status, tempBuf); + printf("[MBOX ERROR PREVHOP] Connection with previous hop closed, exiting previous hop handler (error %s)\n", tempBuf); + break; + } + else if (status != SSL_ERROR_NONE) + { + printf("[MBOX ERROR PREVHOP] SSL read error code %lu", status); + exit(-1); + } + + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Data received (from previous hop) (length %d, slice %d: %s):\n", r, slice->slice_id, slice->purpose); + + cJSON* sliceRecord = create_slice_record("ClientToServer", buf, r, slice); + char* printStr = cJSON_Print(sliceRecord); + printf("[MBOX PREVHOP] Received data (%d bytes)\n", r); + printf("%s\n", printStr); + free(printStr); + + char* jsonFileName = COMMON_WriteJSONFile(sliceRecord, middlebox_id); + + cJSON* modifiedSlice = NULL; + if (slice->write_access) modifiedSlice = call_slice_handler(jsonFileName); + if (modifiedSlice) + { + char* modifiedBuf = cJSON_GetObjectItem(modifiedSlice, "data")->valuestring; + int newSliceID = cJSON_GetObjectItem(modifiedSlice, "slice")->valueint; + + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Forwarding record to next hop modifed by command handler\n"); + w = SPP_forward_record(next_ssl, modifiedBuf, strlen(modifiedBuf) , SPP_get_slice_by_id(next_ssl, newSliceID), ctx, 1); + check_SSL_write_error(next_ssl, w, strlen(modifiedBuf)); + } + else + { + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Forwarding record to next hop unmodified\n"); + w = SPP_forward_record(next_ssl, buf,r , slice, ctx, 0); + check_SSL_write_error(next_ssl, w, r); + } + + free (jsonFileName); + cJSON_Delete(sliceRecord); + + + //this is probably not necessary... + if(r == 0 ) + { + break; + } + } + + // NEW SHUT DOWN + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Shutting down next hop\n"); + shut_down_connections(next_ssl); + DEBUG_PRINT("[MBOX DEBUG PREVHOP] Next hop shut down\n"); + + return(0); +} + +int handle_next_hop_data(SSL* prev_ssl, SSL* next_ssl) +{ + int r,w,status; + char buf[BUFSIZZ]; + SPP_SLICE *slice; + SPP_CTX *ctx; + + // Read HTTP GET (assuming a single read is enough) + while(1) + { + DEBUG_PRINT("[MBOX DEBUG NEXTHOP] Waiting to read data from next hop\n"); + + r = SPP_read_record(next_ssl, buf, BUFSIZZ, &slice, &ctx); + + status = SSL_get_error(next_ssl, r); + if (status == SSL_ERROR_ZERO_RETURN || status != SSL_ERROR_NONE) + { + printf("[MBOX ERROR NEXTHOP] Connection with next hop closed, exiting next hop handler and also closing previous hop connection\n"); + break; + } + else if (status != SSL_ERROR_NONE) + { + printf("[MBOX ERROR NEXTHOP] SSL read error code %d", status); + exit(-1); + } + + DEBUG_PRINT("[MBOX DEBUG NEXTHOP] Data received (from previous hop) (length %d bytes, slice %d: %s):\n", r, slice->slice_id, slice->purpose); + + cJSON* sliceRecord = create_slice_record("ServerToClient", buf, r, slice); + char* printStr = cJSON_Print(sliceRecord); + printf("[MBOX NEXTHOP] Received data (%d bytes)\n", r); + printf("%s\n", printStr); + COMMON_WriteJSONFile(sliceRecord, middlebox_id); + free(printStr); + + w = SPP_forward_record(prev_ssl, buf,r , slice, ctx, 0); + check_SSL_write_error(prev_ssl, w, r); + + // In theory this is not necessary + if(r == 0 ) + { + break; + } + } + + DEBUG_PRINT("[MBOX DEBUG NEXTHOP] Triggering connection with previous hop to close too\n"); + + return(0); +} + + + +int handle_data(SSL* prev_ssl, SSL* next_ssl) +{ + pid_t next_handler; + int status; + + DEBUG_PRINT("[MBOX DEBUG] Initializing data handlers\n"); + + next_handler = fork(); + if(next_handler == 0) + { + //child process + // handle traffic from client + handle_previous_hop_data(prev_ssl, next_ssl); + DEBUG_PRINT("[MBOX DEBUG] Exiting previous hop handler\n"); + //TODO: wait for child before returning + exit(0); + } + else + { + //parent + handle_next_hop_data(prev_ssl, next_ssl); + DEBUG_PRINT("[MBOX DEBUG] Exiting next hop handler\n"); + } + + DEBUG_PRINT("[MBOX DEBUG] Waiting previous hop handler to quit before quiting data handler\n"); + + wait(&status); + + //CLEAN UP + close(SSL_get_fd(next_ssl)); + close(SSL_get_fd(prev_ssl)); + + //CLEAN UP + SSL_free(next_ssl); + //SSL_free(prev_ssl); + + DEBUG_PRINT("[MBOX DEBUG] Exiting data handler!\n"); + + return 0; +} + + + + +int main(int argc, char **argv) +{ + int sock, s; + BIO *sbio; + SSL_CTX *ctx; + SSL *ssl; + int r; + pid_t pid; + int port = 8423; + char *prxy_address = "127.0.0.1:8423"; + SSL* ssl_next = NULL; + char buf[BUFSIZZ]; + int ret; + + if (argc < 4) + { + printf ("Usage: mcmbox port proxy-address midlebox-id [command handler...]\n"); + exit(0); + } + port = atoi(argv[1]); + prxy_address = argv[2]; + middlebox_id = argv[3]; + DEBUG_PRINT("[MBOX DEBUG] port=%d prxy_address=%s id=%s\n", port, prxy_address, middlebox_id); + + + if (argc > 4) + { + char tempBuf[1024]; + memset(tempBuf, 0, 1024); + int written = 0; + for (int i = 4; i < argc; i++) + { + written += snprintf(tempBuf + written, 1024 - written, "%s ", argv[i]); + } + handler_command = strdup(tempBuf); + DEBUG_PRINT("[MOX DEBUG] Handler command = %s\n", handler_command); + } + else + { + DEBUG_PRINT("[MBOX DEBUG] Handler command not set\n"); + } + + // TO-DO: Actually check the return value of this e.g. if the files don't exist + int status = COMMON_InitializeSSLCtx(&ctx, KEYFILE, PASSWORD, CA_FILE, ID_MIDDLEBOX_MIN ); + load_dh_params(ctx,DHFILE); + + // Socket in listen state + sock = tcp_listen(port); + + // Wait for client request + int nConn = 0; + + while(1) + { + // keep track of number of connections + nConn++; + + if((s = accept(sock, 0, 0)) < 0) + { + printf("[MBOX ERROR] Problem socket accept\n"); + } + + signal(SIGCHLD, SIG_IGN); + // fork a new proces + if((pid = fork())) + { + close(s); + } + else + { + sbio = BIO_new_socket(s, BIO_NOCLOSE); + ssl = SSL_new(ctx); + SSL_set_bio(ssl, sbio, sbio); + + if ((r = SPP_proxy(ssl, prxy_address, SPP_Callback, &ssl_next)) <= 0) + { + printf ("[MBOX ERROR] SPP proxy error"); + } + else + { + DEBUG_PRINT("[MBOX DEBUG] SPP proxy OK\n"); + } + + // Set server URL + //char* targetServercopy = "127.0.0.1:4433"; + //ssl->spp_server_address = targetServercopy; + + handle_data(ssl, ssl_next); + + // Close socket + close(s); + + // Exit child thread + exit(0); + } + } + + // Clean context + COMMON_DestroyCtx(ctx); + + // Exit + exit(0); +} + + + + diff --git a/evaluation/demonstration/server b/evaluation/demonstration/server new file mode 100755 index 0000000000000000000000000000000000000000..071b9badd400f948a0cca73582d7397efcc7a082 Binary files /dev/null and b/evaluation/demonstration/server differ diff --git a/evaluation/demonstration/server.c b/evaluation/demonstration/server.c index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..719984f7312d53bc5596c0f70f80ad41bd404e80 100644 --- a/evaluation/demonstration/server.c +++ b/evaluation/demonstration/server.c @@ -0,0 +1,403 @@ +#include "common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "cJSON.h" + +#define CA_LIST "ca.pem" +#define KEYFILE "server.pem" +#define PASSWORD "password" +#define DHFILE "dh1024.pem" +#define BUFSIZZ 20000 +#define DISABLE_NAGLE 0 + + +#ifdef DEBUG +#define DEBUG_PRINT(...) do{ fprintf( stdout, __VA_ARGS__ ); } while( false ) +#else +#define DEBUG_PRINT(...) do{ } while ( false ) +#endif + +char* handler_command = NULL; + +// ------------------------------------------------------------- +// Load parameters from "dh1024.pem" +// ------------------------------------------------------------- +void load_dh_params(SSL_CTX *ctx, char *file) +{ + DH *ret=0; + BIO *bio; + + if ((bio=BIO_new_file(file,"r")) == NULL) + { + printf ("[SERVER ERROR] Couldn't open DH file %s\n", file); + exit(0); + } + + ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + if(SSL_CTX_set_tmp_dh(ctx,ret) < 0) + { + printf ("[SERVER ERROR] Couldn't set DH parameters\n"); + exit(0); + } +} + +// ------------------------------------------------------------- +// Listen TCP socket +// ------------------------------------------------------------- +int tcp_listen(){ + + int sock; + struct sockaddr_in sin; + int val = 1; + + // Create socket, allocate memory and set sock options + if((sock=socket(AF_INET,SOCK_STREAM,0)) < 0) + { + printf("[SERVER] Couldn't make socket"); + exit(-1); + } + + memset(&sin, 0, sizeof(sin)); + sin.sin_addr.s_addr = INADDR_ANY; + sin.sin_family = AF_INET; + sin.sin_port = htons(DEFAULT_SERVER_PORT); + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val,sizeof(val)); + +/* + if (DISABLE_NAGLE == 1) + set_nagle(sock, 1); +*/ + + // Bind to socket + if(bind(sock,(struct sockaddr *)&sin, sizeof(sin))<0) + { + printf ("[SERVER] Could not bind to port %d", sin.sin_port); + } + + // Listen to socket + listen(sock,5); + + // Return socket descriptor + return(sock); +} + +// ------------------------------------------------------------- +// Check for SSL_write error (just write at this point) +// -- TO DO: check behavior per slice +// ------------------------------------------------------------- +void check_SSL_write_error(SSL *ssl, int r, int request_len) +{ + int errorCode = SSL_get_error(ssl, r); + switch(errorCode) + { + case SSL_ERROR_NONE: + if(request_len != r) + { + printf("[SERVER ERROR] Incomplete write!"); + exit(1); + } + break; + + default: + { + printf("[SERVER ERROR] SSL error %d", errorCode); + exit(1); + } + } +} + + + +cJSON* createErrorResponse (cJSON* recvData) +{ + cJSON* root = cJSON_CreateObject(); + cJSON* sliceArray = cJSON_AddArrayToObject(root, "slices"); + + cJSON* inputSlices = cJSON_GetObjectItem(recvData, "slices"); + cJSON* inputSlice = NULL; + cJSON_ArrayForEach(inputSlice, inputSlices) + { + cJSON* outputSlice = cJSON_CreateObject(); + cJSON_AddNumberToObject(outputSlice, "slice", cJSON_GetObjectItem(inputSlice, "slice")->valueint); + cJSON_AddStringToObject(outputSlice, "data", "Error"); + cJSON_AddItemToArray(sliceArray, outputSlice); + } + return root; +} + + +cJSON* call_response_handler(char* inputJsonFile, cJSON* recvData) +{ + DEBUG_PRINT("[SERVER DEBUG] Calling response handler with file %s\n", inputJsonFile); + + char commandBuf[256]; + sprintf(commandBuf, "%s %s", handler_command, inputJsonFile); + + int bufLen = 0; + char* response = COMMON_CallExternalProcess(commandBuf, &bufLen); + + DEBUG_PRINT ("[SERVER DEBUG] Received %lu bytes from handler\n", strlen(response)); + cJSON* returnJson = cJSON_Parse(response); + if (returnJson) return returnJson; + + printf ("[SERVER ERROR] Could not parse json from command handler %s - received { %s }\n", handler_command, response); + return createErrorResponse(recvData); +} + + +// ------------------------------------------------------------- +// Serve requests in browser-like mode +// ------------------------------------------------------------- +int send_response(SSL *ssl, int s, char *proto) +{ + DEBUG_PRINT("[SERVER DEBUG] Send_response() called\n"); + + SPP_SLICE *slice; + SPP_CTX *ctx; + char buf[BUFSIZZ]; + int errorCode = SSL_ERROR_NONE; + int expectedSlices = 0; + int slicesSeen = 0; + cJSON* recvData = cJSON_CreateObject(); + cJSON* sliceDataArray = cJSON_AddArrayToObject(recvData, "slices"); + + while ( (errorCode == SSL_ERROR_NONE) && ( expectedSlices == 0 || expectedSlices > slicesSeen)) + { + if (expectedSlices == 0) + { + DEBUG_PRINT("[SERVER DEBUG] Entering read loop for first time\n"); + } + else + { + DEBUG_PRINT("[SERVER DEBUG] Entering read loop, seen %d / %d slices\n", slicesSeen, expectedSlices); + } + + DEBUG_PRINT("[SERVER DEBUG] Reading SPP record\n"); + int r = SPP_read_record(ssl, buf, BUFSIZZ, &slice, &ctx); + errorCode = SSL_get_error(ssl, r); + if (errorCode != SSL_ERROR_NONE) + { + printf("[SERVER ERROR] SSL read error code %d\n", errorCode); + break; + } + + if (expectedSlices == 0) + { + expectedSlices = ssl->slices_len; + DEBUG_PRINT("[SERVER DEBUG] Expecting %lu slices\n", ssl->slices_len); + } + + DEBUG_PRINT("[SERVER DEBUG] Read %d bytes from slice %d (%s)\n", r, slice->slice_id, slice->purpose); + DEBUG_PRINT("[SERVER DEBUG] { %s }\n", buf); + + // Print proxies + for (int i = 0; i < ssl->proxies_len; i++) + { + DEBUG_PRINT(" [SERVER DEBUG] Proxy: %s\n", ssl->proxies[i]->address); + } + for (int i = 0; i < ssl->slices_len; i++) + { + DEBUG_PRINT(" [SERVER DEBUG] Slice with ID %d and purpose %s\n", ssl->slices[i]->slice_id, ssl->slices[i]->purpose); + } + slicesSeen++; + + cJSON* sliceData = cJSON_CreateObject(); + cJSON_AddNumberToObject(sliceData, "slice", slice->slice_id); + cJSON_AddStringToObject(sliceData, "slicePurpose", slice->purpose); + cJSON_AddStringToObject(sliceData, "data", COMMON_MakeNullTerminatedCopy(buf, r)); + cJSON_AddItemToArray(sliceDataArray, sliceData); + } + + char* sliceDataString = cJSON_Print(recvData); + printf("[SERVER] Received\n%s\n", sliceDataString); + free(sliceDataString); + + char* filename = COMMON_WriteJSONFile(recvData, "Server"); + DEBUG_PRINT("[SERVER DEBUG] Data written to %s\n", filename); + cJSON* responseData = call_response_handler(filename, recvData); + + char* responseDataStr = cJSON_Print(responseData); + printf("[SERVER] Returning following data\n"); + printf("%s\n", responseDataStr); + + cJSON* responseSlices = cJSON_GetObjectItem(responseData, "slices"); + cJSON* outputSlice = NULL; + cJSON_ArrayForEach(outputSlice, responseSlices) + { + int sliceIndex = cJSON_GetObjectItem(outputSlice, "slice")->valueint; + char* sliceData = cJSON_GetObjectItem(outputSlice, "data")->valuestring; + + DEBUG_PRINT("[SERVER DEBUG] Writing %lu bytes as record to slice %d\n", strlen(sliceData), sliceIndex); + int r = SPP_write_record(ssl, sliceData, strlen(sliceData), SPP_get_slice_by_id(ssl, sliceIndex)); + check_SSL_write_error(ssl, r, strlen(sliceData)); + } + + free(filename); + cJSON_Delete(recvData); + cJSON_Delete(responseData); + + DEBUG_PRINT ("[SERVER DEBUG] Shutting down SSL\n"); + int r = SSL_shutdown(ssl); + if( !r ) + { + shutdown(s, 1); + r = SSL_shutdown(ssl); + } + + // Verify that shutdown was good + switch(r){ + case 1: + break; // Success + case 0: + case -1: + default: // Error + printf ("[SERVER ERROR] Shutdown failed with code %d\n", r); + exit(1); + } + // free SSL + SSL_free(ssl); + + return 0; +} + +// Main function +int main(int argc, char **argv) +{ + BIO *sbio; + SSL *ssl; + SSL_CTX *ctx; + char* proto = "spp"; + int sock, newsock; + int pid; + int status; + + if (argc == 1) + { + // If no handler is specified, simply echo the data received from the client + handler_command = "cat"; + } + else + { + char tempBuf[1024]; + memset(tempBuf, 0, 1024); + int written = 0; + for (int i = 1; i < argc; i++) + { + written += snprintf(tempBuf + written, 1024 - written, "%s ", argv[i]); + } + handler_command = strdup(tempBuf); + } + + + // Print out configuration + DEBUG_PRINT("[SERVER DEBUG] Server starting\n"); + DEBUG_PRINT("[SERVER DEBUG] Configuration:\n"); + DEBUG_PRINT("[SERVER DEBUG] KeyFile: %s\n", KEYFILE); + DEBUG_PRINT("[SERVER DEBUG] DHFile: %s\n", DHFILE); + DEBUG_PRINT("[SERVER DEBUG] Proto: %s\n", proto); + DEBUG_PRINT("[SERVER DEBUG] Handler command { %s }\n", handler_command); + + // Build SSL context + DEBUG_PRINT("[SERVER DEBUG] Initialising ctx\n"); + status = COMMON_InitializeSSLCtx(&ctx, KEYFILE, PASSWORD, CA_LIST, ID_SERVER); + DEBUG_PRINT("[SERVER DEBUG] Loading DH parameters\n"); + load_dh_params(ctx, DHFILE); + + // Listen on socket + DEBUG_PRINT("[SERVER DEBUG] Listening on TCP port %d\n", DEFAULT_SERVER_PORT); + sock = tcp_listen(); + + int nConn = 0; + bool report = true; + while (1) + { + DEBUG_PRINT("[SERVER DEBUG] Waiting on TCP accept...\n"); + newsock = accept(sock, 0, 0); + if (newsock < 0) + { + printf("[SERVER ERROR] Socket accept failed with code %d\n", newsock); + exit(1); + } + else + { + DEBUG_PRINT("[SERVER DEBUG] Accepted new connection %d\n", sock); + } + + // Keep track of number of connections + nConn++; + DEBUG_PRINT("[SERVER DEBUG] %d connections\n", nConn); + + // Fork a new process + signal(SIGCHLD, SIG_IGN); + pid = fork(); + if (pid == 0) + { + // In child process + if (pid == -1) + { + printf ("[SERVER ERROR] Forking process for new connection failed"); + exit(1); + } + + DEBUG_PRINT("[SERVER DEBUG] child process close old socket and operate on new one\n"); + close(sock); + sbio = BIO_new_socket(newsock, BIO_NOCLOSE); + ssl = SSL_new(ctx); + SSL_set_bio(ssl, sbio, sbio); + + // Wait on SSL Accept + int sslAcceptResult = SSL_accept(ssl); + + X509* server_cert = SSL_get_certificate(ssl); + printf ("[SERVER] Server certificate:\n"); + COMMON_PrintCertificateDetails(server_cert); + X509_free(server_cert); + + X509* client_cert = SSL_get_peer_certificate(ssl); + printf ("[Server] Client certificate:\n"); + COMMON_PrintCertificateDetails(client_cert); + X509_free(client_cert); + + if (sslAcceptResult <= 0) + { + printf("[SERVER ERROR] SSL accept error\n"); + exit(0); + } + else + { + DEBUG_PRINT("[SERVER DEBUG] SPP accept OK\n"); + } + + // Send a response back + DEBUG_PRINT("[SERVER DEBUG] Sending response back\n"); + send_response(ssl, newsock, proto); + + // Correctly end child process + DEBUG_PRINT("[SERVER DEBUG] Ending child process\n"); + shutdown(newsock, SHUT_RDWR); + close(newsock); + exit(0); + } + else + { + DEBUG_PRINT("[SERVER DEBUG] Parent process closing new socket\n"); + close(newsock); + } + } + + // Wait for forked process to complete + wait(&status); + + // Clean context + COMMON_DestroyCtx(ctx); + + // Correctly end parent process + exit(0); +} \ No newline at end of file