From 503bd2fd6a4655b0f97a84e8b6a30d0ece6618da Mon Sep 17 00:00:00 2001 From: Marina Date: Fri, 23 May 2025 02:38:53 +0300 Subject: [PATCH] add new --- CmakeLists.txt | 14 + cJSON.c | 3191 ++++++++++++++++++++++++++++++++++++++++++++++ cJSON.h | 307 +++++ client.c | 87 ++ server.c | 180 +++ settings.json | 11 + system_data.json | 100 ++ system_load.png | Bin 0 -> 21262 bytes tasks.json | 29 + 9 files changed, 3919 insertions(+) create mode 100644 CmakeLists.txt create mode 100644 cJSON.c create mode 100644 cJSON.h create mode 100644 client.c create mode 100644 server.c create mode 100644 settings.json create mode 100644 system_data.json create mode 100644 system_load.png create mode 100644 tasks.json diff --git a/CmakeLists.txt b/CmakeLists.txt new file mode 100644 index 0000000..1d70f78 --- /dev/null +++ b/CmakeLists.txt @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 3.10) + +# Укажите путь к vcpkg, если он не установлен глобально +set(CMAKE_TOOLCHAIN_FILE "C:/vcpkg/scripts/buildsystems/vcpkg.cmake" CACHE STRING "Vcpkg toolchain file") + +project(MyProject) + +find_package(json-c CONFIG REQUIRED) + +add_executable(client client.c) +target_link_libraries(client PRIVATE json-c) + +add_executable(server server.c) +target_link_libraries(server PRIVATE json-c) \ No newline at end of file diff --git a/cJSON.c b/cJSON.c new file mode 100644 index 0000000..3873ab1 --- /dev/null +++ b/cJSON.c @@ -0,0 +1,3191 @@ +/* + 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 +#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 */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +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(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* 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 != 18) + #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 *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL 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 + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +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); + item->valuestring = NULL; + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + item->string = NULL; + } + 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; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + size_t number_string_length = 0; + cJSON_bool has_decimal_point = false; + + 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; 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_string_length++; + break; + + case '.': + number_string_length++; + has_decimal_point = true; + break; + + default: + goto loop_end; + } + } +loop_end: + /* malloc for temporary buffer, add 1 for '\0' */ + number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1); + if (number_c_string == NULL) + { + return false; /* allocation failure */ + } + + memcpy(number_c_string, buffer_at_offset(input_buffer), number_string_length); + number_c_string[number_string_length] = '\0'; + + if (has_decimal_point) + { + for (i = 0; i < number_string_length; i++) + { + if (number_c_string[i] == '.') + { + /* replace '.' with the decimal point of the current locale (for strtod) */ + number_c_string[i] = decimal_point; + } + } + } + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + /* free the temporary buffer */ + input_buffer->hooks.deallocate(number_c_string); + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)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); + /* free the temporary buffer */ + input_buffer->hooks.deallocate(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 <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + size_t v1_len; + size_t v2_len; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + /* return NULL if the object is corrupted or valuestring is NULL */ + if (object->valuestring == NULL || valuestring == NULL) + { + return NULL; + } + + v1_len = strlen(valuestring); + v2_len = strlen(object->valuestring); + + if (v1_len <= v2_len) + { + /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */ + if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring )) + { + return NULL; + } + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +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; + } + + 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); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* 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] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + 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) || !compare_double((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 occurred */ + 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); + output = NULL; + } + + 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; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + 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; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, 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 || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + 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); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 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); + buffer->buffer = NULL; + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + if (printed != NULL) + { + hooks->deallocate(printed); + printed = NULL; + } + + 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); + p.buffer = NULL; + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + 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--; + + if (head != NULL) { + head->prev = current_item; + } + + 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; + } + + if (cannot_access_at_index(input_buffer, 1)) + { + goto fail; /* nothing comes after the comma */ + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed 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--; + + if (head != NULL) { + head->prev = current_item; + } + + 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) + (size_t)(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) && (current_element->string != 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; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + 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) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return 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) || (object == item)) + { + 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(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + 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) || (item != parent->child && item->prev == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* 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; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* 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(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0 || newitem == NULL) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + if (after_inserted != array->child && after_inserted->prev == NULL) { + /* return false if after_inserted is a corrupted array item */ + return false; + } + + 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; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (parent->child == 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 (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + 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); + if (replacement->string == NULL) + { + return false; + } + + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return 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 boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? 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 <= (double)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; + } + + if (a && a->child) { + a->child->prev = 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; + } + + if (a && a->child) { + a->child->prev = 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; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *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; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse); + +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + return cJSON_Duplicate_rec(item, 0, recurse ); +} + +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, 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) + { + if(depth >= CJSON_CIRCULAR_LIMIT) { + goto fail; + } + newchild = cJSON_Duplicate_rec(child, depth + 1, 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; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* 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))) + { + 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 (compare_double(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); + object = NULL; +} \ No newline at end of file diff --git a/cJSON.h b/cJSON.h new file mode 100644 index 0000000..7ae4d59 --- /dev/null +++ b/cJSON.h @@ -0,0 +1,307 @@ + +/* + 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 + +#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 3 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 + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* 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 CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#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 + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 18 + +#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 +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* 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 + +/* Limits the length of circular references can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_CIRCULAR_LIMIT +#define CJSON_CIRCULAR_LIMIT 10000 +#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); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* 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); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, 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 *item); + +/* 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 item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const 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/array 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. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +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 *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) 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(cJSON_bool) 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(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach 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(cJSON_bool) 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(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) 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); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +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)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/ +#define cJSON_SetBoolValue(object, boolValue) ( \ + (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \ + (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \ + cJSON_Invalid\ +) + +/* 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 diff --git a/client.c b/client.c new file mode 100644 index 0000000..e00ecda --- /dev/null +++ b/client.c @@ -0,0 +1,87 @@ +#include +#include +#include +#include +#include +#include + +#include "cJSON.h" + +#define PORT 9999 +#define SERVER_ADDRESS "127.0.0.1" +#define SLEEP_TIME 5 // Increased for better visibility + +double getCpuUsage() { + return (double)(rand() % 100); +} + +double getAvailableMemory() { + return (double)(rand() % 100); +} + +int main() { + SOCKET clientSocket = INVALID_SOCKET; + struct sockaddr_in serverAddress; + WSADATA wsaData; + + int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData); + if (iResult != 0) { + printf("WSAStartup failed with error: %d\n", iResult); + return 1; + } + + clientSocket = socket(AF_INET, SOCK_STREAM, 0); + if (clientSocket == INVALID_SOCKET) { + fprintf(stderr, "Socket creation error with error: %d\n", WSAGetLastError()); + WSACleanup(); + return -1; + } + + memset(&serverAddress, 0, sizeof(serverAddress)); + serverAddress.sin_family = AF_INET; + serverAddress.sin_addr.s_addr = inet_addr(SERVER_ADDRESS); + serverAddress.sin_port = htons(PORT); + + if (connect(clientSocket, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR) { + fprintf(stderr, "Connection failed with error: %d\n", WSAGetLastError()); + closesocket(clientSocket); + WSACleanup(); + return -1; + } + + srand(time(NULL)); + + char dataBuffer[1024]; + + while (1) { + double cpuUsage = getCpuUsage(); + double availableMemory = getAvailableMemory(); + + cJSON *jsonData = cJSON_CreateObject(); + cJSON_AddNumberToObject(jsonData, "cpuUsage", cpuUsage); + cJSON_AddNumberToObject(jsonData, "availableMemory", availableMemory); + + char *jsonString = cJSON_PrintUnformatted(jsonData); + if (jsonString == NULL) { + fprintf(stderr, "Failed to print JSON.\n"); + cJSON_Delete(jsonData); + closesocket(clientSocket); + WSACleanup(); + return 1; + } + + snprintf(dataBuffer, sizeof(dataBuffer), "%s", jsonString); + send(clientSocket, dataBuffer, (int)strlen(dataBuffer), 0); + + printf("Sent: CPU Usage: %f, Available Memory: %f\n", cpuUsage, availableMemory); + + cJSON_Delete(jsonData); + free(jsonString); + + Sleep(SLEEP_TIME * 1000); + } + + closesocket(clientSocket); + WSACleanup(); + return 0; +} diff --git a/server.c b/server.c new file mode 100644 index 0000000..f65599a --- /dev/null +++ b/server.c @@ -0,0 +1,180 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "cJSON.h" + +#define PORT 9999 +#define BUFFER_SIZE 1024 +#define HISTORY_SIZE 100 + +typedef struct { + double cpuUsage[HISTORY_SIZE]; + double availableMemory[HISTORY_SIZE]; + int currentIndex; + pthread_mutex_t dataMutex; +} SystemData; + +SystemData system_data; + +void initializeSystemData() { + for (int i = 0; i < HISTORY_SIZE; i++) { + system_data.cpuUsage[i] = 0.0; + system_data.availableMemory[i] = 0.0; + } + system_data.currentIndex = 0; + pthread_mutex_init(&system_data.dataMutex, NULL); +} +void addSystemData(double cpuLoad, double memoryAvailable) { + pthread_mutex_lock(&system_data.dataMutex); + system_data.cpuUsage[system_data.currentIndex] = cpuLoad; + system_data.availableMemory[system_data.currentIndex] = memoryAvailable; + system_data.currentIndex = (system_data.currentIndex + 1) % HISTORY_SIZE; + pthread_mutex_unlock(&system_data.dataMutex); +} + +void generateDataFile() { + FILE *dataFile = fopen("system_data.json", "w"); + + pthread_mutex_lock(&system_data.dataMutex); + for (int i = 0; i < HISTORY_SIZE; i++) { + int index = (system_data.currentIndex + i) % HISTORY_SIZE; // Corrected Indexing + fprintf(dataFile, "%d %f %f\n", i, system_data.cpuUsage[index], system_data.availableMemory[index]); + } + pthread_mutex_unlock(&system_data.dataMutex); + + fclose(dataFile); +} + +void generateGnuplotScript() { + FILE *plotScript = fopen("plot_script.gp", "w"); + + fprintf(plotScript, "set terminal png size 800,600\n"); + fprintf(plotScript, "set output 'system_load.png'\n"); + fprintf(plotScript, "set title 'System Performance'\n"); + fprintf(plotScript, "set xlabel 'Time'\n"); + fprintf(plotScript, "set ylabel 'Percentage'\n"); + fprintf(plotScript, "plot 'system_data.json' using 1:2 with lines title 'CPU Usage', \\\n"); + fprintf(plotScript, " 'system_data.json' using 1:3 with lines title 'Available Memory'\n"); + + fclose(plotScript); +} +void generatePlot() { + generateDataFile(); + generateGnuplotScript(); + system("gnuplot plot_script.gp"); +} + +// Client handling thread +void *handleClient(void *socketDescriptor) { + SOCKET clientSocket = *(SOCKET*)socketDescriptor; // Changed to SOCKET + char dataBuffer[BUFFER_SIZE]; + int bytesRead; + + while ((bytesRead = recv(clientSocket, dataBuffer, BUFFER_SIZE - 1, 0)) > 0) { + dataBuffer[bytesRead] = '\0'; + + cJSON *jsonData = cJSON_Parse(dataBuffer); + if (jsonData == NULL) { + const char *errorPointer = cJSON_GetErrorPtr(); + break; + } + + cJSON *cpuUsageJson = cJSON_GetObjectItemCaseSensitive(jsonData, "cpuUsage"); + cJSON *availableMemoryJson = cJSON_GetObjectItemCaseSensitive(jsonData, "availableMemory"); + + if (cJSON_IsNumber(cpuUsageJson) && cJSON_IsNumber(availableMemoryJson)) { + double cpuLoad = cpuUsageJson->valuedouble; + double memoryAvailable = availableMemoryJson->valuedouble; + + printf("Received: CPU Usage: %f, Available Memory: %f\n", cpuLoad, memoryAvailable); + addSystemData(cpuLoad, memoryAvailable); + generatePlot(); + } + + cJSON_Delete(jsonData); + } + + closesocket(clientSocket); // Use closesocket on Windows + free(socketDescriptor); + return NULL; +} + + +int main() { + SOCKET serverSocket, clientSocket, *newSocketPtr; // Changed to SOCKET + struct sockaddr_in serverAddress; + int addressLength = sizeof(serverAddress); + pthread_t threadId; + WSADATA wsaData; //needed for winsock + + // Initialize Winsock + int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData); // Request version 2.2 + if (iResult != 0) { + printf("WSAStartup failed with error: %d\n", iResult); + return 1; + } + + + initializeSystemData(); + + // Create socket + if ((serverSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { // Changed to INVALID_SOCKET + fprintf(stderr, "socket failed with error: %d\n", WSAGetLastError()); // Windows error reporting + WSACleanup(); + exit(EXIT_FAILURE); + } + + serverAddress.sin_family = AF_INET; + serverAddress.sin_addr.s_addr = INADDR_ANY; + serverAddress.sin_port = htons(PORT); + + // Bind socket + if (bind(serverSocket, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR) { // Changed to SOCKET_ERROR + fprintf(stderr, "bind failed with error: %d\n", WSAGetLastError()); + closesocket(serverSocket); + WSACleanup(); + exit(EXIT_FAILURE); + } + + // Listen for connections + if (listen(serverSocket, 3) == SOCKET_ERROR) { // Changed to SOCKET_ERROR + fprintf(stderr, "listen failed with error: %d\n", WSAGetLastError()); + closesocket(serverSocket); + WSACleanup(); + exit(EXIT_FAILURE); + } + + puts("Server listening..."); + + while (1) { + // Accept connection + if ((clientSocket = accept(serverSocket, (struct sockaddr *)&serverAddress, (int*)&addressLength)) == INVALID_SOCKET) { // Changed to SOCKET and cast addrlen + fprintf(stderr, "accept failed with error: %d\n", WSAGetLastError()); + continue; + } + puts("Connection accepted"); + + newSocketPtr = malloc(sizeof(SOCKET)); // Allocate enough space for a SOCKET + *newSocketPtr = clientSocket; + + // Create thread to handle the client + if (pthread_create(&threadId, NULL, handleClient, (void*) newSocketPtr) != 0) { //Condition changed since pthread_create on windows returns 0 on success + perror("could not create thread"); + free(newSocketPtr); + closesocket(clientSocket); + continue; + } + + pthread_detach(threadId); + } + + closesocket(serverSocket); // Use closesocket on Windows + WSACleanup(); + pthread_mutex_destroy(&system_data.dataMutex); + return 0; +} \ No newline at end of file diff --git a/settings.json b/settings.json new file mode 100644 index 0000000..e4f774c --- /dev/null +++ b/settings.json @@ -0,0 +1,11 @@ + { + "C_Cpp.intelliSenseEngine": "default", + "C_Cpp.default.compilerPath": "C:\msys64\mingw64\bin\gcc.exe", // Укажите путь к вашему gcc.exe + "C_Cpp.default.cStandard": "c11", + "C_Cpp.default.cppStandard": "c++11", + "C_Cpp.default.includePath": [ + "${workspaceFolder}/Ⓑ", + "C:\msys64\mingw64\include" // Добавьте путь к заголовочным файлам MinGW + ] + } + diff --git a/system_data.json b/system_data.json new file mode 100644 index 0000000..dafd564 --- /dev/null +++ b/system_data.json @@ -0,0 +1,100 @@ +0 0.000000 0.000000 +1 0.000000 0.000000 +2 0.000000 0.000000 +3 0.000000 0.000000 +4 0.000000 0.000000 +5 0.000000 0.000000 +6 0.000000 0.000000 +7 0.000000 0.000000 +8 0.000000 0.000000 +9 0.000000 0.000000 +10 0.000000 0.000000 +11 0.000000 0.000000 +12 0.000000 0.000000 +13 0.000000 0.000000 +14 0.000000 0.000000 +15 0.000000 0.000000 +16 0.000000 0.000000 +17 0.000000 0.000000 +18 0.000000 0.000000 +19 0.000000 0.000000 +20 0.000000 0.000000 +21 0.000000 0.000000 +22 0.000000 0.000000 +23 0.000000 0.000000 +24 0.000000 0.000000 +25 0.000000 0.000000 +26 0.000000 0.000000 +27 0.000000 0.000000 +28 0.000000 0.000000 +29 0.000000 0.000000 +30 0.000000 0.000000 +31 0.000000 0.000000 +32 0.000000 0.000000 +33 0.000000 0.000000 +34 0.000000 0.000000 +35 0.000000 0.000000 +36 0.000000 0.000000 +37 0.000000 0.000000 +38 0.000000 0.000000 +39 0.000000 0.000000 +40 0.000000 0.000000 +41 0.000000 0.000000 +42 0.000000 0.000000 +43 0.000000 0.000000 +44 0.000000 0.000000 +45 0.000000 0.000000 +46 0.000000 0.000000 +47 0.000000 0.000000 +48 0.000000 0.000000 +49 0.000000 0.000000 +50 0.000000 0.000000 +51 0.000000 0.000000 +52 0.000000 0.000000 +53 0.000000 0.000000 +54 0.000000 0.000000 +55 0.000000 0.000000 +56 0.000000 0.000000 +57 0.000000 0.000000 +58 0.000000 0.000000 +59 0.000000 0.000000 +60 0.000000 0.000000 +61 0.000000 0.000000 +62 0.000000 0.000000 +63 0.000000 0.000000 +64 0.000000 0.000000 +65 0.000000 0.000000 +66 0.000000 0.000000 +67 0.000000 0.000000 +68 0.000000 0.000000 +69 0.000000 0.000000 +70 0.000000 0.000000 +71 0.000000 0.000000 +72 0.000000 0.000000 +73 0.000000 0.000000 +74 0.000000 0.000000 +75 0.000000 0.000000 +76 0.000000 0.000000 +77 0.000000 0.000000 +78 0.000000 0.000000 +79 0.000000 0.000000 +80 0.000000 0.000000 +81 0.000000 0.000000 +82 0.000000 0.000000 +83 0.000000 0.000000 +84 0.000000 0.000000 +85 0.000000 0.000000 +86 0.000000 0.000000 +87 0.000000 0.000000 +88 0.000000 0.000000 +89 0.000000 0.000000 +90 0.000000 0.000000 +91 0.000000 0.000000 +92 0.000000 0.000000 +93 14.000000 35.000000 +94 50.000000 68.000000 +95 86.000000 42.000000 +96 45.000000 32.000000 +97 88.000000 73.000000 +98 80.000000 81.000000 +99 43.000000 8.000000 diff --git a/system_load.png b/system_load.png new file mode 100644 index 0000000000000000000000000000000000000000..54bc81f77d4d3e5c97862919d4d83c4f27e0a815 GIT binary patch literal 21262 zcma)k1zc6z`Yq?^Q4B&9kQM`JJxHe_h=71J2pdqOQz>bWQYI>;Al;21l7gs+MT;U<(r>KIIrpFUz31;<4zc&zbIm!w?;GD3W3Fqb)s?8WGH<1zprBGdsh~wcv0)Dd z#qS1`zvDObyXX(%KU*`}j`jHJ=<2Tin)01^ znjn2WfQD0xE{Q?*8+ZSGjTce7MUJ?<-_BNj^Ig;SrL?=ruY^C`nbvJpe#0Kbdf*(Z zd6UKMMr6ad8Iu=Ltl(bD^2}-D(1_q{6+J= zFXpUtSaB$}yZwfN&3rOu!+$PUaMobBhnco8;DUyN%Ylq0rMHcI7rsZ~1!H(u!Pyt5LU$e&Q@ZlU(aMV{UD2ZM^@g=h?Gom0oU1kivcJ5q0R?wR30Dx!UWpzKa-!@1%EM z7sfmo?_cFT@2DT_PA@Afs~XAwK*-|l+<4boYoDH;UQl3QkIziKjMvYhkWUn@R+twB z3kwTHMa7xO-!^O-DqsEaf+pYK(bu#XM_XIli|#!xjWY9n{?)W!uhPigm-Z}-kMFzu z+lGmKs7ix zSc1FbJRbCOqR0E$<=>c?nCe0~^ml!a&^Os3FDxSB&|P}rQ^8pi6O$J~R7(I~gJ>^t9st9!JniOEdA-WPSq z)P2>t|JALln`!2zrQEm zYiio}@ZrN7jE5#Vit1Whj~qGDI<%FNa;T%o%H7@F*LS7dZ8U(krltndmy?ro>eQ*9 zv$MH5Irck70=Ddoj-sUMuL}*me!YCexvHv4#(QoV8&f@2Qdd*+(WR-cf11A%cPe!L z^1RA-X<%?rUsu<{(sFLB!=*J%O@H}IaWESP2L}_Ap|NpyQ;RWM`G* zhMb(7I0Nb}S!BFiu~~F=Bbr%u?AXD`Xywz;&@hLw=jV&L8?wpyRnGQAA2j&>{d-(o zTtkk0`|Qh?3Rb)fw6ur4=j{7kEG$xK_x|~3^RLAYtN1OPw^=1xz77b`<+QZ4gop3q zR8UuM&<&oMosAW9iYv!m>G}Em{CuaC7k1k#upnQY&s$kZ z`HNdMuv-1VqF_@xtSTKT=jG#LqptgyYh-k)as_K^&%NV!TK5XymBm@?I4tfq27Yn> zRiBF&FP=Z2qS=4r#*Hp4vS!!Y`uf;E&4Z$%+Cz5iyK?oa)%*KXH%ynm_J_(jjy524 z9qjFI-n!-X7_Rt*pTtU7Vx1T)9-%1R(@NuOWER9kzyKBcCvZrftqWYtpM z4A1kBkPz%QOH0euUv+X-kzbxaf1bB{@XL$fKw9l|bzCe~65DGaIaId%D^30ZdpWu4 zw6wGx`%YB;Y*Bp|btqo^!dEObGc)sU6Wq0W_15uahpFb;YAJ*#^*xK32 z{rY@0e)-$Mc5!1fv(NOCHYp0njvZ@=#2B}7Vt3^I!ul*-I~ce7&vV4mu~92&X|?1S z7IiL0)LVvWNv1bR-?Mwjd|5qk1k>A1c+m2-Kd@6SpK}3ZO4Kejn#6& zg8Euvp-{8Cyt_cJ_vF+17_sW*>31AHKWZWcj3z23t6sf&W%p42h81@MzBEPh>ba{DM-_+L)k;Tr=E|5p0cQJ>~{Q-yF_jK5=t;t1R z=zk@_db_ex+Unin?5Owbh_1eV`wo|~i7#BI?(Ye(UVVYTAsJ{UpCEZ0wrY%{mlwa` zrKYAn9e+Xvi>%MD?lPAsLDFJO-|_&*+OIm~ zxawbDZ?v0uj}J8`zj^cKmB`FMeRh6+v((9F-mp2jX(W|VgYE*0+5gMwY z^!|H!FpJRn*UtmD>F1uA#brNy{8+WRI66E$jL#Ljs1SLV&Y`Eg81KAssLJ56wWgur zgGbF-Y`%*>4a;4JiyCFUhnfV_JCrS}ifhS^L}@HVmE7(Z#lmKYUi+ z%q-!>m!ZDuwJU#YLpCiMXn*(JND_%3@BMIsjA=YNmvx_9q6Oh<#%#*G_OQd1?&Y30wKKfl}b*4CcCHf%l< z;8knReCB;>?iU|l-`InPhWdQ3pKhPU4!|TdH8sV_cq4=*_t_w=&`9Cm-o4Mey6|-` z504GX4HDTaPU?E6mc6@mb+xs$e`aDLGlpv3qFbC`H0H=Tb=uirDBh8!9TQ&D5;if`YvzPVw0E<%3Rlp_TH!7Q36Jhk&$|5&PcipydQ2& zCzkA^5+wzN^FCwerlDOfZEA2U*Thd!@*Dh$cVIu`a zDW{-84KFY6^_w^Cd;GpU4@^o*8XB^;Qbk=u5C({TBFH>+T`1(FAdiQH=a&ofpGd_IPMK9m1_+wMk zo&d_NTZQN{@7=q1_C*jA>A-;lDB6C0e&fr=n!C1L!Oc6q|9PA~N4-G(q4=M+A2L>! z=KGLwPN?EV&d$yT2KR%5m9QO;9jgiT`?)VUJ0W2Y7uP`6{NvS>Yq!(51;u5Plgs*2 zx}8p3QFdcHm8I%j&9r4cHhg&gv1E;qdbx^<%2sOX+aV#Z-@bkO`t_$r=E3+!yH`R& zLRQxA{e1#$A~=DU`l@^@YIhJ5v4`#c#XV4V+efyIcWI{jsJa7hcnfFE6AHCZnKtIyo*F0U?Bl1>qHYf5}6Hq>htnA zu;9v7j^%_}DomD)qUP%4+G_r+!P@YwGd*2S!|N42(?BWpw=0(W@9VVJq)3JyjQ0@| z6m%ST{~$0h5Jeof#v*EeU&h;ATRZH}xCdH&>sfyz_P<&fm)c_f+G75| zt+0a{t8MvyB3S4re)R0@CTGrc9^>@=QL`C;nVXqmIc)X}$aki_dbQ2E+Gk-pTEuP> z74rumWWSX~0)jS(wUerRJZrDh1C5NfrZ)m?mje6(4oEruTApd7VV5oi((vfMP{-m_ z*?jD51qadPkuFH zxX7|zs60}TGOYHSf&fkP`2OZtTak+(&?0f+G2e`AmGsRi^h59B%dX@o_94P9s&g`%cv|%7=7zb^_xT+qF}(i00tdupMsRzAebjO)I}V6TkNU z?OXI?4XKPu{JY|PKhw0Rk_eMIOPkKgNB)nzeoMc7M#In!Np=P9rPoE41ebY`oxVXB!aKx&?RpEzY z5IW7vqqy!EYPVYs!^p_U!}u6EMFS(FrJBtgfJSl`=DfVU#Y9D){3>hyIzHaB*f4H7 z+28MiYhnqk&Y!=DZlx*V7;%@k?BXtcy#~BD)?L>6#d-gM0}`si=s!eba?wmRRQ&PB z9}*P-w3?cl4I3{sJd}_RK_0dHHRI}`SABz)f@1zN+A6>0UmktFC2sBL9{@1@)|UEA zXStA#4)OBZHd~(;#kbYBN1e*PM>3lFU|md?fAxp9wzSaE(V^1nnwnO7&I|zU%zg>x z5cMlGucPii?(AF;K0TUW?LJ`eswaRJ5L-T^$f}W=S$HUG=LIiK3Ab@Zj{v3FlkJ;+ zP(8ija+QaIqCBI!+nDnu0b2%cEi5d^hXA)3w$E9*+w>2dm-?wj{8%fT8 zwerQ6Psnvec0J{8tE;QHjJ?$flBUu(I+Cmuu~SQ%zSiDYSy{o|v|Yb`9lJSJ%45@} zO$~7}M!LEy%yc>U5MZ)fOh*QgP*IwZ*pU%Y>MJ}Zt8S0Z%*+6_0)zVc`s(WHo;#OR zUF~mZXn5hmqZeNc$}WCK6Q!!6!oY8^C*W`)H>sUb;LI)t21Mi|d|pb*eokz!eK+%v z0sq*vX#yYz1Hxorw3(Tima7Yro9S}+_7FqWv$Pz*nq9ea1@HvX@zi%|?$xUk$)j0Y zBJ)P^;e7ge+i7Sfv2D!E%urGN{8rsetIg|f;|3NM7qQQjl$1E6+}~R_HZ-74{Fs}= z*OMwLodsvFrl(t><;okKot-_gmwwl-T^t;8$aTQ2Ox0Td146a0=#RXY+#5ACJ^9l8 zUAxx?iqE|BJs$D6`4Y*=tbG@^#O>Wkk+4+m{N+lIqyI=|I)KOM$cTym$}Dnzs%liZ zWS(Fs5grrSrqzC^QU1&Q9LMG57w0F}rr#Z!#7yK>Ok8v`W>Z{HyC<@Npl-^aNKIC1 zYlhRvE&tdw*@_idTj^V)mj~7H^vCmU`cHe2suu?1tIxHI^d?G}GZ267Nm|LyuPW>s zzn=6^%40&V{7Z4g+UioD|Jn-j4gSfkEi@t`JT_B(yBIAveqHea%^>k%1<2G43=FrK zMR@n^OO9<{Bi+caUhT}u$kR|zc!`WCXj%nEgT|^Kzz`r%cIBrw-N)_d#IO-iAH2WaRT3nXpEvI3 z-yz!GFe@KIa2n`n#@n*n1xmULv5tJ37XD||SiNca{{EMTfwW)INdWwFfEp?8F8KfB zW|*UZtp5w+;!>rmMET`EvouTfVtvMs&ef`k^?+FTR{1&3d!h{U-xV)!WodD(;2p=_ z@0+wKD2(IL0C6e+1?G(&52hvvf@Vkl-;v#zOdI25_yWW){Yc0gotm1ud-pE-QiNhK z4F~o1?XGbTnP_S6L`J5Kdf|osC{Rqd#*HUONBIIys;Xw^f@k?TKksC1eV7?J4`s0&%-Phq#MpTE z;XQj2(3yc2K#+ie+bO?s^JWg|O9kj4!Bn)jw~No(0@NZd>rpzgvfjRbk2*RCH1Y7r z2)FJ9a8jS-=@dvrMf&v1JF9@Ev($>`Ud3^jS%9>R_nxKbU z^p?c7Q&IvjJ((&iEYzaBd;h+*&&pU)V*srZSQy{M$F%1L8)6%za?TXL?dz+qs_MPp zT05jK2ypIOXDRhrnhRJ zWMyTc2`!=Y#tLCubNK$eJB79}$5Z;kg$qmblVVv(z{p1|-~X7Nw&nZPpb^&6z~wL(N@^n&1P_h=RnsC376_iuYR_1|GeLRSA_{w8rjwmH*!>czv`;_KId_ zwJbOH>jjC!hfh;#o;fpOpP7+CE3cra$kX=^y;2#w0~z50KpLPjlKeqnhJ~Gh`cD%} zN<3zaJiWZ0lzO5H+$g{V^95u8xyWuy|6?12apk4v*N=b%(8F|ItDGsi7$#LGjQX4M z{{4HyB1?&R$8DUltH1g&g_B(+lYeby{{?!0gMlG3EDYg+eoOMgR|U?O=vGSpTj{^; zPAo-3rGih)ci~3T@4x>ZK#LGz6Si(DZnS%KlWEJAEuNm9$aJD6PkpY6+4}}#_XFWF z2>^d4>6(0Z?Q$pqQN!eaBKSqK&v3RtWbC&NhL!Y~&XL0D`00w5}&X3&sPgj3@d4XBan39l_ zlM_ew_*~P_`wtCMsl@L2(%P`v&-cukGd4DvU^I-b&W*M^p-n>FB^D0&G{%F}M->xu z`0N$hy@w7pdM4Q*J>}<5W@sjNE-HgFZPk$To%&jfE$e;hlCfKe`!q{b(KL^|N&v;> zyo2C!EsKg}_t*l80h+x!k%84xZ8~}SiDS7P^78V&)wvQd+!#>3zwE!IW7>4X60z6W<@}_1dEb^bxLy@=W&ZcfO#QaI0`CEr ztEyyiPYYIK<>H%BhUd;(Sg74U{DmO-n`J?i@}xd06tVwQ@cQ*@@RBIJtwU_0_9$or zNE3^5<19OOwpRPEff{}&>sy|Cq&wehWuz?|n1N~c?)xCM^bS!VAx;vMq9US3#5&Rh*&J?^;>daRNRc7T&0A2haX5w^yPodu#7)KnTI0|mrg0YLK zwU1vvS8tG~T%e_`t*fi1tZdV4VqjokVj>F+fd&@KC_CTnk{3cv5Hn)_j9(yMiQ0cU z4U!+t+Q4{p8tM<=HCE>5B=FMe3ZfYqhDFTrvFu6Qi=__9g_|LQGFQDoSPeP-g1r25 zl1EQl(mTfz({k503vOtI($!--Q64&r?K&bL#W~)QilPKJssn)n`@*j5QcH^Rty{NH z(%IPPK`41o_)zO11|V8ZjE>r|y0{@B|NQBys0oI+eer8h&?Zg=jB#mR=gjb(rr#)z z>RX0W<|?y*T9IA;as256>{w_Cq;{f(K?})!eHvt-#G!`9MjC2r>TTQX*5bVQ*rYK_ zO|#ZoC0)DhS~fA-Uvzr6&Rm7vy9Y*p-`>4ol7xhW0M)^Yd>Lt?pg0<3_5E0KEO!l^ z{I`LDw3L+haWWNvEz;6HC|@&!jUH~Nu^re9Jex9F+P2wVZ~2~%UBZ87`a)Gwi0RGi z4$Zwg$^!WM6v3RCJ#d^7#EzigD_g4|_7DF+!{%Gqkfi|;`EQBlgret)RQxxr&SyIN zi`W^5A8@6{(i1}F&PVI2<{VkiJk|QouQgF)p?|KEg8%-9|MKpebesft2<3y2M%RB3 z<{8f+Upj>Rabb^$5PEig{dYJ2{nr04aqy5Bx|tAxgDFnEVkgFZWLTb2o?HHrr8vP< zd|tizJ)1E?`{Q;~k9^ zC?*ubTJk>a3RZkkCRF1E-2(JrPo>3V@6&gY0;;O2d;$Wo5-tOXF}a0rJM{yJxH{os zShENzv$eH#!|%UGi(&ncaJtb4fZ17HX!K{Nr!PMHVv|0xI^99Msia38(%q6Z5Gu|* zwr+;B!%j!{)xOgCi#$4PSJ%fy2e`PnkVENz!_<`|4Y%ZRJ62tZh>p(6vIQA8b0XPz zHv_|f{T3=JfkTJ#^YWgEOA}FZlP=N1yC8=-{Q-6-GHhZ(LIPk)eOGo?Rsb!^Km!B8 zRjMKT@Kb|_EZwQAQc=*+Q>>6-(~0(QCmr2H`Dh*kN$V}&lTSI4t_YjbY$yGKZs8gb zB-)CKwNMSucrdZ_0*%B9yt4B5_kZ^s)8?q$no262)DA$u1@X8Hyl4_P`XWg;UKtq@ zS*%r5P@v?*=pQno*9N{_T39Id*GP@H9gFu5*<$SVFOnYDjBFfzK_mAe=Gx7h=rpai zA8e(dSoZ>aa9fEqax8=9iY|QH)~yd28F%dhVQ)N3M4be#(lndVmuF@eCR%D1<}Gy( zAfvy(?k3Yt7M7T}IM5SQ5RWS)x$(m9Hd>v5=Q`MP8Y0YOASNOC*tO@~3Jndtc~jc? z^D{P&?k^(=L}1R>Z;jN|*ikNCBk4JP{zfF&Iex>!mj`OF>pW6bY}y^3O#C2+o1Jy} z<82;tZ{QesrjjK%US2`wMxLqkMN%r0_bOJBYuCG8#gps15*tB_99NBE-UaJnqS%_M zHpnB7YtQVC>F&5nSPYnTqeL@5t$)vutYF`KyH zA1gaPZj8t_hwt*Hw!Hk4YW>gsJn}@0QiNq_6=klcpU^B-qpi8IP5G{@ z1oDuXbyZjhNJ(-3WLs*>YwZBy8k(s(IxIvdO>zH3YiiO~f)SuNOtqezd|mEUu;iNo zXv@sJKXP>w)%4U<*=SzH>d$mJiHd)z6thHD5=$OFamAw98S;f*?wJU*YcVlKdU_0y zdstYON~%}thscVBj-K8~pBM0aZYU}DZ}wYwXS!+Q z#`Bhz%um4(b8>Pb`k#pNA~1V(NW5wvpYqmaMHD)LgCUi>W_qd~KYn$_1pyBMxRw() zQ<6TcCF~X&)_ushwBY<3I?k5}$y<@2(*C<>;d1s8rpX~gi#MvGrh*cRh!C1>h^U}T z1A~ILatf>Q2?|0JuWx7&QK33{Yib->2GiD z-@gy#6B#kvZ4!L3s8g@8p5DiXJbuLsQ@aoagN%_yf_{cSTNz(n)8o+t%_S(i*$%2c zm?4m-S$TPmJyQSZ8RtefkP~S{OCDctQ8xA0#j7WPGg89Qa_3guT$w~~Io@~7CiVF5 z*gK?1-qaVCJM~hj^bQ(;2R*&(J9xH+$bCw;H*VU5o{X8~^mI0|h>r}m#nCsdc#q_| z>imR^V%L)5`f2QW7LhgVzP-MS&Q0yqDM&--!Bq3*SKb3?iH;um^5xHq-(G{YM#D<5 zooE%oyJ|slJ98#FI9OL|6_XO9m9fZ@i}P=~QS73lE$r)cN@pcTZQ>)r!ck0Uw5Gmr>^Y`Rj)8ic^2dClwORAu zD9Nv!)8QF^ZaG7K<>6~ts=?=q#?%_G5Qd{t8MP?)#83RvD`DgxC6LtR$?#Dc?9Uao z33A+}Jl?Wi)awjt3OxJisb-LZQ z!6godrm3=!lg6o(k(LH>+1*L}HIV!!o15vB9pu6s?WFflHbV-UCJQv4I&Y38<05G- zt~Rao>z8@IKFIS~;qIB-c5GgH+RTvoDj9u4O^o<1JsX}szC2sNA zsjP6(Tf`hAlZ`~H^^?eXA(5OigmhJ6Uj3aY-0IWTAql(Mh^X3G8gh0+Fh<`Z!;e-X z1x-|K&d$sneqa^HBy4>LBtL-WENHPz&&fPeMbLJpuiw9m0IPvJGUQ+<);T(lFZ%1i z*Zxw*L^4{;7ud4m{-{7ZH*S&&8;|_NU)Aa+eBh)U1nqqf-t0; zOh>r(?K5vqQcO%t{7+&iGg%DHzCwOOgw}T&muZtg0Cm{;%+1ex82TXEM_W^LbW$tE zYJ}h(ILQO!6S&a;TJYu#c~D0|Md8lpCKDdFJle5=;-&iV#mj$(HokmrlvJ2qXH z;Brrjg2K8lbPc#nrH`@q`s|p6Q_m>%!7}7r0|55i3K=5LG$mr2-%2uC4Tm_KLN2w=TKXp?9uMc}a-g44v5Fr? z7Xs`gAM*M0=h@MABl_Lgd=ffpE(S}s{i2(_;ktu@1K};uS^A z?zAqSD40|8a$pw*jS?LZG5c%-jkwWA80O#$tYi1K2jv|365z$`3KyiS8tjy(q*X=P<4!!0l$P{P?*0c0;f5GHlz^jvMTyyo0d zXaO!4eXxzaeGctcFyyGXFpelID>DQEt~)2|@JOLmJ{WfiCV{UofvKshGsp)72TQTu zhFX$qSoG@o4~*O~oHsSN_`q|~o&20Hp_J<98GC|b2hDW(@@4QnRJ#v9D}0R?o=O~P z`D)JGsag;~3lB;eG`yTGC~XP*thG9&l&^^R{QB|nmS{{pNJ-4)a7(I3kDI>ICgPr{ zQ4Z!BE}S~<>iQEU7!E7gb`HbH2eB$6>x_=hE|?OuiJb?OF=@aA@cL|4({1=PF%#$` zfqxkWpU6$U+zAL{$YH%^10sJBQW2M7sF_>6ixDiF1 zmZ3-y(vd;LJF%qL{b{%e3Hko5(WE2BeBi83L1Ko~6{zF^a3Zct`X-2mm zKnn(@6z-4QZ99RCylmu4jEwf$yU@S_at8ec#DYLt>fqzLy1_3V!Ct5qBg*s?O~uDR zbk)vJ!3&5>)^W{4x~zmQj8FnspO=wANlgu!YB}N9)tkMT6{xrd^yKW)s$eDghD3P* zWMGebmqWb~;Ut3ZB#eZbFL;cxoc6h2M0nkKhuiL07pT4HDTIZEcME8}U0hsjP1i83 z^6AJTZ-)@z^-uQHs-|<@13~!_eEN>Pl@i?CL-5uj2ZEay;Ng*g1Pu#k#1tmJn^HH5 z`fQP>L9|(M*_DWxm77ti+`!Aam%5b0xFCTn!yYgTT?Uy8&@AUBVbD2& z{$)$;SG5U;yr|Ta6d)e~0MX1$9uRAsoX04?IExD%IU=x~cx_Nd`QuU1+D^JJy1kAN zoks@;4+dPCd^!((Q_8Ws6jl{O`Yw?#7L5o4wn0I^m8(6&)oXPxQ_E%iIRzz z@=&KddtP5Y@p(pu-7^X_&N_`H^hXsjJOnZo+^NU3=$UJ zyJ6GzCbt#neQr+zf`TH$!>yya0=UUWD`DT$m?j4RRpr{R9y^{$bfzeW!Q2=b6~)NJ z1d_3%a@0z0>A|%fpxDLXsBkQ~;iMV>wnact5c--iyn5OiG8SI}?Gh?9Qy*>4c9B-R z9~}+PdLy)4{9_<-aT#D&^K02qGZx8J zEKATKy3L!o2_n>QvoFQ3Ee{eJWJ7EP(NzWXIKrTKugK$nQiyq>ntR9iy$c?KSD%41 zXB#Jc6{lE#LFT;$>*`-Ur zkQD+6d-Z60zL>>_{HjG>Nl7nA@{oGaI5?30v3A+6IjZobZA5nKK6-;LQN-qW%$AR^ z-Q2x%hbRLNAF?J}%#O4{6+}txqN0ZF-&7qo`wtnK*djJ@q*(C_@|xkWQoifB7az|7 z^E3m)$5pCXJ;!xg_zaoD?Ckm$_rKTPb{RO{NcQ&jpg#5VBB#D3wEjD~vbli{nf~Y! zal`9VOoTg19>cAjT&K9<^}0Jncqn9asp~v~aQXnWy*}WvippEamG9oYd-380N&}&x zu`m&f<$}e^YCGiZSfl_4`#rdxlODmHCNBQ##4B&al+mI3;qu;W{X?7z;H;k5cU**m z2XG7f-@P$_neIL44b+DDfyJNL8~XSxga2k`VS%RWG60u?AMDjyTK59K5ZRbkt({&? zQ&Rcb5BP#JGBPgBby$Ukg$2@rgQX5O2W-G}KROH|?J`S}ijB5Z{jp^E5CEQhe4H;nSxOw`i2@CXHvgd=NaJwNPxL;mP&9`*AOAK7BMFk3pW@aWvxvw@ zm<6&F%@q_Bpw0gMN8FDtaqHWusb#%>THknumKo;NlB>rF&gB-bNNQ$lI3=tpm1Z?p z9J-zmo=NlqaK*^M#aj$>F@$O(CJxl@Th7YY3hHMIA^nF(Md60EblaQ+-NXr%+I{>C znHeqBjQ*fFs9eyCBOUN@5lRD$E3YIB5RKRZkA%dDnM)ao&Q*S7=>19u+Zg=C8V;~* zXAvD!l3TnR@f#-X{>ca}P5Rnii8(U>I1yoC112owRy8b% z{V`wcc8tI*d1h`|{P>K|iy2y8yn0cT`LezL6ZmrJhEczpH!BwFMc229nsqljyR6^x zB~AsnECBv;w~{|yE!x#Jjy^}M_tHL2&a)UHpvj4M*yioIMmRwu`p-;-yBno@UOx;L zijQv;x~KCKn9nVN9z$j3K7oD~xCS=t^NCEYqSgCBqIFUTWl+jS!s_=ACxWF|UqZF8 zaO#-0I^oCUD*x^K_hM^)Zf-!GiO+Yic}^v(44>wgc}04x{r|Q7Rg?xhuFk&PsR3`h zG~CX>#PT6OemDbY*>@02Z?GHf?K3J(Dcvgv0t{fHd>g?R$}V$8Q*#FnPoS#f(2fBE zu=ulE+NqEE^d@U;4?(fOzz3_AI;GFx-3ei>uEPa}PdATl<+DV>LWv=?uBx?_$;qCI z_OF+Tai^#Z7gQ|rJZChy^ku4!gK*>^KRbwaAxQwC^qpY^G(r)s$DqFhh+R;l0H_)r z!$Z@}+jpPV);4!IiBW)HV642+G%|(nb5e$5hspG%dMiLZ`$Q+rOafFPA>)xX=3%rrkSSJyEDXp*6ie1# z8DtgS@;oDnURd9l=;#U|vO#5Uw}x`K0Gmf+tkl7P-4YkiqwPS+zL^IM*5@^vi~40d z7@MVa#-wGg;X`Z2vny6hPdtxp{zj*lZ-%btXuF%0`+)#Ts1H0m&BEjVhF~}j zE}Q!a-@~PjN5<7}RseU9X>rs7`$ayapy05T{=W!@(Ij9W(tQBzk`C$e8m{>P;>^T` z&D3xrZsCN1VqLv3=|AEWgRZHa0EZ;W_U}bcNea>2s}r3|mLB%hEW&1% z4ht_Vx;Qr_4kG5|e^3qfJbzOSsL+!89f6?Q&?WwyTvr>uUj35tq}a&v(?)ww|e>NRa$yF5~B}%7z~6*zB?#OHHI&4FKpUx!So6WGRTXw_A!-X!u0b^ zXk>qx0U1H&f(!!5goahzxsJ`lfRz)S6bo3l;VUi$<;#B#k@d9BX+yQzZ|$ajV%7_v zH+vVm-I7|@*_d?2^a{%B$@D#&T0{$1MW6Bnwm+LvD=4^J_9!yxC;*WnH|8lXCL`gv z@60YvG80kr_`1k<6CFFmm9gE4PiUOOq#CQ`8>$Y-S*n zrsk*u1!T@NiR%`b{LIu*Gyh|qm`v+hS3iygZRGC;tfMpGP1*3XfqE89|w5`+$lWy{%7%b0E&Hc90Fw#xs|{CNRXn%V%qE6&kG zzF6d>LSK1b%ER%-tLM+TK$~FIS%zX*&&4;G& z3i?BsCydvmib#?nUL=Wa)K!7D-%jjbB7^>B$EWEcNSzK`O`?Y);f z>ZMeR8z=|C64ytnv5ggV4N!l4#qI0MEsC1GUZVn5|2iLGuq5}vX!!HV-{1&JxE6Up z-mWDGFBSQhXaM31P8B$5AhEDXx#O5qsiZKb|A0;TgmW!E|NkM}CuC~{{&X(gQ=?Vx zbxcjOe3{6uo3|{u*?KK>8)_&%c2NURiM1y4(`9ESYYI1!H=0rO4V8fPO}V}?PVFq; zydFC?*MI&nBX2qB=sSXjH6zCBg4jvk@}6}S&r?{@%ZqGLc_tmbSB90i4h2_ppkP3O z)UMHBF0$sJ9MK}^aGg)|A$h~kgV;~&8e?DIwot;;__qEXkLAdX>wBH(615(!tARJt zRAU^A{{9}h=sfujJR#(-%b6$IQq{CSkyQa^ggNOS2A;=(nS9+D!n;S<4?GE5%rl)V zb+T@ulO?=<-x#lJ=K4J-{H;VHgx6&TcI1V>KMx~{PAc8oLH0IGWIj?Z8qHI7BaUfb z_SVw1SwD%b8J5-I#%TYHjy$0x5fSBz8(M5+aV1Vit!NwBPVm0T5y_0cN)GL7 z(T^R=HjhG+f>S_%84SG0`PZ~i-EoYFUDEaSfxi$zVhQdqHjci$wv#yj*<1>fD~Lp# z5dm;VE9nAD4$A&DRYEBzk;1avl8J*wh{anRawaMrNqi_NoSa|KaRMaGH~O#6pg)2C zX}z3p$l_w_8RU5mc%QSPH#3Lse-}NyqLPx7(YbTypbhfVVDd^gAcsX&UTZqA{`CaP(#`UP3`{z(o zQSC2dc!1D(*%7V?$7E%d+cvbhCFhw0M2!w^1?B2W42(yR9C+p8p?6R@)YX3m)9cF8w8b!b@3iZ zv&}bduYDbkxESc_7USRsYAI|yfEGC2!j?ykzQ9!(`H@kEH{EsiN_3Lz0->$kKJ29L zzE(ZEs@wT^?$Bt6anjE5zoqPdw(3M79Va+ysI%sK*#>Zuih+=^_0|+h+N7X=3%}z}*i93JB z$^5~Q5Mn!j_>|J&rdJTqB%E7X`l-ELOiHRECx;&nVQ3v1vI{BM{U}EyjWE@nIqHw! z^!$69+Uh3T81^Y$069!?&aprSb4WA)xs}py@;*l zKV1sVEL>g__hS=hrFnRDZ|jGBaWr&ST6V-_N(dAk5mIzfZ#BHfHxPXPh{w+x4ewb+ zk9^CPPeEAi`csKo?0hTFyZsk!8t#N-8l?qPhtS?u`cqu4%D;Q5SLzyvoc4sIaou2l z{!(SWi+f&FdTHNaxj!p~(9p=rW<+%FzA|>bV2UpXHW$}2kiw9p}=Vdm>GVT5rLzJsicmP z_jh+{y+gK8O)%>)zZ1#R(Gk(y2U{=fhri1p6!*mE32In>zWre~ZxeB#1BxX6{S^oJ zd&ej$c!>aN)^Gdgf;Q$gCK6$BETgr*dDI%opW<=9ySD@(3MU*WX=hms?VcW~BK~lc zcI2Y>hD-FER1kzIt8O}_;Zb4RruLl1_Nz}zuD07!1%PYySIf197{T-(~1|iT)9^y?GVno6Nb6zjx ziML~LbL$t^W{(#O-$Z=wamRQu{%|P*`B?`a55S9A| zGe7)ItylrA>5)pWh8iuj7-nd|!HS>(iN)DSTiX#F7-1b!#)}p%xmF!M{*0MFwsCOV z2X7BC%lEr0dg7v@(xrXA1Tvm8H^*ZTIDXK@=6NVKZA?s|^|`h&@!K(Oo{gq^IdwDq z;ww#;-mYyAy|tL%xGW_pt!0s6E_auD`Vli1tmwt* zfM46sE*^dAjlWl#O#1S{&trWLi?p?uHedGU@c_a^zl9T>XR==SI1cS>vRB7n)q818 zDV&6v3sQ?Fpo#|2f;Yw~FD+jDm*K_%A))D-Lm!5J{}{jOOL-vhv+91z12po=oWJO{ zWXdzGtyKTzHHtA)F$ul2EP|r<6weG$NkvtLv$-b!-uH8w6cj&x4JlGZ(w;-+al#Ww zN-y-|9LN*sPf)8E85lNsX<@l((%X9k?Qs$td^47!xWgXb;28C}1S@Q!AI@GRV(Ir( zn7GnoTO4&xAVR0wReW=LcY&=PzDN@~A{l;h7eA3y)tLCrpdH(VRUGSc)AR%^~*Qz1>p%E?JI3C4t&s5 zK8^=(u*)ps@CQuyG#s)%P^eaq3k5Agwsf6$SzY%0zC|dAP99{*!E4v9!N=1mJ@X!C z$(MuotL+cKgIHeRe|z`sBMuV69I;5F%s6s(zDQ>4P?#R_1Bg<5wX+-D%;94u%nY~U z2ANDHeIp|&vu6~^%|oW)V*Oy`Ab&MJl<2=$1_9;fiGDn}CW2G>I6xD~QRrpju?>)U zm~Op7Z((t=MPU`vVgN0SpxS)XL5l-1P64#Jxw$>TDbyCi%n(vYg8JyY@Y%e$2Gm+Lmm9WUNkBq0$e7J z$l(fbPO3276a4UE!peL1>93pkBqTb%IA_p+S182eS11|=@0RsAey{F?t;t*VlJXHz z5s@vNI066RZK1`x9KGy90dwy3RvTevxwU1NVj)OLVEDMZgt(?XMn3Q)H}A%CANtJR zu<*iHh11|w$ESm$@stnv%iDs%uw%o#eNvgY3{LGZ7uT!r7kOw7P>Gy<9`N|F@a$Re z>Rw*u`_CS9lfO&lJoK!980nzV5fq^ zW3#hLXii$1<@nl6{=1k9cua$A{3OnUYx3!37e9K`+&^`anO8`tFgclcmd|NEAZcCE z{c0)DVN^6UJj7Xn3T-t*?`drDB>-m}srv91hct+TF`O>k{s%SUx`6`` z8K=0y?ns2MX*}J+`P1uZ>+mk2gIT$`ZWTQ^{a|Z>P7_-fhQEt}UI8oijT_!}{_h!M zHU#I%J)xT6iA@^$Ywvtbukx5<7s{l-qiGJQ zuw^}Y@}#WH6D|s_FdJ-M4!>WCT2W#;IP_2Z-0blChZ5Rbirq%_EKc^GUj3MF8Xq2> z;`i5GF&)@Lz}BJrcLnDIJ4V~bk8fA?WTZ*8pUlC7Ryc=_(5Dj$wsmx5kjHZ_Qq$8>k$u7Q zVjHaeY}E*SpQwZWT@IZyNba`lm5K1V6V8z6Xj{=39A5$=2siZ$6T4e)sok(&n-8P~ zt$eAmV41wkbH68pzgal^lWYsQMg+x$py1`>xiJO>W`7lq?DNi`=hIuB>vBSvpqqH> zq3yZTQ#uajC75we#Yr#3ae5wy0n**o6{lf*ptd1#++YwmgX8Xa`T;0~?^NI2EAS{9 zM!|=8ECU`tfJf+HSP*XxonKAS0S*6WOg$c&q=x|a0tcvp2Og0~k)Hm*s@F54jtQ8&o(-fF z?|FS`yt5cmH4emp=U2$wc#NC#B`yMQi6Nd))7vZPlmvGb&cEAtKF(aaQ<+#!oKUf{ zvH~)!Obnl_#}l$1o_Qc_qou0)4jzPWRH=A|*L@t6S&Nvt7qkdI9jiJ$GXod4XDSVz zJON0R_rd=_04;1VxNn_2dEn`WH*a>xD<~5o-X%lBZFd#B36F~bN6Pn4sSwh1RBP&qzh6RA>ciK9-cIosDm&x$uCJwRqR#32{uAc?XcIIkki2#Zr>&MSapwu zX$#NeZt2Fi@i+ns&*Qaqb=x>4rKH-f7p5Kfw#G4n?Li#OgVN)#*>W1bd^&khD|)&3 z@}#J!C^J*JMS*zOm=7LJhEpg?sM;t@c6Qmd=YY%;J|ybUoNS)CTqtUQ<1mjp>`^Oi z*X!hg%i1juKQKYW62buw$W-Ncy484Iz~e-SmD#Ps%acO-Fx0TIITW8cfLa2Xkz+ZZ z`w0@B12f#A{%=@R7E-9$r8D$!D)HPS0|1_HR3gACH)^#E4KwxNA;xJyoFwIS;;zNP zzd%}eI({BfVOHtjXm4xFjKGQLt2MMcckZ*<%lQ)PU?cPZ&p2pP0b>S*Bk(ats|@=c z`Ky;{{H3n-o`bY;BKZQozGZuc4dk^T(6E{f?b~~zk<;cx)H`HOJeX)d0^L`qVeCyQ-VmrtOX^)AA zt;5DRdcIRby7|+mjO}lBk0j0&$!zDoaP|Alf;$dq;c;BT%yqX|=27!Ddr8W)tz4ad z^I!^&p$aFlzKsHi{g#6m|>U7 zO-Xs_k6V_F&wu>*gJluZb`X{UNlAOx5ao!!m$kJ$9w%R&MvWjn^>RCP>ZVCP4E%kC z7B|*1ZeH_|jeqz33^ZdHCX$nqkcCoLuLR1MpQfpZA6GsK4C?(d0<8!|cW4e7{{K89 zOi*OZ$z&+Bo9GQLzasY$!Y9Z$`A=p7Sl{{^&y(@CIo^^og;PMot5=}_;^3`6kj!6k z`zRr_c8?GAPoW*b`Fcn1JrvyHJSZJDG%!@Bw+vz>fn7+ zQeBQE*!YDwq6y9kd92EFCT;pL4xyuAl{$DZy|`Ee-^j?U;K@mpWAA_4xEc3!j9Wxx z7E07M8k)xU?{~?+$Ie0n2Y&?$u3%JlV&XB%sinzkCnS2DD#Z;Rd2kAck{VyXhT*{> zVUT*yZt_?}W7Il^x=QkC@!TS1PixVbKw1X}2l)`hhpW50dW@)=ZyRisG11X*q(u39 zl~Y`~E!zaKZye?9mz?nK?LF}*DE$ZIgSfO54j zUw#^&!*C#~z^K@HUg!@mTZ$B=tABi+(mj3J?2!R0wUV~BHmD?b_qprzd_)Ucb2rLX#e=Yp~ZLd69+rWQH=un{U?Jw9f6v~R~3VHHoSN;#QQS