From ff6c1be582dcf7098ddb2e8c1e73d59c576ee300 Mon Sep 17 00:00:00 2001 From: retoor Date: Thu, 25 Sep 2025 02:35:00 +0200 Subject: [PATCH] Initial commmit. --- .gitignore | 5 + Makefile | 11 + README.md | 68 ++ cJSON.c | 3191 ++++++++++++++++++++++++++++++++++++++++++++++++++++ cJSON.h | 306 +++++ rproxy.c | 2158 +++++++++++++++++++++++++++++++++++ 6 files changed, 5739 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 cJSON.c create mode 100644 cJSON.h create mode 100644 rproxy.c diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..509cf80 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.json +*.bak +*.bak2 +*.db +rproxy diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4f0cd30 --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ + +all: build run + +build: + gcc -Wall -Wextra -O2 -g -pthread cJSON.c rproxy.c -o rproxy -lssl -lcrypto -lsqlite3 -lm + +run: + ./rproxy + +clean: + rm -f rproxy diff --git a/README.md b/README.md new file mode 100644 index 0000000..0ffc8a6 --- /dev/null +++ b/README.md @@ -0,0 +1,68 @@ +# RProxy + +RProxy is a reverse proxy server designed to route requests to various upstream services based on the hostname. It is built using C and leverages the cJSON library for JSON parsing. This README provides a comprehensive guide on how to get started, configure the server, and understand its features. + +## Getting Started + +### Prerequisites +- GCC (GNU Compiler Collection) +- Make +- OpenSSL libraries (`libssl` and `libcrypto`) +- SQLite3 library + +### Installation +1. Clone the repository: + ```bash + git clone + cd + ``` +2. Build the project using the Makefile: + ```bash + make + ``` +3. Run the server: + ```bash + make run + ``` + +### Configuration + +The configuration for RProxy is stored in the `proxy_config.json` file. Below is a breakdown of its structure: + +```json +{ + "port": 8585, + "reverse_proxy": [ + { "hostname": "example.com", "upstream_host": "127.0.0.1", "upstream_port": 3000, "use_ssl": false } + ] +} +``` + +- **port**: The port on which the RProxy server will listen for incoming requests. +- **reverse_proxy**: An array of objects, each representing a reverse proxy configuration. + - **hostname**: The hostname that the server will respond to. + - **upstream_host**: The IP address or hostname of the upstream service. + - **upstream_port**: The port on which the upstream service is running. + - **use_ssl**: A boolean indicating whether to use SSL for the upstream connection. + +### Features +- **Reverse Proxying**: RProxy can route requests to multiple upstream services based on the hostname. +- **SSL Support**: Optionally, RProxy can connect to upstream services using SSL. +- **Dynamic Configuration**: The configuration can be easily modified by editing the `proxy_config.json` file. +- **Multi-Host Support**: RProxy can handle requests for multiple hostnames, making it suitable for microservices architectures. + +### Use Cases +- **Microservices Architecture**: RProxy can be used to route requests to different microservices based on the hostname, simplifying service discovery. +- **Load Balancing**: By configuring multiple upstream services for a single hostname, RProxy can distribute traffic among them. +- **API Gateway**: RProxy can serve as an API gateway, providing a single entry point for various backend services. + +### Monitoring and Statistics +RProxy can be extended to monitor various statistics such as: +- **Request Count**: The total number of requests handled by the server. +- **Response Times**: The time taken to respond to requests. +- **Error Rates**: The number of failed requests to upstream services. + +## License +Copyright (c) retoor. All rights reserved. + +This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. \ No newline at end of file diff --git a/cJSON.c b/cJSON.c new file mode 100644 index 0000000..6e4fb0d --- /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 != 19) + #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; +} diff --git a/cJSON.h b/cJSON.h new file mode 100644 index 0000000..cab5feb --- /dev/null +++ b/cJSON.h @@ -0,0 +1,306 @@ +/* + 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 19 + +#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/rproxy.c b/rproxy.c new file mode 100644 index 0000000..55c8e73 --- /dev/null +++ b/rproxy.c @@ -0,0 +1,2158 @@ +/* + * ===================================================================================== + * + * Filename: proxy.c + * + * Description: High-performance Reverse Proxy with Real-time Monitoring Dashboard. + * Single-file C implementation using epoll - PRODUCTION READY VERSION + * + * Version: 1.5 (Compiler Warnings Fixed) + * Created: 2024 + * Compiler: gcc + * + * Author: Fixed Version + * + * To Compile: + * gcc -Wall -Wextra -O2 -g -pthread cJSON.c proxy.c -o rproxy -lssl -lcrypto -lsqlite3 -lm + * + * ===================================================================================== + */ + + +// --- Standard Library Includes --- +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// --- Local Includes --- +#include "cJSON.h" + +// --- Constants --- +#define MAX_EVENTS 1024 +#define MAX_FDS 65536 +#define CHUNK_SIZE 65536 +#define HISTORY_SECONDS 300 +#define MAX_HEADER_SIZE 8192 +#define MAX_REQUEST_LINE_SIZE 4096 +#define MAX_URI_SIZE 2048 + +// --- Enums and Structs --- + +typedef enum { + CONN_TYPE_UNUSED, + CONN_TYPE_LISTENER, + CONN_TYPE_CLIENT, + CONN_TYPE_UPSTREAM +} conn_type_t; + +typedef enum { + CLIENT_STATE_READING_REQUEST_LINE, // Initial state, reading headers + CLIENT_STATE_READING_HEADERS, // Legacy, handled by above + CLIENT_STATE_READING_BODY, // New state for handling request bodies + CLIENT_STATE_CONNECTING_UPSTREAM, + CLIENT_STATE_TUNNELING, // Full-duplex forwarding state + CLIENT_STATE_DONE, + CLIENT_STATE_ERROR +} client_state_t; + +struct connection_s; +struct vhost_stats_s; + +typedef struct { + char hostname[256]; + char upstream_host[256]; + int upstream_port; + int use_ssl; + int rewrite_host; +} route_config_t; + +typedef struct { + int port; + route_config_t *routes; + int route_count; +} app_config_t; + +typedef struct { + char *data; + size_t size; + size_t capacity; +} buffer_t; + +typedef struct { + char method[16]; + char uri[MAX_URI_SIZE]; + char version[16]; + char host[256]; + int content_length; + int is_websocket; + int keep_alive; + int connection_upgrade; +} http_request_t; + +typedef struct connection_s { + conn_type_t type; + client_state_t state; + int fd; + struct connection_s *pair; + struct vhost_stats_s *vhost_stats; + buffer_t read_buf; + buffer_t write_buf; + SSL *ssl; + int ssl_handshake_done; + http_request_t request; + char *http_body_start; + long http_content_length; + long http_body_read; + int is_websocket; + int keep_alive; + double request_start_time; + time_t last_activity; +} connection_t; + +typedef struct { + double time; + double value; +} history_point_t; + +typedef struct { + history_point_t *points; + int capacity; + int head; + int count; +} history_deque_t; + +typedef struct { + double time; + double rx_kbps; + double tx_kbps; +} network_history_point_t; + +typedef struct { + network_history_point_t *points; + int capacity; + int head; + int count; +} network_history_deque_t; + +typedef struct request_time_s { + double *times; + int capacity; + int head; + int count; +} request_time_deque_t; + +typedef struct vhost_stats_s { + char vhost_name[256]; + long long http_requests; + long long websocket_requests; + long long total_requests; + long long bytes_sent; + long long bytes_recv; + double avg_request_time_ms; + long long last_bytes_sent; + long long last_bytes_recv; + double last_update; + history_deque_t throughput_history; + request_time_deque_t request_times; + struct vhost_stats_s *next; +} vhost_stats_t; + +typedef struct { + time_t start_time; + int active_connections; + history_deque_t cpu_history; + history_deque_t memory_history; + network_history_deque_t network_history; + history_deque_t throughput_history; + long long last_net_sent; + long long last_net_recv; + double last_net_update_time; + vhost_stats_t *vhost_stats_head; + sqlite3 *db; +} system_monitor_t; + +// --- Global State --- +connection_t connections[MAX_FDS]; +app_config_t config; +system_monitor_t monitor; +int epoll_fd; +SSL_CTX *ssl_ctx; +static int g_debug_mode = 0; + + +// --- Function Prototypes --- +void log_error(const char *msg); +void log_info(const char *format, ...); +void log_debug(const char *format, ...); +int load_config(const char *filename); +void free_config(); +route_config_t *find_route(const char *hostname); +void setup_listener_socket(int port); +void accept_new_connection(int listener_fd); +void close_connection(int fd); +void handle_connection_event(struct epoll_event *event); +void connect_to_upstream(connection_t *client_conn, route_config_t *route); +void handle_client_data(connection_t *conn); +void handle_client_body(connection_t *conn); +int parse_http_request_line(const char *line, http_request_t *request); +int parse_http_headers(const char *headers, http_request_t *request); +int find_header_value(const char *headers, const char *header_name, char *value, size_t value_size); +void monitor_init(const char *db_file); +void monitor_update(); +void monitor_cleanup(); +void monitor_record_request_start(vhost_stats_t *stats, int is_websocket); +void monitor_record_request_end(vhost_stats_t *stats, double start_time); +vhost_stats_t* monitor_get_or_create_vhost_stats(const char *vhost_name); +void serve_dashboard(connection_t *conn); +void serve_stats_api(connection_t *conn); +void send_error_response(connection_t *conn, int code, const char* status, const char* body); + + +// --- Buffer Helpers --- +static inline int buffer_init(buffer_t *buf, size_t capacity) { + buf->data = malloc(capacity); + if (!buf->data) { + log_error("Failed to allocate buffer"); + return -1; + } + buf->capacity = capacity; + buf->size = 0; + return 0; +} + +static inline void buffer_free(buffer_t *buf) { + if (buf->data) { + free(buf->data); + buf->data = NULL; + } + buf->capacity = 0; + buf->size = 0; +} + +static inline int buffer_ensure_capacity(buffer_t *buf, size_t required) { + if (buf->capacity >= required) return 0; + + size_t new_capacity = buf->capacity; + while (new_capacity < required) { + new_capacity *= 2; + } + + char *new_data = realloc(buf->data, new_capacity); + if (!new_data) { + log_error("Failed to reallocate buffer"); + return -1; + } + buf->data = new_data; + buf->capacity = new_capacity; + return 0; +} + +// --- String Utilities --- +static char* safe_strdup(const char *str, size_t max_len) { + if (!str) return NULL; + size_t len = strnlen(str, max_len); + char *dup = malloc(len + 1); + if (!dup) return NULL; + memcpy(dup, str, len); + dup[len] = '\0'; + return dup; +} + +static void trim_whitespace(char *str) { + if (!str) return; + + // Trim leading whitespace + char *start = str; + while (isspace((unsigned char)*start)) start++; + + if (start != str) { + memmove(str, start, strlen(start) + 1); + } + + // Trim trailing whitespace + char *end = str + strlen(str) - 1; + while (end >= str && isspace((unsigned char)*end)) { + *end = '\0'; + end--; + } +} + +static int is_valid_http_method(const char *method) { + const char *valid_methods[] = {"GET", "POST", "PUT", "DELETE", "HEAD", + "OPTIONS", "PATCH", "TRACE", "CONNECT", NULL}; + for (int i = 0; valid_methods[i]; i++) { + if (strcmp(method, valid_methods[i]) == 0) return 1; + } + return 0; +} + +static int is_valid_http_version(const char *version) { + return (strcmp(version, "HTTP/1.0") == 0 || strcmp(version, "HTTP/1.1") == 0); +} + +// ================================================================================================= +// +// Logging Implementation +// +// ================================================================================================= + +void log_error(const char *msg) { + perror(msg); +} + +void log_message(const char *level, const char *format, va_list args) { + time_t now; + time(&now); + char buf[32]; + strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&now)); + printf("%s - %-5s - ", buf, level); + vprintf(format, args); + printf("\n"); + fflush(stdout); +} + +void log_info(const char *format, ...) { + va_list args; + va_start(args, format); + log_message("INFO", format, args); + va_end(args); +} + +void log_debug(const char *format, ...) { + if (!g_debug_mode) return; + va_list args; + va_start(args, format); + log_message("DEBUG", format, args); + va_end(args); +} + + +// ================================================================================================= +// +// Configuration Implementation +// +// ================================================================================================= + +static char* read_file_to_string(const char *filename) { + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + + fseek(f, 0, SEEK_END); + long length = ftell(f); + if (length < 0 || length > 1024*1024) { // Max 1MB config + fclose(f); + return NULL; + } + + fseek(f, 0, SEEK_SET); + char *buffer = malloc(length + 1); + if (buffer) { + size_t read_len = fread(buffer, 1, length, f); + buffer[read_len] = '\0'; + } + fclose(f); + return buffer; +} + +int load_config(const char *filename) { + log_info("Loading configuration from %s", filename); + char *json_string = read_file_to_string(filename); + if (!json_string) { + log_error("Could not read config file"); + return 0; + } + + cJSON *root = cJSON_Parse(json_string); + free(json_string); + if (!root) { + fprintf(stderr, "JSON parse error: %s\n", cJSON_GetErrorPtr()); + return 0; + } + + cJSON *port_item = cJSON_GetObjectItem(root, "port"); + config.port = cJSON_IsNumber(port_item) ? port_item->valueint : 8080; + + if (config.port < 1 || config.port > 65535) { + fprintf(stderr, "Invalid port number: %d\n", config.port); + cJSON_Delete(root); + return 0; + } + + cJSON *proxy_array = cJSON_GetObjectItem(root, "reverse_proxy"); + if (cJSON_IsArray(proxy_array)) { + config.route_count = cJSON_GetArraySize(proxy_array); + if (config.route_count <= 0) { + cJSON_Delete(root); + return 0; + } + + config.routes = malloc(config.route_count * sizeof(route_config_t)); + if (!config.routes) { + log_error("Failed to allocate memory for routes"); + cJSON_Delete(root); + return 0; + } + + int i = 0; + cJSON *route_item; + cJSON_ArrayForEach(route_item, proxy_array) { + route_config_t *route = &config.routes[i]; + memset(route, 0, sizeof(route_config_t)); + + cJSON *hostname = cJSON_GetObjectItem(route_item, "hostname"); + cJSON *upstream_host = cJSON_GetObjectItem(route_item, "upstream_host"); + cJSON *upstream_port = cJSON_GetObjectItem(route_item, "upstream_port"); + + if (!cJSON_IsString(hostname) || !cJSON_IsString(upstream_host) || !cJSON_IsNumber(upstream_port)) { + fprintf(stderr, "Invalid route configuration at index %d\n", i); + continue; + } + + strncpy(route->hostname, hostname->valuestring, sizeof(route->hostname) - 1); + strncpy(route->upstream_host, upstream_host->valuestring, sizeof(route->upstream_host) - 1); + route->upstream_port = upstream_port->valueint; + + if (route->upstream_port < 1 || route->upstream_port > 65535) { + fprintf(stderr, "Invalid upstream port for %s: %d\n", route->hostname, route->upstream_port); + continue; + } + + route->use_ssl = cJSON_IsTrue(cJSON_GetObjectItem(route_item, "use_ssl")); + route->rewrite_host = cJSON_IsTrue(cJSON_GetObjectItem(route_item, "rewrite_host")); + + log_info("Route configured: %s -> %s:%d (SSL: %s, Rewrite Host: %s)", + route->hostname, route->upstream_host, route->upstream_port, + route->use_ssl ? "yes" : "no", route->rewrite_host ? "yes" : "no"); + i++; + } + } + cJSON_Delete(root); + log_info("Loaded %d routes from %s", config.route_count, filename); + return 1; +} + +void free_config() { + if (config.routes) { + free(config.routes); + config.routes = NULL; + } + config.route_count = 0; +} + +route_config_t *find_route(const char *hostname) { + if (!hostname) return NULL; + for (int i = 0; i < config.route_count; i++) { + if (strcasecmp(hostname, config.routes[i].hostname) == 0) { + return &config.routes[i]; + } + } + return NULL; +} + +// ================================================================================================= +// +// Monitor Implementation +// +// ================================================================================================= +static void history_deque_init(history_deque_t *dq, int capacity) { + dq->points = malloc(sizeof(history_point_t) * capacity); + dq->capacity = capacity; + dq->head = 0; + dq->count = 0; +} + +static void history_deque_push(history_deque_t *dq, double time, double value) { + dq->points[dq->head] = (history_point_t){ .time = time, .value = value }; + dq->head = (dq->head + 1) % dq->capacity; + if (dq->count < dq->capacity) dq->count++; +} + +static void network_history_deque_init(network_history_deque_t *dq, int capacity) { + dq->points = malloc(sizeof(network_history_point_t) * capacity); + dq->capacity = capacity; + dq->head = 0; + dq->count = 0; +} + +static void network_history_deque_push(network_history_deque_t *dq, double time, double rx, double tx) { + dq->points[dq->head] = (network_history_point_t){ .time = time, .rx_kbps = rx, .tx_kbps = tx }; + dq->head = (dq->head + 1) % dq->capacity; + if (dq->count < dq->capacity) dq->count++; +} + +static void request_time_deque_init(request_time_deque_t *dq, int capacity) { + dq->times = malloc(sizeof(double) * capacity); + dq->capacity = capacity; + dq->head = 0; + dq->count = 0; +} + +static void request_time_deque_push(request_time_deque_t *dq, double time_ms) { + dq->times[dq->head] = time_ms; + dq->head = (dq->head + 1) % dq->capacity; + if (dq->count < dq->capacity) dq->count++; +} + +static void init_db() { + if (!monitor.db) return; + + char *err_msg = 0; + const char *sql_create_table = + "CREATE TABLE IF NOT EXISTS vhost_stats (" + " id INTEGER PRIMARY KEY AUTOINCREMENT," + " vhost TEXT NOT NULL," + " timestamp REAL NOT NULL," + " http_requests INTEGER DEFAULT 0," + " websocket_requests INTEGER DEFAULT 0," + " total_requests INTEGER DEFAULT 0," + " bytes_sent INTEGER DEFAULT 0," + " bytes_recv INTEGER DEFAULT 0," + " avg_request_time_ms REAL DEFAULT 0," + " UNIQUE(vhost, timestamp)" + ");"; + const char *sql_create_index = + "CREATE INDEX IF NOT EXISTS idx_vhost_timestamp ON vhost_stats(vhost, timestamp);"; + + if (sqlite3_exec(monitor.db, sql_create_table, 0, 0, &err_msg) != SQLITE_OK || + sqlite3_exec(monitor.db, sql_create_index, 0, 0, &err_msg) != SQLITE_OK) { + fprintf(stderr, "SQL error: %s\n", err_msg); + sqlite3_free(err_msg); + } +} + +static void load_stats_from_db() { + if (!monitor.db) return; + + sqlite3_stmt *res; + const char *sql = + "SELECT vhost, http_requests, websocket_requests, total_requests, " + "bytes_sent, bytes_recv, avg_request_time_ms " + "FROM vhost_stats v1 WHERE timestamp = (" + " SELECT MAX(timestamp) FROM vhost_stats v2 WHERE v2.vhost = v1.vhost" + ")"; + + if (sqlite3_prepare_v2(monitor.db, sql, -1, &res, 0) != SQLITE_OK) { + fprintf(stderr, "Failed to execute statement: %s\n", sqlite3_errmsg(monitor.db)); + return; + } + + int vhost_count = 0; + while (sqlite3_step(res) == SQLITE_ROW) { + vhost_stats_t *stats = monitor_get_or_create_vhost_stats((const char*)sqlite3_column_text(res, 0)); + if (stats) { + stats->http_requests = sqlite3_column_int64(res, 1); + stats->websocket_requests = sqlite3_column_int64(res, 2); + stats->total_requests = sqlite3_column_int64(res, 3); + stats->bytes_sent = sqlite3_column_int64(res, 4); + stats->bytes_recv = sqlite3_column_int64(res, 5); + stats->avg_request_time_ms = sqlite3_column_double(res, 6); + vhost_count++; + } + } + sqlite3_finalize(res); + log_info("Loaded statistics for %d vhosts from database", vhost_count); +} + +void monitor_init(const char *db_file) { + memset(&monitor, 0, sizeof(system_monitor_t)); + monitor.start_time = time(NULL); + + history_deque_init(&monitor.cpu_history, HISTORY_SECONDS); + history_deque_init(&monitor.memory_history, HISTORY_SECONDS); + network_history_deque_init(&monitor.network_history, HISTORY_SECONDS); + history_deque_init(&monitor.throughput_history, HISTORY_SECONDS); + + if (sqlite3_open(db_file, &monitor.db) != SQLITE_OK) { + fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(monitor.db)); + if (monitor.db) { + sqlite3_close(monitor.db); + monitor.db = NULL; + } + } else { + init_db(); + load_stats_from_db(); + } + monitor_update(); +} + +void monitor_cleanup() { + if (monitor.db) { + sqlite3_close(monitor.db); + monitor.db = NULL; + } + + vhost_stats_t *current = monitor.vhost_stats_head; + while (current) { + vhost_stats_t *next = current->next; + if (current->throughput_history.points) free(current->throughput_history.points); + if (current->request_times.times) free(current->request_times.times); + free(current); + current = next; + } + monitor.vhost_stats_head = NULL; + + if (monitor.cpu_history.points) free(monitor.cpu_history.points); + if (monitor.memory_history.points) free(monitor.memory_history.points); + if (monitor.network_history.points) free(monitor.network_history.points); + if (monitor.throughput_history.points) free(monitor.throughput_history.points); +} + +static void save_stats_to_db() { + if (!monitor.db) return; + + sqlite3_stmt *stmt; + const char *sql = + "INSERT OR REPLACE INTO vhost_stats " + "(vhost, timestamp, http_requests, websocket_requests, total_requests, " + "bytes_sent, bytes_recv, avg_request_time_ms) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?);"; + + if (sqlite3_prepare_v2(monitor.db, sql, -1, &stmt, NULL) != SQLITE_OK) return; + + double current_time = (double)time(NULL); + for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) { + if (s->request_times.count > 0) { + double total_time = 0; + for(int i = 0; i < s->request_times.count; i++) { + total_time += s->request_times.times[i]; + } + s->avg_request_time_ms = total_time / s->request_times.count; + } + + sqlite3_bind_text(stmt, 1, s->vhost_name, -1, SQLITE_STATIC); + sqlite3_bind_double(stmt, 2, current_time); + sqlite3_bind_int64(stmt, 3, s->http_requests); + sqlite3_bind_int64(stmt, 4, s->websocket_requests); + sqlite3_bind_int64(stmt, 5, s->total_requests); + sqlite3_bind_int64(stmt, 6, s->bytes_sent); + sqlite3_bind_int64(stmt, 7, s->bytes_recv); + sqlite3_bind_double(stmt, 8, s->avg_request_time_ms); + sqlite3_step(stmt); + sqlite3_reset(stmt); + } + sqlite3_finalize(stmt); +} + +static double get_cpu_usage() { + static long long prev_user = 0, prev_nice = 0, prev_system = 0, prev_idle = 0; + long long user, nice, system, idle, iowait, irq, softirq; + + FILE *f = fopen("/proc/stat", "r"); + if (!f) return 0.0; + + if (fscanf(f, "cpu %lld %lld %lld %lld %lld %lld %lld", + &user, &nice, &system, &idle, &iowait, &irq, &softirq) != 7) { + fclose(f); + return 0.0; + } + fclose(f); + + long long prev_total = prev_user + prev_nice + prev_system + prev_idle; + long long total = user + nice + system + idle; + long long totald = total - prev_total; + long long idled = idle - prev_idle; + + prev_user = user; prev_nice = nice; prev_system = system; prev_idle = idle; + return totald == 0 ? 0.0 : (double)(totald - idled) * 100.0 / totald; +} + +static void get_memory_usage(double *used_gb) { + struct sysinfo info; + if (sysinfo(&info) != 0) { + *used_gb = 0; + return; + } + *used_gb = (double)(info.totalram - info.freeram) * info.mem_unit / (1024.0 * 1024.0 * 1024.0); +} + +static void get_network_stats(long long *bytes_sent, long long *bytes_recv) { + FILE *f = fopen("/proc/net/dev", "r"); + if (!f) { + *bytes_sent = 0; + *bytes_recv = 0; + return; + } + + char line[256]; + if (!fgets(line, sizeof(line), f) || !fgets(line, sizeof(line), f)) { // Skip headers + fclose(f); + *bytes_sent = 0; + *bytes_recv = 0; + return; + } + + long long total_recv = 0, total_sent = 0; + while (fgets(line, sizeof(line), f)) { + char iface[32]; + long long r, t; + if (sscanf(line, "%31[^:]: %lld %*d %*d %*d %*d %*d %*d %*d %lld", iface, &r, &t) == 3) { + if (strncmp(iface, " lo", 3) != 0) { + total_recv += r; + total_sent += t; + } + } + } + fclose(f); + *bytes_sent = total_sent; + *bytes_recv = total_recv; +} + +void monitor_update() { + double current_time = time(NULL); + + history_deque_push(&monitor.cpu_history, current_time, get_cpu_usage()); + + double mem_used_gb; + get_memory_usage(&mem_used_gb); + history_deque_push(&monitor.memory_history, current_time, mem_used_gb); + + long long net_sent, net_recv; + get_network_stats(&net_sent, &net_recv); + double time_delta = current_time - monitor.last_net_update_time; + if (time_delta > 0 && monitor.last_net_update_time > 0) { + double rx = (net_recv - monitor.last_net_recv) / time_delta / 1024.0; + double tx = (net_sent - monitor.last_net_sent) / time_delta / 1024.0; + network_history_deque_push(&monitor.network_history, current_time, fmax(0, rx), fmax(0, tx)); + history_deque_push(&monitor.throughput_history, current_time, fmax(0, rx + tx)); + } + monitor.last_net_sent = net_sent; + monitor.last_net_recv = net_recv; + monitor.last_net_update_time = current_time; + + for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) { + double vhost_delta = current_time - s->last_update; + if (vhost_delta >= 1.0) { + double kbps = 0; + if (s->last_update > 0) { + long long bytes_diff = (s->bytes_sent - s->last_bytes_sent) + (s->bytes_recv - s->last_bytes_recv); + kbps = bytes_diff / vhost_delta / 1024.0; + } + history_deque_push(&s->throughput_history, current_time, fmax(0, kbps)); + s->last_bytes_sent = s->bytes_sent; + s->last_bytes_recv = s->bytes_recv; + s->last_update = current_time; + } + } + + static time_t last_db_save = 0; + if (current_time - last_db_save >= 10) { + save_stats_to_db(); + last_db_save = current_time; + } +} + +vhost_stats_t* monitor_get_or_create_vhost_stats(const char *vhost_name) { + if (!vhost_name || strlen(vhost_name) == 0) return NULL; + + for (vhost_stats_t *curr = monitor.vhost_stats_head; curr; curr = curr->next) { + if (strcmp(curr->vhost_name, vhost_name) == 0) return curr; + } + + vhost_stats_t *new_stats = calloc(1, sizeof(vhost_stats_t)); + if (!new_stats) return NULL; + + strncpy(new_stats->vhost_name, vhost_name, sizeof(new_stats->vhost_name) - 1); + new_stats->last_update = time(NULL); + history_deque_init(&new_stats->throughput_history, 60); + request_time_deque_init(&new_stats->request_times, 100); + new_stats->next = monitor.vhost_stats_head; + monitor.vhost_stats_head = new_stats; + return new_stats; +} + +void monitor_record_request_start(vhost_stats_t *stats, int is_websocket) { + if (!stats) return; + if (is_websocket) { + stats->websocket_requests++; + } else { + stats->http_requests++; + } + stats->total_requests++; +} + +void monitor_record_request_end(vhost_stats_t *stats, double start_time) { + if (!stats) return; + struct timespec end_time; + clock_gettime(CLOCK_MONOTONIC, &end_time); + double duration_ms = ((end_time.tv_sec + end_time.tv_nsec / 1e9) - start_time) * 1000.0; + if (duration_ms >= 0) { + request_time_deque_push(&stats->request_times, duration_ms); + } +} + +// ================================================================================================= +// +// Dashboard Implementation +// +// ================================================================================================= +const char *DASHBOARD_HTML = +"\n" +"\n" +"\n" +" Reverse Proxy Monitor\n" +" \n" +" \n" +"\n" +"\n" +"
\n" +"
\n" +"
0
\n" +"
Connections
\n" +"
\n" +"
\n" +"
0
\n" +"
Memory
\n" +"
\n" +"
\n" +"
0
\n" +"
CPU %
\n" +"
\n" +"
\n" +"\n" +"
\n" +"
CPU Usage
\n" +" \n" +"
\n" +"\n" +"
\n" +"
Memory Usage
\n" +" \n" +"
\n" +"\n" +"
\n" +"
Network I/O
\n" +"
\n" +"
RX
\n" +"
TX
\n" +"
\n" +" \n" +"
\n" +"\n" +"
\n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +"
Virtual HostHTTP ReqWS ReqTotal ReqAvg Resp (ms)SentReceived
\n" +"
\n" +"\n" +" \n" +"\n" +"\n" +; +void serve_dashboard(connection_t *conn) { + if (!conn) return; + + char header[512]; + int len = snprintf(header, sizeof(header), + "HTTP/1.1 200 OK\r\n" + "Content-Type: text/html; charset=utf-8\r\n" + "Content-Length: %zu\r\n" + "Connection: keep-alive\r\n" + "Cache-Control: no-cache\r\n" + "\r\n", strlen(DASHBOARD_HTML)); + + if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + len + strlen(DASHBOARD_HTML)) < 0) { + send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed"); + return; + } + + memcpy(conn->write_buf.data + conn->write_buf.size, header, len); + conn->write_buf.size += len; + memcpy(conn->write_buf.data + conn->write_buf.size, DASHBOARD_HTML, strlen(DASHBOARD_HTML)); + conn->write_buf.size += strlen(DASHBOARD_HTML); + + struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT }; + epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event); + conn->read_buf.size = 0; + conn->keep_alive = 1; +} + +static cJSON* format_history(history_deque_t *dq, int window_seconds) { + cJSON *arr = cJSON_CreateArray(); + if (!arr || !dq || !dq->points || dq->count == 0) return arr; + + double current_time = time(NULL); + int start_index = (dq->head - dq->count + dq->capacity) % dq->capacity; + + for (int i = 0; i < dq->count; ++i) { + int current_index = (start_index + i) % dq->capacity; + history_point_t *p = &dq->points[current_index]; + if ((current_time - p->time) <= window_seconds) { + cJSON *pt = cJSON_CreateObject(); + if (pt) { + cJSON_AddNumberToObject(pt, "x", (long)((p->time - current_time) * 1000)); + cJSON_AddNumberToObject(pt, "y", p->value); + cJSON_AddItemToArray(arr, pt); + } + } + } + return arr; +} + +static cJSON* format_network_history(network_history_deque_t *dq, int window_seconds, const char *key) { + cJSON *arr = cJSON_CreateArray(); + if (!arr || !dq || !dq->points || !key || dq->count == 0) return arr; + + double current_time = time(NULL); + int start_index = (dq->head - dq->count + dq->capacity) % dq->capacity; + + for (int i = 0; i < dq->count; ++i) { + int current_index = (start_index + i) % dq->capacity; + network_history_point_t *p = &dq->points[current_index]; + if ((current_time - p->time) <= window_seconds) { + cJSON *pt = cJSON_CreateObject(); + if (pt) { + cJSON_AddNumberToObject(pt, "x", (long)((p->time - current_time) * 1000)); + cJSON_AddNumberToObject(pt, "y", strcmp(key, "rx_kbps") == 0 ? p->rx_kbps : p->tx_kbps); + cJSON_AddItemToArray(arr, pt); + } + } + } + return arr; +} + +void serve_stats_api(connection_t *conn) { + if (!conn) return; + + cJSON *root = cJSON_CreateObject(); + if (!root) { + send_error_response(conn, 500, "Internal Server Error", "JSON creation failed"); + return; + } + + cJSON *current = cJSON_CreateObject(); + if (!current) { + cJSON_Delete(root); + send_error_response(conn, 500, "Internal Server Error", "JSON creation failed"); + return; + } + cJSON_AddItemToObject(root, "current", current); + + char buffer[64]; + double last_cpu = 0, last_mem = 0; + + if (monitor.cpu_history.count > 0) { + int last_idx = (monitor.cpu_history.head - 1 + monitor.cpu_history.capacity) % monitor.cpu_history.capacity; + last_cpu = monitor.cpu_history.points[last_idx].value; + } + + if (monitor.memory_history.count > 0) { + int last_idx = (monitor.memory_history.head - 1 + monitor.memory_history.capacity) % monitor.memory_history.capacity; + last_mem = monitor.memory_history.points[last_idx].value; + } + + snprintf(buffer, sizeof(buffer), "%.2f", last_cpu); + cJSON_AddStringToObject(current, "cpu_percent", buffer); + snprintf(buffer, sizeof(buffer), "%.2f", last_mem); + cJSON_AddStringToObject(current, "memory_gb", buffer); + cJSON_AddNumberToObject(current, "active_connections", monitor.active_connections); + + cJSON_AddItemToObject(root, "cpu_history", format_history(&monitor.cpu_history, HISTORY_SECONDS)); + cJSON_AddItemToObject(root, "memory_history", format_history(&monitor.memory_history, HISTORY_SECONDS)); + cJSON_AddItemToObject(root, "network_rx_history", format_network_history(&monitor.network_history, HISTORY_SECONDS, "rx_kbps")); + cJSON_AddItemToObject(root, "network_tx_history", format_network_history(&monitor.network_history, HISTORY_SECONDS, "tx_kbps")); + cJSON_AddItemToObject(root, "throughput_history", format_history(&monitor.throughput_history, HISTORY_SECONDS)); + + cJSON *processes = cJSON_CreateArray(); + if (processes) { + cJSON_AddItemToObject(root, "processes", processes); + for (vhost_stats_t *s = monitor.vhost_stats_head; s; s = s->next) { + cJSON *p = cJSON_CreateObject(); + if (p) { + cJSON_AddStringToObject(p, "name", s->vhost_name); + cJSON_AddNumberToObject(p, "http_requests", s->http_requests); + cJSON_AddNumberToObject(p, "websocket_requests", s->websocket_requests); + cJSON_AddNumberToObject(p, "total_requests", s->total_requests); + cJSON_AddNumberToObject(p, "avg_request_time_ms", s->avg_request_time_ms); + cJSON_AddNumberToObject(p, "bytes_sent", s->bytes_sent); + cJSON_AddNumberToObject(p, "bytes_recv", s->bytes_recv); + cJSON_AddItemToObject(p, "throughput_history", format_history(&s->throughput_history, 60)); + cJSON_AddItemToArray(processes, p); + } + } + } + + char *json_string = cJSON_PrintUnformatted(root); + if (!json_string) { + cJSON_Delete(root); + send_error_response(conn, 500, "Internal Server Error", "JSON serialization failed"); + return; + } + + char header[512]; + int hlen = snprintf(header, sizeof(header), + "HTTP/1.1 200 OK\r\n" + "Content-Type: application/json; charset=utf-8\r\n" + "Content-Length: %zu\r\n" + "Connection: keep-alive\r\n" + "Cache-Control: no-cache\r\n" + "\r\n", strlen(json_string)); + + if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + hlen + strlen(json_string)) < 0) { + free(json_string); + cJSON_Delete(root); + send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed"); + return; + } + + memcpy(conn->write_buf.data + conn->write_buf.size, header, hlen); + conn->write_buf.size += hlen; + memcpy(conn->write_buf.data + conn->write_buf.size, json_string, strlen(json_string)); + conn->write_buf.size += strlen(json_string); + + struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT }; + epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event); + + cJSON_Delete(root); + free(json_string); + conn->read_buf.size = 0; + conn->keep_alive = 1; +} + + +// ================================================================================================= +// +// HTTP Implementation +// +// ================================================================================================= + +int find_header_value(const char *headers, const char *header_name, char *value, size_t value_size) { + if (!headers || !header_name || !value || value_size == 0) return 0; + + size_t header_name_len = strlen(header_name); + const char *line_start = headers; + + while (*line_start) { + const char *line_end = strstr(line_start, "\r\n"); + if (!line_end) { + line_end = line_start + strlen(line_start); + } + + size_t line_len = line_end - line_start; + if (line_len > header_name_len + 1) { + if (strncasecmp(line_start, header_name, header_name_len) == 0 && + line_start[header_name_len] == ':') { + + const char *value_start = line_start + header_name_len + 1; + while (value_start < line_end && isspace((unsigned char)*value_start)) { + value_start++; + } + + size_t value_len = line_end - value_start; + if (value_len >= value_size) { + value_len = value_size - 1; + } + + memcpy(value, value_start, value_len); + value[value_len] = '\0'; + trim_whitespace(value); + return 1; + } + } + + if (*line_end == '\r') { + line_start = line_end + 2; + } else if (*line_end == '\0') { + break; + } else { + line_start = line_end + 1; + } + } + + return 0; +} + +int parse_http_request_line(const char *line, http_request_t *request) { + if (!line || !request) return 0; + + memset(request, 0, sizeof(http_request_t)); + + char *line_copy = safe_strdup(line, MAX_REQUEST_LINE_SIZE); + if (!line_copy) return 0; + + trim_whitespace(line_copy); + + char *method = strtok(line_copy, " "); + char *uri = strtok(NULL, " "); + char *version = strtok(NULL, " "); + + if (!method || !uri || !version) { + free(line_copy); + return 0; + } + + if (!is_valid_http_method(method) || !is_valid_http_version(version)) { + free(line_copy); + return 0; + } + + if (strlen(uri) >= sizeof(request->uri)) { + free(line_copy); + return 0; + } + + strncpy(request->method, method, sizeof(request->method) - 1); + request->method[sizeof(request->method) - 1] = '\0'; // Fix: Ensure null termination + + strncpy(request->uri, uri, sizeof(request->uri) - 1); + request->uri[sizeof(request->uri) - 1] = '\0'; // Fix: Ensure null termination + + strncpy(request->version, version, sizeof(request->version) - 1); + request->version[sizeof(request->version) - 1] = '\0'; // Fix: Ensure null termination + + free(line_copy); + return 1; +} + +int parse_http_headers(const char *headers, http_request_t *request) { + if (!headers || !request) return 0; + + char value[256]; + + // Parse Host header + if (find_header_value(headers, "Host", value, sizeof(value))) { + char *colon = strchr(value, ':'); + if (colon) { + *colon = '\0'; // Remove port from hostname + } + strncpy(request->host, value, sizeof(request->host) - 1); + request->host[sizeof(request->host) - 1] = '\0'; // Fix: [-Wstringop-truncation] Ensure null termination + } + + // Parse Content-Length + request->content_length = -1; // Default to unknown + if (find_header_value(headers, "Content-Length", value, sizeof(value))) { + request->content_length = atoi(value); + if (request->content_length < 0) { + request->content_length = 0; + } + } + + // Parse Connection header + if (find_header_value(headers, "Connection", value, sizeof(value))) { + if (strcasecmp(value, "keep-alive") == 0) { + request->keep_alive = 1; + } else if (strcasecmp(value, "upgrade") == 0) { + request->connection_upgrade = 1; + } + } + + // Parse Upgrade header for WebSocket + if (find_header_value(headers, "Upgrade", value, sizeof(value))) { + if (strcasecmp(value, "websocket") == 0) { + request->is_websocket = 1; + } + } + + return 1; +} + +void send_error_response(connection_t *conn, int code, const char* status, const char* body) { + if (!conn || !status || !body) return; + + char response[2048]; + int len = snprintf(response, sizeof(response), + "HTTP/1.1 %d %s\r\n" + "Content-Type: text/plain; charset=utf-8\r\n" + "Content-Length: %zu\r\n" + "Connection: close\r\n" + "Server: ReverseProxy/1.1\r\n" + "\r\n" + "%s", + code, status, strlen(body), body); + + if (len > 0 && len < (int)sizeof(response)) { // Fix: [-Wsign-compare] Cast sizeof to int + if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + len) == 0) { + memcpy(conn->write_buf.data + conn->write_buf.size, response, len); + conn->write_buf.size += len; + + struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT }; + epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event); + } + } + + conn->keep_alive = 0; + conn->state = CLIENT_STATE_ERROR; +} + +void handle_client_data(connection_t *conn) { + if (!conn) return; + + // Update last activity time + conn->last_activity = time(NULL); + + int bytes_read = read(conn->fd, conn->read_buf.data + conn->read_buf.size, + conn->read_buf.capacity - conn->read_buf.size - 1); + + if (bytes_read <= 0) { + if (bytes_read < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) { + return; + } + close_connection(conn->fd); + return; + } + + conn->read_buf.size += bytes_read; + conn->read_buf.data[conn->read_buf.size] = '\0'; + + // Check for complete headers + char *headers_end = strstr(conn->read_buf.data, "\r\n\r\n"); + if (!headers_end) { + // Check if we've exceeded max header size + if (conn->read_buf.size >= MAX_HEADER_SIZE) { + send_error_response(conn, 413, "Request Header Too Large", "Request headers too large"); + } + return; + } + + // Mark request start time + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + conn->request_start_time = ts.tv_sec + ts.tv_nsec / 1e9; + + // Extract request line + char *first_line_end = strstr(conn->read_buf.data, "\r\n"); + if (!first_line_end) { + send_error_response(conn, 400, "Bad Request", "Invalid request line"); + return; + } + + *first_line_end = '\0'; + + // Parse request line + if (!parse_http_request_line(conn->read_buf.data, &conn->request)) { + send_error_response(conn, 400, "Bad Request", "Invalid request line format"); + *first_line_end = '\r'; // restore + return; + } + + *first_line_end = '\r'; // restore + + // Parse headers + char *headers_start = first_line_end + 2; + *headers_end = '\0'; + + if (!parse_http_headers(headers_start, &conn->request)) { + send_error_response(conn, 400, "Bad Request", "Invalid headers"); + *headers_end = '\r'; // restore + return; + } + + *headers_end = '\r'; // restore + + // Handle special dashboard/API routes + if (strcmp(conn->request.method, "GET") == 0) { + if (strncmp(conn->request.uri, "/dashboard", 10) == 0) { + serve_dashboard(conn); + return; + } + if (strncmp(conn->request.uri, "/api/stats", 10) == 0) { + serve_stats_api(conn); + return; + } + } + + // Validate Host header + if (strlen(conn->request.host) == 0) { + send_error_response(conn, 400, "Bad Request", "Host header is required"); + return; + } + + // Find route configuration + route_config_t *route = find_route(conn->request.host); + if (!route) { + char body[512]; + snprintf(body, sizeof(body), "Host not configured: %s", conn->request.host); + send_error_response(conn, 404, "Not Found", body); + return; + } + + // Get or create vhost stats + conn->vhost_stats = monitor_get_or_create_vhost_stats(route->hostname); + conn->is_websocket = conn->request.is_websocket; + conn->keep_alive = conn->request.keep_alive; + + // **FIX**: Store content length and how much body we've already read + conn->http_content_length = conn->request.content_length; + conn->http_body_read = conn->read_buf.size - ((headers_end + 4) - conn->read_buf.data); + if (conn->http_content_length < 0) conn->http_content_length = 0; // Treat unknown length as 0 for this stage + + // Record request start + monitor_record_request_start(conn->vhost_stats, conn->is_websocket); + + // Rewrite Host header if needed + if (route->rewrite_host) { + char new_host_header[320]; + snprintf(new_host_header, sizeof(new_host_header), "Host: %s:%d\r\n", + route->upstream_host, route->upstream_port); + + char host_search[] = "Host:"; + char *host_start = strcasestr(conn->read_buf.data, host_search); + if (host_start) { + char *host_line_end = strstr(host_start, "\r\n"); + if (host_line_end) { + size_t old_len = (host_line_end + 2) - host_start; + size_t new_len = strlen(new_host_header); + size_t tail_len = conn->read_buf.size - (host_start - conn->read_buf.data) - old_len; + + if (new_len != old_len) { + if (buffer_ensure_capacity(&conn->read_buf, conn->read_buf.size - old_len + new_len + 1) < 0) { + send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed"); + return; + } + // Recalculate pointer after potential realloc + host_start = strcasestr(conn->read_buf.data, host_search); + memmove(host_start + new_len, host_start + old_len, tail_len); + conn->read_buf.size = conn->read_buf.size - old_len + new_len; + } + memcpy(host_start, new_host_header, new_len); + conn->read_buf.data[conn->read_buf.size] = '\0'; + } + } + } + + // Transition to connecting upstream + conn->state = CLIENT_STATE_CONNECTING_UPSTREAM; + connect_to_upstream(conn, route); +} + +// ================================================================================================= +// +// Proxy Implementation +// +// ================================================================================================= + +static void set_non_blocking(int fd) { + int flags = fcntl(fd, F_GETFL, 0); + if (flags >= 0) { + fcntl(fd, F_SETFL, flags | O_NONBLOCK); + } +} + +static void add_to_epoll(int fd, uint32_t events) { + struct epoll_event event = { .data.fd = fd, .events = events }; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1) { + log_error("epoll_ctl_add failed"); + close(fd); + } +} + +static void modify_epoll(int fd, uint32_t events) { + struct epoll_event event = { .data.fd = fd, .events = events }; + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) == -1) { + close_connection(fd); + } +} + +void setup_listener_socket(int port) { + int fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) { + log_error("socket failed"); + exit(EXIT_FAILURE); + } + + int reuse = 1; + if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) { + log_error("setsockopt SO_REUSEADDR failed"); + close(fd); + exit(EXIT_FAILURE); + } + + struct sockaddr_in addr = { + .sin_family = AF_INET, + .sin_port = htons(port), + .sin_addr.s_addr = htonl(INADDR_ANY) + }; + + if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) { + log_error("bind failed"); + close(fd); + exit(EXIT_FAILURE); + } + + if (listen(fd, SOMAXCONN) == -1) { + log_error("listen failed"); + close(fd); + exit(EXIT_FAILURE); + } + + set_non_blocking(fd); + add_to_epoll(fd, EPOLLIN); + + connections[fd].type = CONN_TYPE_LISTENER; + connections[fd].fd = fd; + + log_info("Listening on port %d (fd=%d)", port, fd); +} + +void accept_new_connection(int listener_fd) { + struct sockaddr_in client_addr; + socklen_t client_len = sizeof(client_addr); + + int client_fd = accept(listener_fd, (struct sockaddr*)&client_addr, &client_len); + if (client_fd == -1) { + if (errno != EAGAIN && errno != EWOULDBLOCK) { + log_error("accept failed"); + } + return; + } + + if (client_fd >= MAX_FDS) { + log_error("Connection fd too high, closing"); + close(client_fd); + return; + } + + set_non_blocking(client_fd); + add_to_epoll(client_fd, EPOLLIN); + + connection_t *conn = &connections[client_fd]; + memset(conn, 0, sizeof(connection_t)); + conn->type = CONN_TYPE_CLIENT; + conn->state = CLIENT_STATE_READING_REQUEST_LINE; + conn->fd = client_fd; + conn->last_activity = time(NULL); + + if (buffer_init(&conn->read_buf, CHUNK_SIZE) < 0 || + buffer_init(&conn->write_buf, CHUNK_SIZE) < 0) { + close_connection(client_fd); + return; + } + + monitor.active_connections++; + log_debug("New connection on fd %d from %s, total: %d", + client_fd, inet_ntoa(client_addr.sin_addr), monitor.active_connections); +} + +void close_connection(int fd) { + if (fd < 0 || fd >= MAX_FDS || connections[fd].type == CONN_TYPE_UNUSED) return; + + connection_t *conn = &connections[fd]; + + // Close paired connection if exists + if (conn->pair) { + conn->pair->pair = NULL; + close_connection(conn->pair->fd); + } + + // Record request end if needed + if (conn->vhost_stats && conn->request_start_time > 0) { + monitor_record_request_end(conn->vhost_stats, conn->request_start_time); + } + + // Remove from epoll + epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL); + + // Clean up SSL + if (conn->ssl) { + SSL_shutdown(conn->ssl); + SSL_free(conn->ssl); + conn->ssl = NULL; + } + + // Close socket + close(fd); + + // Free buffers + buffer_free(&conn->read_buf); + buffer_free(&conn->write_buf); + + // Update connection count + if (conn->type == CONN_TYPE_CLIENT) { + monitor.active_connections--; + } + + log_debug("Closed connection on fd %d, remaining: %d", fd, monitor.active_connections); + + // Reset connection structure + memset(conn, 0, sizeof(connection_t)); + conn->type = CONN_TYPE_UNUSED; +} + +void connect_to_upstream(connection_t *client, route_config_t *route) { + if (!client || !route) return; + + int up_fd = socket(AF_INET, SOCK_STREAM, 0); + if (up_fd < 0) { + send_error_response(client, 502, "Bad Gateway", "Failed to create upstream socket"); + return; + } + + if (up_fd >= MAX_FDS) { + close(up_fd); + send_error_response(client, 502, "Bad Gateway", "Connection limit exceeded"); + return; + } + + struct sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(route->upstream_port); + + // Try to resolve hostname + if (inet_pton(AF_INET, route->upstream_host, &addr.sin_addr) <= 0) { + struct hostent *he = gethostbyname(route->upstream_host); + if (!he) { + close(up_fd); + send_error_response(client, 502, "Bad Gateway", "Cannot resolve upstream hostname"); + return; + } + memcpy(&addr.sin_addr, he->h_addr_list[0], he->h_length); + } + + set_non_blocking(up_fd); + + int connect_result = connect(up_fd, (struct sockaddr*)&addr, sizeof(addr)); + if (connect_result < 0 && errno != EINPROGRESS) { + close(up_fd); + send_error_response(client, 502, "Bad Gateway", "Failed to connect to upstream"); + return; + } + + add_to_epoll(up_fd, EPOLLIN | EPOLLOUT); + + connection_t *up = &connections[up_fd]; + memset(up, 0, sizeof(connection_t)); + up->type = CONN_TYPE_UPSTREAM; + up->fd = up_fd; + up->last_activity = time(NULL); + + client->pair = up; + up->pair = client; + up->vhost_stats = client->vhost_stats; + + if (buffer_init(&up->read_buf, CHUNK_SIZE) < 0 || + buffer_init(&up->write_buf, CHUNK_SIZE) < 0) { + close_connection(up_fd); + send_error_response(client, 502, "Bad Gateway", "Memory allocation failed"); + return; + } + + if (route->use_ssl) { + up->ssl = SSL_new(ssl_ctx); + if (!up->ssl) { + close_connection(up_fd); + send_error_response(client, 502, "Bad Gateway", "SSL initialization failed"); + return; + } + SSL_set_fd(up->ssl, up_fd); + SSL_set_connect_state(up->ssl); + } + + log_debug("Connecting to upstream %s:%d on fd %d", + route->upstream_host, route->upstream_port, up_fd); +} + +static int do_read(connection_t *conn) { + if (!conn) return -1; + + if (buffer_ensure_capacity(&conn->read_buf, conn->read_buf.size + CHUNK_SIZE) < 0) { + return -1; + } + + int bytes_read; + if (conn->ssl && conn->ssl_handshake_done) { + bytes_read = SSL_read(conn->ssl, conn->read_buf.data + conn->read_buf.size, CHUNK_SIZE); + if (bytes_read <= 0) { + int ssl_error = SSL_get_error(conn->ssl, bytes_read); + if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE) { + errno = EAGAIN; + } + } + } else { + bytes_read = read(conn->fd, conn->read_buf.data + conn->read_buf.size, CHUNK_SIZE); + } + + return bytes_read; +} + +static int do_write(connection_t *conn) { + if (!conn || conn->write_buf.size == 0) return 0; + + int written; + if (conn->ssl && conn->ssl_handshake_done) { + written = SSL_write(conn->ssl, conn->write_buf.data, conn->write_buf.size); + if (written <= 0) { + int ssl_error = SSL_get_error(conn->ssl, written); + if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE) { + errno = EAGAIN; + return 0; + } + } + } else { + written = write(conn->fd, conn->write_buf.data, conn->write_buf.size); + } + + if (written > 0) { + memmove(conn->write_buf.data, conn->write_buf.data + written, + conn->write_buf.size - written); + conn->write_buf.size -= written; + } + + return written; +} + +void handle_client_body(connection_t *conn) { + if (!conn || !conn->pair) { + close_connection(conn->fd); + return; + } + + connection_t *upstream = conn->pair; + conn->last_activity = time(NULL); + + long remaining_to_read_total = conn->http_content_length - conn->http_body_read; + if (remaining_to_read_total <= 0) { + conn->state = CLIENT_STATE_TUNNELING; + return; + } + + size_t can_read_now = conn->read_buf.capacity - conn->read_buf.size; + if (can_read_now > (size_t)remaining_to_read_total) { // Fix: [-Wsign-compare] Cast to size_t + can_read_now = remaining_to_read_total; + } + + if(can_read_now == 0) return; + + int bytes = read(conn->fd, conn->read_buf.data, can_read_now); + + if (bytes > 0) { + conn->http_body_read += bytes; + + if (buffer_ensure_capacity(&upstream->write_buf, upstream->write_buf.size + bytes) < 0) { + close_connection(conn->fd); + return; + } + + memcpy(upstream->write_buf.data + upstream->write_buf.size, conn->read_buf.data, bytes); + upstream->write_buf.size += bytes; + modify_epoll(upstream->fd, EPOLLIN | EPOLLOUT); + + if (conn->http_body_read >= conn->http_content_length) { + log_debug("Finished reading body for fd %d, transitioning to TUNNELING", conn->fd); + conn->state = CLIENT_STATE_TUNNELING; + } + } else if (bytes == 0) { + close_connection(conn->fd); + } else if (errno != EAGAIN && errno != EWOULDBLOCK) { + close_connection(conn->fd); + } +} + +static void handle_tunneling(connection_t *conn) { + if (!conn || !conn->pair) { + close_connection(conn->fd); + return; + } + + conn->last_activity = time(NULL); + + int bytes = do_read(conn); + if (bytes > 0) { + conn->read_buf.size += bytes; + connection_t *pair = conn->pair; + + if (buffer_ensure_capacity(&pair->write_buf, + pair->write_buf.size + conn->read_buf.size) < 0) { + close_connection(conn->fd); + return; + } + + memcpy(pair->write_buf.data + pair->write_buf.size, + conn->read_buf.data, conn->read_buf.size); + pair->write_buf.size += conn->read_buf.size; + + // Update stats + if (conn->vhost_stats) { + if (conn->type == CONN_TYPE_CLIENT) { + conn->vhost_stats->bytes_recv += bytes; + } else { + conn->vhost_stats->bytes_sent += bytes; + } + } + + conn->read_buf.size = 0; + modify_epoll(pair->fd, EPOLLIN | EPOLLOUT); + } else if (bytes == 0) { + close_connection(conn->fd); + } else if (errno != EAGAIN && errno != EWOULDBLOCK) { + close_connection(conn->fd); + } +} + +static void handle_write_event(connection_t *conn) { + if (!conn) return; + + conn->last_activity = time(NULL); + + if (conn->type == CONN_TYPE_UPSTREAM && !conn->ssl_handshake_done) { + // Check if connection is established + int err = 0; + socklen_t len = sizeof(err); + if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &err, &len) != 0 || err != 0) { + close_connection(conn->fd); + return; + } + + // Handle SSL handshake if needed + if (conn->ssl) { + int ret = SSL_do_handshake(conn->ssl); + if (ret == 1) { + conn->ssl_handshake_done = 1; + } else { + int ssl_error = SSL_get_error(conn->ssl, ret); + if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE) { + close_connection(conn->fd); + return; + } + // Continue handshake later + return; + } + } else { + conn->ssl_handshake_done = 1; // No SSL, consider "handshake" done + } + + // Connection established, forward client request + if (conn->ssl_handshake_done && conn->pair) { + connection_t *client = conn->pair; + if (buffer_ensure_capacity(&conn->write_buf, + conn->write_buf.size + client->read_buf.size) < 0) { + close_connection(conn->fd); + return; + } + + memcpy(conn->write_buf.data + conn->write_buf.size, + client->read_buf.data, client->read_buf.size); + conn->write_buf.size += client->read_buf.size; + client->read_buf.size = 0; + + // **FIX**: Transition to the correct state based on Content-Length + if (client->http_body_read >= client->http_content_length) { + client->state = CLIENT_STATE_TUNNELING; + log_debug("Request has no body or was already read, tunneling fd %d", client->fd); + } else { + client->state = CLIENT_STATE_READING_BODY; + log_debug("Request has body, reading body for fd %d", client->fd); + } + + // Record WebSocket request end immediately after connection + if (client->is_websocket && client->vhost_stats) { + monitor_record_request_end(client->vhost_stats, client->request_start_time); + } + } + } + + // Write data if available + int written = do_write(conn); + if (written > 0) { + // Update stats + if(conn->vhost_stats) { + if(conn->type == CONN_TYPE_CLIENT) { + conn->vhost_stats->bytes_sent += written; + } else { + conn->vhost_stats->bytes_recv += written; // This seems reversed, but from perspective of vhost, upstream sends to it. + } + } + } + + if (written < 0 && errno != EAGAIN && errno != EWOULDBLOCK) { + close_connection(conn->fd); + return; + } + + // Adjust epoll events + if (conn->write_buf.size == 0) { + modify_epoll(conn->fd, EPOLLIN); + } +} + +void handle_connection_event(struct epoll_event *event) { + int fd = event->data.fd; + + if (event->events & (EPOLLERR | EPOLLHUP)) { + close_connection(fd); + return; + } + + if (fd < 0 || fd >= MAX_FDS) { + return; + } + + connection_t *conn = &connections[fd]; + + if (conn->type == CONN_TYPE_LISTENER) { + if (event->events & EPOLLIN) { + accept_new_connection(fd); + } + } else { + if (event->events & EPOLLOUT) { + handle_write_event(conn); + } + + if ((event->events & EPOLLIN) && conn->type != CONN_TYPE_UNUSED) { + if (conn->type == CONN_TYPE_CLIENT) { + // **FIX**: Dispatch based on the more detailed state machine + switch (conn->state) { + case CLIENT_STATE_READING_REQUEST_LINE: + handle_client_data(conn); + break; + case CLIENT_STATE_READING_BODY: + handle_client_body(conn); + break; + case CLIENT_STATE_TUNNELING: + handle_tunneling(conn); + break; + default: + // Do nothing for other states like CONNECTING, DONE, ERROR + break; + } + } else { // It's an upstream connection + handle_tunneling(conn); + } + } + } +} + +// ================================================================================================= +// +// Main Implementation +// +// ================================================================================================= + +void create_default_config_if_not_exists(const char* filename) { + FILE *f = fopen(filename, "r"); + if (f) { + fclose(f); + return; + } + + f = fopen(filename, "w"); + if (!f) { + log_error("Cannot create default config file"); + return; + } + + fprintf(f, "{\n" + " \"port\": 8080,\n" + " \"reverse_proxy\": [\n" + " {\n" + " \"hostname\": \"localhost\",\n" + " \"upstream_host\": \"127.0.0.1\",\n" + " \"upstream_port\": 3000,\n" + " \"use_ssl\": false,\n" + " \"rewrite_host\": true\n" + " },\n" + " {\n" + " \"hostname\": \"example.com\",\n" + " \"upstream_host\": \"127.0.0.1\",\n" + " \"upstream_port\": 5000,\n" + " \"use_ssl\": false,\n" + " \"rewrite_host\": false\n" + " }\n" + " ]\n" + "}\n"); + fclose(f); + log_info("Created default config file: %s", filename); +} + +void init_ssl() { + SSL_load_error_strings(); + OpenSSL_add_ssl_algorithms(); + ssl_ctx = SSL_CTX_new(TLS_client_method()); + if (!ssl_ctx) { + log_error("Failed to create SSL context"); + exit(EXIT_FAILURE); + } + + // Set verification options + SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_NONE, NULL); + SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3); +} + +void cleanup() { + log_info("Shutting down proxy..."); + + // Close all connections + for (int i = 0; i < MAX_FDS; i++) { + if (connections[i].type != CONN_TYPE_UNUSED) { + close_connection(i); + } + } + + free_config(); + monitor_cleanup(); + + if (epoll_fd >= 0) { + close(epoll_fd); + } + + if (ssl_ctx) { + SSL_CTX_free(ssl_ctx); + } + + EVP_cleanup(); +} + +void cleanup_idle_connections() { + static time_t last_cleanup = 0; + time_t current_time = time(NULL); + + // Run cleanup every 60 seconds + if (current_time - last_cleanup < 60) { + return; + } + + last_cleanup = current_time; + const time_t timeout = 300; // 5 minutes timeout + + for (int i = 0; i < MAX_FDS; i++) { + connection_t *conn = &connections[i]; + if (conn->type != CONN_TYPE_UNUSED && conn->type != CONN_TYPE_LISTENER) { + if (current_time - conn->last_activity > timeout) { + log_debug("Closing idle connection fd=%d", i); + close_connection(i); + } + } + } +} + +int main(int argc, char *argv[]) { + signal(SIGPIPE, SIG_IGN); + + if (getenv("DEBUG")) { + g_debug_mode = 1; + log_info("Debug mode enabled"); + } + + const char *config_file = (argc > 1) ? argv[1] : "proxy_config.json"; + create_default_config_if_not_exists(config_file); + + if (!load_config(config_file)) { + fprintf(stderr, "Failed to load configuration\n"); + return 1; + } + + init_ssl(); + monitor_init("proxy_stats.db"); + + epoll_fd = epoll_create1(EPOLL_CLOEXEC); + if (epoll_fd == -1) { + log_error("epoll_create1 failed"); + return 1; + } + + // Initialize connections array + for (int i = 0; i < MAX_FDS; i++) { + connections[i].type = CONN_TYPE_UNUSED; + } + + setup_listener_socket(config.port); + + log_info("Reverse proxy running on 0.0.0.0:%d", config.port); + log_info("Dashboard available at http://localhost:%d/dashboard", config.port); + + atexit(cleanup); + + struct epoll_event events[MAX_EVENTS]; + struct timespec last_monitor_update = {0, 0}; + + while (1) { + int n = epoll_wait(epoll_fd, events, MAX_EVENTS, 1000); + if (n == -1) { + if (errno == EINTR) { + continue; + } + log_error("epoll_wait failed"); + break; + } + + for (int i = 0; i < n; i++) { + handle_connection_event(&events[i]); + } + + struct timespec current_time; + clock_gettime(CLOCK_MONOTONIC, ¤t_time); + if (current_time.tv_sec > last_monitor_update.tv_sec) { + monitor_update(); + cleanup_idle_connections(); + last_monitor_update = current_time; + } + } + + return 0; +}