diff --git a/Makefile b/Makefile index 2182e1d60c..ba65343848 100644 --- a/Makefile +++ b/Makefile @@ -214,6 +214,7 @@ RVDIR=$(MOUNT_DIR)/renderervk SDLDIR=$(MOUNT_DIR)/sdl SDLHDIR=$(MOUNT_DIR)/libsdl/include/SDL2 +RSDIR=$(MOUNT_DIR)/recordsystem CMDIR=$(MOUNT_DIR)/qcommon UDIR=$(MOUNT_DIR)/unix W32DIR=$(MOUNT_DIR)/win32 @@ -438,6 +439,8 @@ ifdef MINGW LDFLAGS += -Wl,--gc-sections -fvisibility=hidden LDFLAGS += -lwsock32 -lgdi32 -lwinmm -lole32 -lws2_32 -lpsapi -lcomctl32 LDFLAGS += -flto + LDFLAGS += -lpthread + CLIENT_LDFLAGS=$(LDFLAGS) @@ -707,7 +710,7 @@ endef define DO_DED_CC $(echo_cmd) "DED_CC $<" -$(Q)$(CC) $(CFLAGS) -DDEDICATED -o $@ -c $< +$(Q)$(CC) $(CFLAGS) -DDEDICATED -DENABLE_RS -o $@ -c $< endef define DO_WINDRES @@ -1305,6 +1308,11 @@ Q3DOBJ = \ $(B)/ded/cm_test.o \ $(B)/ded/cm_trace.o \ $(B)/ded/cmd.o \ + $(B)/ded/cJSON.o \ + $(B)/ded/rs_records.o \ + $(B)/ded/rs_common.o \ + $(B)/ded/rs_commands.o \ + $(B)/ded/rs_serverdemos.o \ $(B)/ded/common.o \ $(B)/ded/cvar.o \ $(B)/ded/files.o \ @@ -1384,7 +1392,7 @@ endif $(B)/$(TARGET_SERVER): $(Q3DOBJ) $(echo_cmd) "LD $@" - $(Q)$(CC) -o $@ $(Q3DOBJ) $(LDFLAGS) + $(Q)$(CC) -o $@ $(Q3DOBJ) $(LDFLAGS) -lcurl -lpthread ############################################################################# ## CLIENT/SERVER RULES @@ -1399,6 +1407,9 @@ $(B)/client/%.o: $(CDIR)/%.c $(B)/client/%.o: $(SDIR)/%.c $(DO_CC) +$(B)/client/%.o: $(RSDIR)/%.c + $(DO_CC) + $(B)/client/%.o: $(CMDIR)/%.c $(DO_CC) @@ -1465,6 +1476,9 @@ $(B)/ded/%.o: $(ADIR)/%.s $(B)/ded/%.o: $(SDIR)/%.c $(DO_DED_CC) +$(B)/ded/%.o: $(RSDIR)/%.c + $(DO_DED_CC) + $(B)/ded/%.o: $(CMDIR)/%.c $(DO_DED_CC) diff --git a/code/qcommon/files.c b/code/qcommon/files.c index 2917af27f3..7f2605f590 100644 --- a/code/qcommon/files.c +++ b/code/qcommon/files.c @@ -306,6 +306,7 @@ static cvar_t *fs_apppath; static cvar_t *fs_steampath; static cvar_t *fs_basepath; +static cvar_t *fs_include; // Cyberstorm - Optional extra path. static cvar_t *fs_basegame; static cvar_t *fs_copyfiles; static cvar_t *fs_gamedirvar; @@ -2520,7 +2521,6 @@ static void FS_WriteCacheHeader( FILE *f ) fwrite( cache_header, sizeof( cache_header ), 1, f ); } - static qboolean FS_ValidateCacheHeader( FILE *f ) { byte buf[ sizeof(cache_header) ]; @@ -4103,6 +4103,44 @@ static void FS_Which_f( void ) { } } +static void FS_AddMapDirectory( const char *path, const char *dir ) { + const searchpath_t *sp; + int len; + searchpath_t *search; + int path_len; + int dir_len; + + for ( sp = fs_searchpaths ; sp ; sp = sp->next ) { + if ( sp->dir && !Q_stricmp( sp->dir->path, path ) && !Q_stricmp( sp->dir->gamedir, dir )) { + return; // we've already got this one + } + } + + Q_strncpyz( fs_gamedir, dir, sizeof( fs_gamedir ) ); + + // + // add the directory to the search path + // + path_len = (int) strlen( path ) + 1; + path_len = PAD( path_len, sizeof( int ) ); + dir_len = (int) strlen( dir ) + 1; + dir_len = PAD( dir_len, sizeof( int ) ); + len = sizeof( *search ) + sizeof( *search->dir ) + path_len + dir_len; + + search = Z_TagMalloc( len, TAG_SEARCH_PATH ); + Com_Memset( search, 0, len ); + search->dir = (directory_t*)( search + 1 ); + search->dir->path = (char*)( search->dir + 1 ); + search->dir->gamedir = (char*)( search->dir->path + path_len ); + + strcpy( search->dir->path, path ); + strcpy( search->dir->gamedir, dir ); + + search->next = fs_searchpaths; + fs_searchpaths = search; + fs_dirCount++; +} + //=========================================================================== @@ -4692,6 +4730,8 @@ static void FS_Startup( void ) { Cvar_SetDescription( fs_copyfiles, "Whether or not to copy files when loading them into the game. Every file found in the cdpath will be copied over." ); fs_basepath = Cvar_Get( "fs_basepath", Sys_DefaultBasePath(), CVAR_INIT | CVAR_PROTECTED | CVAR_PRIVATE ); Cvar_SetDescription( fs_basepath, "Write-protected CVAR specifying the path to the installation folder of the game." ); + fs_include = Cvar_Get("fs_include", "", CVAR_INIT); // Cyberstorm + Cvar_SetDescription( fs_include, "Write-protected CVAR specifying additional paths to look for maps." ); fs_basegame = Cvar_Get( "fs_basegame", BASEGAME, CVAR_INIT | CVAR_PROTECTED ); Cvar_SetDescription( fs_basegame, "Write-protected CVAR specifying the path to the base game(s) folder(s), separated by '/'." ); fs_steampath = Cvar_Get( "fs_steampath", "", CVAR_INIT | CVAR_PROTECTED | CVAR_PRIVATE ); @@ -4776,6 +4816,13 @@ static void FS_Startup( void ) { } #endif + // Cyberstorm + if (fs_include->string[0]) { + Com_Printf( "----- NFS -----\n" ); + FS_AddMapDirectory(fs_basepath->string, fs_include->string); + } + // !Cyberstorm + // fs_homepath is somewhat particular to *nix systems, only add if relevant // NOTE: same filtering below for mods and basegame if ( fs_homepath->string[0] && Q_stricmp( fs_homepath->string, fs_basepath->string ) ) { diff --git a/code/recordsystem/cJSON.c b/code/recordsystem/cJSON.c new file mode 100644 index 0000000000..48a401a69d --- /dev/null +++ b/code/recordsystem/cJSON.c @@ -0,0 +1,3143 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 18) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + item->valuestring = NULL; + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + item->string = NULL; + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (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); + 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; + /* 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; + } + if (strlen(valuestring) <= strlen(object->valuestring)) + { + 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)) + { + 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_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); + object = NULL; +} \ No newline at end of file diff --git a/code/recordsystem/cJSON.h b/code/recordsystem/cJSON.h new file mode 100644 index 0000000000..a37d69e1e7 --- /dev/null +++ b/code/recordsystem/cJSON.h @@ -0,0 +1,300 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 18 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* 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 \ No newline at end of file diff --git a/code/recordsystem/recordsystem.h b/code/recordsystem/recordsystem.h new file mode 100644 index 0000000000..ffe17f67ff --- /dev/null +++ b/code/recordsystem/recordsystem.h @@ -0,0 +1,46 @@ +// recordsystem.h -- thread and string utility functions for record system + +#ifndef __RECORDSYSTEM_H__ +#define __RECORDSYSTEM_H__ + +#include +#include + +// String utility functions +qboolean startsWith(const char *string, const char *prefix); +qboolean endsWith(const char *string, const char *suffix); + +typedef struct { + int success; + int targetClientNum; + char *message; + char displayName[MAX_NAME_LENGTH]; + char uuid[UUID_LENGTH]; +} apiResponse_t; + +typedef struct { + char *memory; + size_t size; +} MemoryStruct; + +void RS_Gateway(const char *s); +void Sys_CreateThread(void (*function)(client_t *, const char *), client_t *client, const char *arg); +void RS_GameSendServerCommand(int clientNum, const char *text); +qboolean RS_ExecuteClientCommand(client_t *client, const char *s); +qboolean RS_IsClientTimerStop(const char *s); +char* formatTime(int ms); +char* RS_HttpGet(const char *url); +char* RS_HttpPost(const char *url, const char *contentType, const char *payload); +char* RS_UrlEncode(const char *str); +apiResponse_t* RS_ParseAPIResponse(const char* jsonString); +void RS_PrintAPIResponse(apiResponse_t *response, qboolean mentionClient, qboolean forceBroadcast); +void RS_StartRecord(client_t *client); +void RS_StopRecord(client_t *client); +void RS_WriteGamestate( client_t *client); +void RS_WriteSnapshot(client_t *client); +void RS_SaveDemo(client_t *client); +void RS_DemoHandler(client_t *client); +const char *RS_va(const char *format, ...); +const char *RS_COMParse( const char **data_p ); + +#endif // __RECORDSYSTEM_H__ \ No newline at end of file diff --git a/code/recordsystem/rs_commands.c b/code/recordsystem/rs_commands.c new file mode 100644 index 0000000000..2ce90ea966 --- /dev/null +++ b/code/recordsystem/rs_commands.c @@ -0,0 +1,174 @@ +#include "../server/server.h" +#include "cJSON.h" + +static void RS_Top(client_t *client, const char *str) { + apiResponse_t *response; + char *encoded_str; + char *encoded_map; + char url[512]; + int clientNum = client - svs.clients; + + // Encode the command string + encoded_str = RS_UrlEncode(str); + if (!encoded_str) { + RS_GameSendServerCommand(clientNum, "print \"^1Error encoding command\n\""); + return; + } + + // Encode the map name + encoded_map = RS_UrlEncode(sv_mapname->string); + if (!encoded_map) { + free(encoded_str); // Free already allocated memory + RS_GameSendServerCommand(clientNum, "print \"^1Error encoding map name\n\""); + return; + } + + // Build the URL + Com_sprintf(url, sizeof(url), "http://%s/api/commands/top?client_num=%d&cmd_string=%s&curr_map=%s&gametype=%i&mode=%i&promode=%i", + "149.28.120.254:8000", + clientNum, + encoded_str, + encoded_map, + Cvar_VariableIntegerValue( "defrag_gametype"), + Cvar_VariableIntegerValue( "defrag_mode"), + Cvar_VariableIntegerValue( "df_promode") + ); + + // Free encoded strings when done + free(encoded_str); + free(encoded_map); + + // Make the HTTP request + response = RS_ParseAPIResponse(RS_HttpGet(url)); + + if (response) { + RS_PrintAPIResponse(response, qfalse, qfalse); + free(response); // Free the response + } else { + RS_GameSendServerCommand(clientNum, "print \"^1Failed to get response\n\""); + } +} + +static void RS_Recent(client_t *client, const char *str) { + apiResponse_t *response; + char *encoded_str; + char url[512]; + int clientNum = client - svs.clients; + + encoded_str = RS_UrlEncode(str); + if (!encoded_str) { + RS_GameSendServerCommand(clientNum, "print \"^1Error encoding command\n\""); + return; + } + + // Build the URL + + Com_sprintf(url, sizeof(url), "http://%s/api/commands/recent?client_num=%d&cmd_string=%s", "149.28.120.254:8000", clientNum, encoded_str); + free(encoded_str); // Free encoded string when done + + // Make the HTTP request + response = RS_ParseAPIResponse(RS_HttpGet(url)); + + if (response) { + RS_PrintAPIResponse(response, qfalse, qfalse); + free(response); // Free the response + } else { + RS_GameSendServerCommand(clientNum, "print \"^1Failed to get response\n\""); + } +} + +static void RS_Login(client_t *client, const char *str) { + char *responseString; + char *jsonString; + cJSON *json; + int clientNum = client - svs.clients; + apiResponse_t *response; + char url[512]; + + // Create a JSON object + json = cJSON_CreateObject(); + if (!json) { + RS_GameSendServerCommand(clientNum, "print \"^1Internal engine error, contact server admin.\n\""); + Com_DPrintf("RS_ERROR: Couldn't create JSON Object for string: %s\n", str ); + return; + } + + // Add client number and command string to the JSON object + cJSON_AddNumberToObject(json, "clientNum", clientNum); + cJSON_AddStringToObject(json, "cmdString", str); + cJSON_AddStringToObject(json, "plyrName", client->name); + + // Convert JSON object to string + jsonString = cJSON_Print(json); + cJSON_Delete(json); // Free the JSON object + + if (!jsonString) { + RS_GameSendServerCommand(clientNum, "print \"^1Internal engine error, contact server admin.\n\""); + Com_DPrintf("RS_ERROR: Couldn't convert JSON object to string for string: %s\n", str ); + return; + } + + client->awaitingLogin = qtrue; + Com_sprintf(url, sizeof(url), "http://%s/api/commands/login", "149.28.120.254:8000"); + // Make the HTTP request + responseString = RS_HttpPost(url, "application/json", jsonString); + + free(jsonString); + + response = RS_ParseAPIResponse(responseString); + + if (response) { + if (response->success && strlen(response->uuid) > 0 && strlen(response->displayName) > 0) { + client->loggedIn = client->awaitingLogin; // Make sure client player is the same one that was awaiting login + strncpy(client->uuid, response->uuid, UUID_LENGTH); + strncpy(client->displayName, response->displayName, MAX_NAME_LENGTH); + } + RS_PrintAPIResponse(response, qtrue, qtrue); + } else { + RS_GameSendServerCommand(clientNum, "print \"^1Bad response from server, contact defrag.racing admins\n\""); + Com_DPrintf("RS_ERROR: Couldn't parse response json: %s\n", jsonString ); + } + + client->awaitingLogin = qfalse; + free(response); +} + +static void RS_Logout(client_t *client, const char *str) { + int clientNum = client - svs.clients; + + if (client->loggedIn == qfalse) { + RS_GameSendServerCommand(clientNum, RS_va("print \"%s^5, ^7You are not logged in^5.\n\"", client->name)); + return; + } + client->loggedIn = qfalse; // Log them out locally, don't wait for server. + strcpy(client->uuid, ""); + strcpy(client->displayName, ""); + RS_GameSendServerCommand(-1, RS_va("print \"%s^5, ^7You are now logged out^5.\n\"", client->name)); +} + +typedef struct { + const char *pattern; + void (*handler)(client_t *client, const char *str); +} Module; + +static Module modules[] = { + {"top", RS_Top}, + {"recent", RS_Recent}, + {"login", RS_Login}, + {"logout", RS_Logout} +}; + +qboolean RS_ExecuteClientCommand(client_t *client, const char *s) { + // Check each command pattern + int numModules = sizeof(modules) / sizeof(modules[0]); + for (int i = 0; i < numModules; i++) { + if (startsWith(s, va("%s ",modules[i].pattern)) || Q_stricmp(s, modules[i].pattern) == 0) { + // Call the appropriate handler function + Sys_CreateThread(modules[i].handler, client, s); + return qtrue; + } + } + + // If we reach here, no command matched + return qfalse; +} diff --git a/code/recordsystem/rs_common.c b/code/recordsystem/rs_common.c new file mode 100644 index 0000000000..414a2f6e59 --- /dev/null +++ b/code/recordsystem/rs_common.c @@ -0,0 +1,584 @@ +#include "../server/server.h" +#include +#include "cJSON.h" + +static char com_token[MAX_TOKEN_CHARS]; +static int com_lines; +static int com_tokenline; + + +qboolean startsWith(const char *string, const char *prefix) { + if (!string || !prefix) { + return qfalse; + } + + size_t prefixLen = strlen(prefix); + size_t stringLen = strlen(string); + + if (prefixLen > stringLen) { + return qfalse; + } + + return (strncmp(string, prefix, prefixLen) == 0) ? qtrue : qfalse; +} + +qboolean endsWith(const char *string, const char *suffix) { + if (!string || !suffix) { + return qfalse; + } + + size_t stringLen = strlen(string); + size_t suffixLen = strlen(suffix); + + if (suffixLen > stringLen) { + return qfalse; + } + + return (strcmp(string + stringLen - suffixLen, suffix) == 0) ? qtrue : qfalse; +} + +// Structure to hold the thread arguments +typedef struct { + client_t *client_arg; + char *str_arg; + void (*function)(client_t *, const char *); +} thread_args_t; + +// Wrapper function that unpacks arguments and calls the target function +static void *thread_wrapper(void *data) { + thread_args_t *args = (thread_args_t *)data; + + // Call the actual function with the unpacked arguments + args->function(args->client_arg, args->str_arg); + + // Clean up + if (args->str_arg) { + free(args->str_arg); + } + free(args); + + return NULL; +} + +/* +=============== +Sys_CreateThread + +Create a new thread of execution with client data and a string argument +=============== +*/ +void Sys_CreateThread(void (*function)(client_t *, const char *), client_t *client, const char *arg) { + // We need to duplicate the string argument to ensure it remains valid + // for the duration of the thread + char *arg_copy = NULL; + + if (arg) { + arg_copy = strdup(arg); + if (!arg_copy) { + Com_Error(ERR_FATAL, "Sys_CreateThread: Failed to allocate memory for thread argument"); + return; + } + } + + // Create and populate the argument structure + thread_args_t *args = (thread_args_t *)malloc(sizeof(thread_args_t)); + if (!args) { + if (arg_copy) { + free(arg_copy); + } + Com_Error(ERR_FATAL, "Sys_CreateThread: Failed to allocate memory for thread arguments"); + return; + } + + args->client_arg = client; // Pass client by reference + args->str_arg = arg_copy; + args->function = function; + + pthread_t threadHandle; + pthread_attr_t attr; + int result; + + pthread_attr_init(&attr); + // Create the thread in detached state so its resources are automatically + // freed when it exits + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + + result = pthread_create(&threadHandle, + &attr, + thread_wrapper, + args); + + pthread_attr_destroy(&attr); + + if (result != 0) { + if (args) { + if (args->str_arg) { + free(args->str_arg); + } + free(args); + } + Com_Error(ERR_FATAL, "Sys_CreateThread: pthread_create failed with error %d", result); + } +} + +void RS_GameSendServerCommand(int clientNum, const char *text) { + if (clientNum == -1) { + SV_SendServerCommand(NULL, "%s", text); + } else { + if (clientNum < 0 || clientNum >= sv.maxclients) { + return; + } + SV_SendServerCommand(svs.clients + clientNum, "%s", text); + } +} + +static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) { + size_t realsize = size * nmemb; + MemoryStruct *mem = (MemoryStruct *)userp; + + char *ptr = realloc(mem->memory, mem->size + realsize + 1); + if (!ptr) { + // Out of memory + Com_Printf("RS: Not enough memory for HTTP response\n"); + return 0; + } + + mem->memory = ptr; + memcpy(&(mem->memory[mem->size]), contents, realsize); + mem->size += realsize; + mem->memory[mem->size] = 0; // Null terminate + + return realsize; +} + +/* +=============== +RS_HttpGet + +Performs an HTTP GET request to the specified URL +Returns the response as a null-terminated string that must be freed by the caller +Returns NULL if the request failed +=============== +*/ +char* RS_HttpGet(const char *url) { + CURL *curl; + CURLcode res; + MemoryStruct chunk; + char *response = NULL; + + // Initialize memory structure + chunk.memory = malloc(1); + if (!chunk.memory) { + Com_Printf("RS: Failed to allocate memory for HTTP response\n"); + return NULL; + } + + chunk.size = 0; + + // Initialize cURL + curl_global_init(CURL_GLOBAL_ALL); + curl = curl_easy_init(); + + if (!curl) { + Com_Printf("RS: Failed to initialize cURL handle\n"); + free(chunk.memory); + curl_global_cleanup(); + return NULL; + } + + // Set options + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); + curl_easy_setopt(curl, CURLOPT_USERAGENT, "Quake III Record System"); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1); + curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10); // 10 second timeout + + // Perform the request + Com_Printf("RS: Making HTTP GET request to %s\n", url); + res = curl_easy_perform(curl); + + // Check for errors + if (res != CURLE_OK) { + Com_Printf("RS: HTTP GET failed: %s\n", curl_easy_strerror(res)); + free(chunk.memory); + } else { + // Request successful + Com_Printf("RS: HTTP GET successful (%lu bytes)\n", (unsigned long)chunk.size); + response = chunk.memory; + } + + // Clean up + curl_easy_cleanup(curl); + curl_global_cleanup(); + + return response; +} + +/* +=============== +RS_UrlEncode + +Encodes a string for use in a URL +The returned string must be freed by the caller +=============== +*/ +char* RS_UrlEncode(const char *str) { + if (!str) { + return NULL; + } + + // Characters that don't need encoding + const char *safe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~"; + + // Count the number of characters that need encoding + int len = strlen(str); + int encoded_len = 0; + int i; + + for (i = 0; i < len; i++) { + if (strchr(safe, str[i])) { + encoded_len++; + } else { + encoded_len += 3; // %XX format for each unsafe character + } + } + + // Allocate memory for the encoded string + char *encoded = (char *)malloc(encoded_len + 1); + if (!encoded) { + return NULL; + } + + // Encode the string + char *p = encoded; + for (i = 0; i < len; i++) { + if (strchr(safe, str[i])) { + *p++ = str[i]; + } else { + sprintf(p, "%%%02X", (unsigned char)str[i]); + p += 3; + } + } + *p = '\0'; + + return encoded; +} + +/* +=============== +RS_HttpPost + +Performs an HTTP POST request to the specified URL with the given payload +Parameters: + url - The target URL for the POST request + contentType - The content type of the payload (e.g., "application/json") + payload - The data to send in the POST request +Returns the response as a null-terminated string that must be freed by the caller +Returns NULL if the request failed +=============== +*/ +char* RS_HttpPost(const char *url, const char *contentType, const char *payload) { + CURL *curl; + CURLcode res; + MemoryStruct chunk; + char *response = NULL; + + // Initialize memory structure + chunk.memory = malloc(1); + if (!chunk.memory) { + Com_Printf("RS: Failed to allocate memory for HTTP response\n"); + return NULL; + } + + chunk.size = 0; + + // Initialize cURL + curl_global_init(CURL_GLOBAL_ALL); + curl = curl_easy_init(); + + if (!curl) { + Com_Printf("RS: Failed to initialize cURL handle\n"); + free(chunk.memory); + curl_global_cleanup(); + return NULL; + } + + // Create headers list + struct curl_slist *headers = NULL; + if (contentType) { + char contentTypeHeader[256]; + Com_sprintf(contentTypeHeader, sizeof(contentTypeHeader), "Content-Type: %s", contentType); + headers = curl_slist_append(headers, contentTypeHeader); + } + + // Log endpoint + Com_Printf("RS: Endpoint: %s\n", url); + + // Log headers + Com_Printf("RS: Headers:\n"); + struct curl_slist *temp = headers; + while (temp) { + Com_Printf(" %s\n", temp->data); + temp = temp->next; + } + + // Log payload + // Com_Printf("RS: Payload: %s\n", payload ? payload : "(none)"); + + // Set options + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); + curl_easy_setopt(curl, CURLOPT_USERAGENT, "Quake III Record System"); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1); + curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10); // 10 second timeout + + // Perform the request + Com_Printf("RS: Making HTTP POST request to %s\n", url); + res = curl_easy_perform(curl); + + // Check for errors + if (res != CURLE_OK) { + Com_Printf("RS: HTTP POST failed: %s\n", curl_easy_strerror(res)); + free(chunk.memory); + } else { + // Request successful + Com_Printf("RS: HTTP POST successful (%lu bytes)\n", (unsigned long)chunk.size); + response = chunk.memory; + } + + // Clean up + curl_slist_free_all(headers); + curl_easy_cleanup(curl); + curl_global_cleanup(); + + return response; +} + + +#include +#include +#include +#include "cJSON.h" + +// Function to parse JSON response into apiResponse_t structure +apiResponse_t *RS_ParseAPIResponse(const char* jsonString) { + // Allocate memory for the response structure + apiResponse_t *response = (apiResponse_t*)malloc(sizeof(apiResponse_t)); + if (!response) { + return NULL; // Memory allocation failed + } + + // Initialize with default values + response->success = 0; + response->targetClientNum = 0; + response->message = NULL; + memset(response->displayName, 0, MAX_NAME_LENGTH); + memset(response->uuid, 0, UUID_LENGTH); + + // Parse JSON string + cJSON* json = cJSON_Parse(jsonString); + if (!json) { + free(response); + return NULL; // JSON parsing failed + } + + // Extract success field (integer) + cJSON* successField = cJSON_GetObjectItem(json, "success"); + if (cJSON_IsNumber(successField)) { + response->success = successField->valueint; + } + + // Extract targetClientNumfield (integer) + cJSON* targetClientNumField = cJSON_GetObjectItem(json, "targetClientNum"); + if (cJSON_IsNumber(targetClientNumField)) { + response->targetClientNum = targetClientNumField->valueint; + } + + // Extract message field (string array) + cJSON* messageField = cJSON_GetObjectItem(json, "message"); + if (cJSON_IsString(messageField) && messageField->valuestring && strlen(messageField->valuestring) > 0) { + response->message = strdup(messageField->valuestring); + } + + // Extract displayName field (string array) + cJSON* displayNameField = cJSON_GetObjectItem(json, "displayName"); + if (cJSON_IsString(displayNameField) && displayNameField->valuestring) { + strncpy(response->displayName, displayNameField->valuestring, MAX_NAME_LENGTH - 1); + response->displayName[MAX_NAME_LENGTH - 1] = '\0'; // Ensure null termination + } + + // Extract uuid field (string array) + cJSON* uuidField = cJSON_GetObjectItem(json, "uuid"); + if (cJSON_IsString(uuidField) && uuidField->valuestring) { + strncpy(response->uuid, uuidField->valuestring, UUID_LENGTH - 1); + response->uuid[UUID_LENGTH - 1] = '\0'; // Ensure null termination + } + + // Clean up JSON object + cJSON_Delete(json); + + return response; +} + +void RS_PrintAPIResponse(apiResponse_t *response, qboolean mentionClient, qboolean forceBroadcast) { + const char *finalMessage=""; + const char *mentionPrefix=""; + client_t *targetClient; + + if (response->targetClientNum < -1) { + Com_DPrintf("RS: %s", response->message); + return; + } + + if (mentionClient && response->targetClientNum >= 0) { + targetClient = &svs.clients[response->targetClientNum]; + strlen(targetClient->name) > 0 ? mentionPrefix = RS_va("%s", targetClient->name) : ""; + } + + if (response->message != NULL) { + finalMessage = RS_va("%s%s", mentionPrefix, response->message); + if (forceBroadcast) + RS_GameSendServerCommand(-1, RS_va("print \"^5(^7defrag^5.^7racing^5)^7 %s\n\"", finalMessage)); + else + RS_GameSendServerCommand(response->targetClientNum, RS_va("print \"^5(^7defrag^5.^7racing^5)^7 %s\n\"", finalMessage)); + } +} + +char* formatTime(int ms) { + static char timeString[12]; + + int minutes = ms / 60000; + ms %= 60000; + + int seconds = ms / 1000; + ms %= 1000; + + snprintf(timeString, sizeof(timeString), "%02d.%02d.%03d", minutes, seconds, ms); + + return timeString; +} + +// Thread-safe va +const char *RS_va(const char *format, ...) { + _Thread_local static int index = 0; + _Thread_local static char string[2][32000]; + + char *buf = string[index]; + index ^= 1; + + va_list argptr; + va_start(argptr, format); + vsprintf(buf, format, argptr); + va_end(argptr); + + return buf; +} + + +static const char *SkipWhitespace( const char *data, qboolean *hasNewLines ) { + int c; + + while( (c = *data) <= ' ') { + if( !c ) { + return NULL; + } + if( c == '\n' ) { + com_lines++; + *hasNewLines = qtrue; + } + data++; + } + + return data; +} + +const char *RS_COMParse( const char **data_p ) +{ + int c = 0, len; + qboolean hasNewLines = qfalse; + const char *data; + + data = *data_p; + len = 0; + com_token[0] = '\0'; + com_tokenline = 0; + + // make sure incoming data is valid + if ( !data ) + { + *data_p = NULL; + return com_token; + } + + while ( 1 ) + { + // skip whitespace + data = SkipWhitespace( data, &hasNewLines ); + if ( !data ) + { + *data_p = NULL; + return com_token; + } + + if ( hasNewLines ) + { + *data_p = data; + return com_token; + } + + c = *data; + break; + } + + // token starts on this line + com_tokenline = com_lines; + + // handle quoted strings + if ( c == '"' ) + { + data++; + while ( 1 ) + { + c = *data; + if ( c == '"' || c == '\0' ) + { + if ( c == '"' ) + data++; + com_token[ len ] = '\0'; + *data_p = data; + return com_token; + } + data++; + if ( c == '\n' ) + { + com_lines++; + } + if ( len < ARRAY_LEN( com_token )-1 ) + { + com_token[ len ] = c; + len++; + } + } + } + + // parse a regular word + do + { + if ( len < ARRAY_LEN( com_token )-1 ) + { + com_token[ len ] = c; + len++; + } + data++; + c = *data; + } while ( c > ' ' ); + + com_token[ len ] = '\0'; + + *data_p = data; + return com_token; +} \ No newline at end of file diff --git a/code/recordsystem/rs_records.c b/code/recordsystem/rs_records.c new file mode 100644 index 0000000000..67fad54cf6 --- /dev/null +++ b/code/recordsystem/rs_records.c @@ -0,0 +1,308 @@ +#include "../server/server.h" +#include "cJSON.h" + +/* +==================== +ParseTimerStop +Parses a timer stop log message into a structured format +==================== +*/ + +static timeInfo_t* RS_ParseClientTimerStop(const char *logLine, qboolean debug) { + timeInfo_t* info; + char buffer[1024]; + const char *token, *str; + + // Validate the prefix to ensure there are no color codes between "ClientTimerStop" and ":" + if (!startsWith(logLine, "ClientTimerStop:")) { + return NULL; + } + + // // Find the position of the colon + const char *colonPos = strchr(logLine, ':'); + // if (!colonPos) { + // return NULL; + // } + + // // Check for any characters between "ClientTimerStop" and ":" that aren't spaces + // for (const char *p = logLine + 15; p < colonPos; p++) { + // if (*p != ' ' && *p != '\t') { + // // Found a non-space character (could be ^7 or other color code) + // return NULL; + // } + // } + + // Skip past "ClientTimerStop: " + logLine = colonPos + 2; + while (*logLine && *logLine == ' ') logLine++; // Skip any extra spaces + + info = (timeInfo_t*)Z_Malloc(sizeof(timeInfo_t)); + if (!info) { + return NULL; + } + + // Initialize the structure + memset(info, 0, sizeof(timeInfo_t)); + + // Make a copy of the line to tokenize + Q_strncpyz(buffer, logLine, sizeof(buffer)); + str = buffer; + + // Parse client number + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Validate client number: must be at most 2 characters, no carets + if (strlen(token) > 2 || strchr(token, '^') != NULL) { + Z_Free(info); + return NULL; + } + + info->clientNum = atoi(token); + + // Check that client number is in valid range + if (info->clientNum < 0 || info->clientNum >= MAX_CLIENTS) { + Z_Free(info); + return NULL; + } + + // Parse time + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Validate (no carets) + if (strchr(token, '^') != NULL) { + Z_Free(info); + return NULL; + } + + info->time = atoi(token); + + // Parse mapname + token = RS_COMParse(&str); // Use qtrue to handle quoted strings properly + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Validate time (no carets) + if (strchr(token, '^') != NULL) { + Z_Free(info); + return NULL; + } + + Q_strncpyz(info->mapname, token, sizeof(info->mapname)); + + // Parse player name and check for colon in unquoted name + const char* rawStr = str; // Save position before parsing to check quotes + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Check if the name was quoted in the original string + qboolean wasQuoted = qfalse; + while (*rawStr && (*rawStr == ' ' || *rawStr == '\t')) rawStr++; // Skip whitespace + if (*rawStr == '"') { + wasQuoted = qtrue; + } + + // Check for unquoted name containing a caret + if (!wasQuoted && strchr(token, '^')) { + // Unquoted name contains a caret - reject this line + Z_Free(info); + return NULL; + } + + Q_strncpyz(info->name, token, sizeof(info->name)); + + // Parse gametype + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) != 1) { + Z_Free(info); + return NULL; + } + info->gametype = atoi(token); + + // Parse promode + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) != 1) { + Z_Free(info); + return NULL; + } + info->promode = atoi(token); + + // Parse mode + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) < 2) { + Z_Free(info); + return NULL; + } + info->submode = atoi(token); + + // Parse interference flag + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) != 1) { + Z_Free(info); + return NULL; + } + info->interferenceOff = atoi(token); + + // Parse OB flag + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) != 1) { + Z_Free(info); + return NULL; + } + info->obEnabled = atoi(token); + + // Parse version + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + // Validate (no carets) + if (strchr(token, '^') != NULL) { + Z_Free(info); + return NULL; + } + info->version = atoi(token); + + // Parse date + token = RS_COMParse(&str); + if (!token[0]) { + Z_Free(info); + return NULL; + } + // Validate (no carets) + if (strchr(token, '^') != NULL || strlen(token) != 10) { + Z_Free(info); + return NULL; + } + Q_strncpyz(info->date, token, sizeof(info->date)); + + // Check for trails. Should only be a newline remaining + if ( !(str[0] == '\n' && str[1] == '\0') ) { + Z_Free(info); + return NULL; + } + + if (debug) { + RS_GameSendServerCommand(-1, RS_va("print \"^5Timer stop detected:\n\ +^5clientNum: ^3%i\n\ +^5time: ^3%i\n\ +^5mapname: ^3%s\n\ +^5player name: ^3%s\n\ +^5gametype: ^3%i\n\ +^5promode: ^3%i\n\ +^5mode: ^3%i\n\ +^5interference off: ^3%i\n\ +^5obs enabled: ^3%i\n\ +^5df version: ^3%i\n\ +^5date: ^3%s\n\""\ + , info->clientNum, info->time, info->mapname, info->name, info->gametype, info->promode,\ + info->submode, info->interferenceOff, info->obEnabled, info->version, info->date)); + } + + return info; +} + + +/* +=============== +RS_SendTime + +Sends a time record to the API server +=============== +*/ +static void RS_SendTime(client_t *client, const char *cmdString) { + apiResponse_t *response; + char *jsonString; + cJSON *json; + char url[512]; + + timeInfo_t *timeInfo = RS_ParseClientTimerStop(cmdString, qfalse); + + // Create a JSON object for the request + json = cJSON_CreateObject(); + if (!json) { + return; + } + + // Add properties to the JSON object + cJSON_AddStringToObject(json, "cmdString", cmdString); + cJSON_AddStringToObject(json, "uuid", svs.clients[timeInfo->clientNum].uuid); + + // Convert JSON object to string + jsonString = cJSON_Print(json); + cJSON_Delete(json); // Free the JSON object + // Com_DPrintf("json payload: %s\n", jsonString); + + Com_sprintf(url, sizeof(url), "http://%s/api/records", "149.28.120.254:8000"); + + // Make the HTTP request + response = RS_ParseAPIResponse(RS_HttpPost(url, "application/json", jsonString)); + + // Free the JSON string + free(jsonString); + + if (response) { + RS_PrintAPIResponse(response, qtrue, qtrue); + free(response); + } else { + RS_GameSendServerCommand(timeInfo->clientNum, "print \"^1Failed to connect to record server\n\""); + } +} + +void RS_Gateway(const char *s) { + timeInfo_t *timeInfo = RS_ParseClientTimerStop(s, qtrue); + if (timeInfo && Cvar_VariableIntegerValue("sv_cheats") == 0) { + + client_t *client = &svs.clients[timeInfo->clientNum]; + if (client->loggedIn) { + client->awaitingDemoSave = qtrue; + client->timerStopTime = svs.time; + client->timerStopInfo = timeInfo; + Sys_CreateThread(RS_SendTime, client, s); + } + else { + RS_GameSendServerCommand(timeInfo->clientNum, "print \"^7You are not logged in^5.\n\""); + RS_StopRecord(client); + } + } +} diff --git a/code/recordsystem/rs_serverdemos.c b/code/recordsystem/rs_serverdemos.c new file mode 100644 index 0000000000..5eb371a00c --- /dev/null +++ b/code/recordsystem/rs_serverdemos.c @@ -0,0 +1,451 @@ +#include "../server/server.h" + +// Static storage for delta compression +static void RS_EmitPacketEntities( const clientSnapshot_t *from, const clientSnapshot_t *to, msg_t *msg, entityState_t *oldents ); + +/* +==================== +RS_StartRecord + +Begins recording a demo for a given client +==================== +*/ +void RS_StartRecord(client_t *client) { + char demoName[MAX_OSPATH]; + int clientNum = client - svs.clients; + + if (client->state != CS_ACTIVE) { + return; + } + + if (client->isRecording) { + Com_Printf("Already recording client %i\n", clientNum); + return; + } + + // Create demo name + Q_strncpyz(demoName, va("demos/[%d].dm_68", clientNum), sizeof(demoName)); + + Com_Printf("recording to %s.\n", demoName); + + // Start writing to demo file + client->demoFile = FS_FOpenFileWrite(demoName); + if (client->demoFile == FS_INVALID_HANDLE) { + Com_Printf("ERROR: couldn't open file: %s.\n", demoName); + return; + } + + Q_strncpyz(client->demoName, demoName, sizeof(demoName)); + // Set client's demo flags + client->isRecording = qtrue; + // client->demoWaiting = qtrue; + + // write out the gamestate message + RS_WriteGamestate( client ); +} + +/* +==================== +RS_SaveDemo + +Save a demo on a logged clientTimerStop +==================== +*/ +void RS_SaveDemo(client_t *client) { + int clientNum = client - svs.clients; + char finalName[MAX_OSPATH]; + timeInfo_t *timeInfo = client->timerStopInfo; + + if (!client->isRecording) { + Com_Printf("Client %i is not being recorded\n", clientNum); + return; + } + + if (client->demoFile != FS_INVALID_HANDLE) { + int len; + + // Write proper EOF markers - TWO -1 values + len = -1; + FS_Write(&len, 4, client->demoFile); + FS_Write(&len, 4, client->demoFile); + + FS_FCloseFile(client->demoFile); + client->demoFile = FS_INVALID_HANDLE; + Com_Printf("Stopped recording client %i\n", clientNum); + } + + if (timeInfo->gametype == 1) { // run mode + Com_sprintf( finalName, sizeof( finalName ), "demos/%s[mdf.%s]%s[%s][%s].dm_68", \ + timeInfo->mapname, \ + timeInfo->promode ? "cpm" : "vq3", \ + formatTime(timeInfo->time), \ + client->displayName, \ + client->uuid); + } + else { + Com_sprintf( finalName, sizeof( finalName ), "demos/%s[mfc.%s.%i]%s[%s][%s].dm_68", \ + timeInfo->mapname, \ + timeInfo->promode ? "cpm" : "vq3", \ + timeInfo->submode, \ + formatTime(timeInfo->time), \ + client->displayName, \ + client->uuid); + } + + if (client->demoFile != FS_INVALID_HANDLE) { + int len; + + // Write proper EOF markers - TWO -1 values + len = -1; + FS_Write(&len, 4, client->demoFile); + FS_Write(&len, 4, client->demoFile); + + FS_FCloseFile(client->demoFile); + client->demoFile = FS_INVALID_HANDLE; + Com_Printf("Stopped recording client %i\n", clientNum); + } + + FS_Rename( client->demoName, finalName ); + Com_Printf("Saved demo: %s\n", finalName); + client->awaitingDemoSave = qfalse; + client->demoFile = FS_INVALID_HANDLE; + client->isRecording = qfalse; +} + +/* +==================== +RS_StopRecord + +stop recording a demo +==================== +*/ +void RS_StopRecord(client_t *client) { + if (client->awaitingDemoSave) + return RS_SaveDemo(client); + int clientNum = client - svs.clients; + + if (!client->isRecording) { + Com_Printf("Client %i is not being recorded\n", clientNum); + return; + } + + if (client->demoFile != FS_INVALID_HANDLE) { + int len; + + // Write proper EOF markers - TWO -1 values + len = -1; + FS_Write(&len, 4, client->demoFile); + FS_Write(&len, 4, client->demoFile); + + FS_FCloseFile(client->demoFile); + client->demoFile = FS_INVALID_HANDLE; + Com_Printf("Stopped recording client %i\n", clientNum); + } + + client->isRecording = qfalse; +} + +/* +==================== +RS_WriteGamestate +==================== +*/ +void RS_WriteGamestate(client_t *client) { + int i; + const svEntity_t *svEnt; + msg_t msg; + byte msgBuffer[ MAX_MSGLEN_BUF ]; + int len; + // entityState_t *ent; + entityState_t nullstate; + + // accept usercmds starting from current server time only + // Com_Memset( &client->lastUsercmd, 0x0, sizeof( client->lastUsercmd ) ); + // client->lastUsercmd.serverTime = sv.time - 1; + + MSG_Init( &msg, msgBuffer, MAX_MSGLEN ); + MSG_Bitstream( &msg ); + + // NOTE, MRE: all server->client messages now acknowledge + // let the client know which reliable clientCommands we have received + MSG_WriteLong( &msg, client->lastClientCommand ); + + client->demoMessageSequence = 1; + client->demoCommandSequence = client->reliableSequence; + // send any server commands waiting to be sent first. + // we have to do this cause we send the client->reliableSequence + // with a gamestate and it sets the clc.serverCommandSequence at + // the client side + // SV_UpdateServerCommandsToClient( client, &msg ); + + client->demoDeltaNum = 0; + // send the gamestate + MSG_WriteByte( &msg, svc_gamestate ); + MSG_WriteLong( &msg, client->reliableSequence ); + + // write the configstrings + for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) { + if ( *sv.configstrings[ i ] != '\0' ) { + MSG_WriteByte( &msg, svc_configstring ); + MSG_WriteShort( &msg, i ); + if ( i == CS_SYSTEMINFO && sv.pure != sv_pure->integer ) { + // make sure we send latched sv.pure, not forced cvar value + char systemInfo[BIG_INFO_STRING]; + Q_strncpyz( systemInfo, sv.configstrings[ i ], sizeof( systemInfo ) ); + Info_SetValueForKey_s( systemInfo, sizeof( systemInfo ), "sv_pure", va( "%i", sv.pure ) ); + MSG_WriteBigString( &msg, systemInfo ); + } else { + MSG_WriteBigString( &msg, sv.configstrings[i] ); + } + } + } + + // write the baselines + Com_Memset( &nullstate, 0, sizeof( nullstate ) ); + for ( i = 0 ; i < MAX_GENTITIES; i++ ) { + if ( !sv.baselineUsed[i] ) { + continue; + } + svEnt = &sv.svEntities[i]; + MSG_WriteByte( &msg, svc_baseline ); + MSG_WriteDeltaEntity( &msg, &nullstate, &svEnt->baseline, qtrue ); + } + + MSG_WriteByte( &msg, svc_EOF ); + + MSG_WriteLong( &msg, client - svs.clients ); // client num + + // write the checksum feed + MSG_WriteLong( &msg, sv.checksumFeed ); + + // it is important to handle gamestate overflow + // but at this stage client can't process any reliable commands + // so at least try to inform him in console and release connection slot + // if ( msg.overflowed ) { + // if ( client->netchan.remoteAddress.type == NA_LOOPBACK ) { + // Com_Error( ERR_DROP, "gamestate overflow" ); + // } else { + // NET_OutOfBandPrint( NS_SERVER, &client->netchan.remoteAddress, "print\n" S_COLOR_RED "SERVER ERROR: gamestate overflow\n" ); + // SV_DropClient( client, "gamestate overflow" ); + // } + // return; + // } + + // Finalize message + MSG_WriteByte(&msg, svc_EOF); + + // Write to demo file + // Sequence should be properly set to match client expectation + len = LittleLong(0); // Gamestate uses sequence 0 + FS_Write(&len, 4, client->demoFile); + + len = LittleLong(msg.cursize); + + FS_Write(&len, 4, client->demoFile); + + FS_Write(msg.data, msg.cursize, client->demoFile); +} + +/* +==================== +RS_WriteServerCommands +==================== +*/ +static void RS_WriteServerCommands(msg_t *msg, client_t *client) { + int i; + + // Write all commands since the last recorded command + if (client->reliableSequence - client->demoCommandSequence > 0) { + // Don't write more than MAX_RELIABLE_COMMANDS + if (client->reliableSequence - client->demoCommandSequence > MAX_RELIABLE_COMMANDS) { + client->demoCommandSequence = client->reliableSequence - MAX_RELIABLE_COMMANDS; + } + + for (i = client->demoCommandSequence + 1; i <= client->reliableSequence; i++) { + int index = i & (MAX_RELIABLE_COMMANDS - 1); + MSG_WriteByte(msg, svc_serverCommand); + MSG_WriteLong(msg, i); + MSG_WriteString(msg, client->reliableCommands[index]); + } + } + + client->demoCommandSequence = client->reliableSequence; +} + +/* +==================== +RS_WriteSnapshot +==================== +*/ +void RS_WriteSnapshot(client_t *client) { + byte bufData[MAX_MSGLEN_BUF]; + clientSnapshot_t *oldsnap; + playerState_t *oldps; + msg_t msg; + int i, len; + int snapFlags; + + clientSnapshot_t *snap; + // Get current snapshot + snap = &client->frames[client->netchan.outgoingSequence & PACKET_MASK]; + // Com_DPrintf("Writing snapshot to client: %i\n", frame->frameNum); + + MSG_Init( &msg, bufData, MAX_MSGLEN ); + MSG_Bitstream( &msg ); + + // Write reliable sequence + MSG_WriteLong(&msg, client->reliableSequence); + + // Write server commands + RS_WriteServerCommands(&msg, client); + + MSG_WriteByte( &msg, svc_snapshot ); + MSG_WriteLong( &msg, sv.time ); // sv.time + MSG_WriteByte( &msg, client->demoDeltaNum ); // 0 or 1 + + snapFlags = svs.snapFlagServerBit; + if ( client->rateDelayed ) { + snapFlags |= SNAPFLAG_RATE_DELAYED; + } + if ( client->state != CS_ACTIVE ) { + snapFlags |= SNAPFLAG_NOT_ACTIVE; + } + MSG_WriteByte( &msg, snapFlags ); // snapFlags. NOTE: in client-side it's snap->snapFlags which doesn't exist in clientSnapshot_t. + MSG_WriteByte( &msg, snap->areabytes ); // areabytes + MSG_WriteData( &msg, snap->areabits, snap->areabytes ); // NOTE: snap->areabits is snap->areamask in client side. + + if ( client->demoDeltaNum == 0 ) {// First snapshot, don't delta compress. + oldsnap = NULL; + oldps = NULL; + } + else { + oldsnap = &client->savedSnap; + oldps = &client->savedSnap.ps; + } + + MSG_WriteDeltaPlayerstate( &msg, oldps, &snap->ps ); + RS_EmitPacketEntities(oldsnap, snap, &msg, client->savedEnts); + // Finalize message + MSG_WriteByte(&msg, svc_EOF); + + // Write to demo file + len = LittleLong(client->demoMessageSequence); // client->netchan.outgoingSequence + FS_Write(&len, 4, client->demoFile); + + len = LittleLong(msg.cursize); + FS_Write(&len, 4, client->demoFile); + FS_Write(msg.data, msg.cursize, client->demoFile); + + // Save this snapshot for delta compression of next snapshot + // Create deep copies of entity pointers for delta compression + for (i = 0; i < snap->num_entities; i++) { + // Make a copy of each entity state + client->savedEnts[i] = *(snap->ents[i]); + } + // Copy the frame structure + client->savedSnap = *snap; + + // Update tracking variables + client->demoMessageSequence++; + client->demoDeltaNum = 1; // Turn on delta for next snapshot +} + +/* +================= +RS_EmitPacketEntities +================= +*/ +static void RS_EmitPacketEntities( const clientSnapshot_t *from, const clientSnapshot_t *to, msg_t *msg, entityState_t *oldents ) { + entityState_t *oldent, *newent; + int oldindex, newindex; + int oldnum, newnum; + int from_num_entities; + + // generate the delta update + if ( !from ) { + from_num_entities = 0; + } else { + from_num_entities = from->num_entities; + } + + newent = NULL; + oldent = NULL; + newindex = 0; + oldindex = 0; + while ( newindex < to->num_entities || oldindex < from_num_entities ) { + if ( newindex >= to->num_entities ) { + newnum = MAX_GENTITIES+1; + } else { + newent = to->ents[ newindex ]; + newnum = newent->number; + } + + if ( oldindex >= from_num_entities ) { + oldnum = MAX_GENTITIES+1; + } else { + oldent = from->ents[ oldindex ]; + oldnum = oldent->number; + } + + if ( newnum == oldnum ) { + // delta update from old position + // because the force parm is qfalse, this will not result + // in any bytes being emitted if the entity has not changed at all + MSG_WriteDeltaEntity (msg, oldent, newent, qfalse ); + oldindex++; + newindex++; + continue; + } + + if ( newnum < oldnum ) { + // this is a new entity, send it from the baseline + MSG_WriteDeltaEntity (msg, &sv.svEntities[newnum].baseline, newent, qtrue ); + newindex++; + continue; + } + + if ( newnum > oldnum ) { + // the old entity isn't present in the new message + MSG_WriteDeltaEntity (msg, oldent, NULL, qtrue ); + oldindex++; + continue; + } + } + + MSG_WriteBits( msg, (MAX_GENTITIES-1), GENTITYNUM_BITS ); +} + +void RS_DemoHandler(client_t *client) { + clientSnapshot_t clFrame = client->frames[client->netchan.outgoingSequence & PACKET_MASK]; + int frameMsec = 1000 / sv_fps->integer * com_timescale->value; + + // Client un-recordable + if (clFrame.ps.pm_type == PM_SPECTATOR || clFrame.ps.pm_type == PM_DEAD || clFrame.ps.pm_flags & PMF_FOLLOW) { + if (client->awaitingDemoSave) { // short-circuit, save demo. + RS_SaveDemo(client); + } + + if (client->isRecording) { + RS_StopRecord(client); + } + } + + // Player is recordable + else { + if (client->isRecording) { // Recording already + RS_WriteSnapshot(client); + } + + else { // Start recording + if (client->state == CS_ACTIVE) { + RS_StartRecord(client); + } + } + + // Save demo? + if (client->awaitingDemoSave) { + if (svs.time - client->timerStopTime > 500*frameMsec) // Enough frames have passed from timer stop to stop recording + RS_SaveDemo(client); + } + } +} \ No newline at end of file diff --git a/code/server/server.h b/code/server/server.h index d096f685f1..1eb12dcab1 100644 --- a/code/server/server.h +++ b/code/server/server.h @@ -33,6 +33,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // GAME BOTH REFERENCE !!! #define MAX_ENT_CLUSTERS 16 +#define UUID_LENGTH 37 typedef struct svEntity_s { struct worldSector_s *worldSector; @@ -90,6 +91,7 @@ typedef struct { int time; byte baselineUsed[ MAX_GENTITIES ]; + } server_t; typedef struct { @@ -156,6 +158,20 @@ typedef enum { GSA_ACKED // gamestate acknowledged, no retansmissions needed } gameStateAck_t; +typedef struct { + int clientNum; // Entity/client number + int time; // Timer time (in milliseconds) + char mapname[64]; // Map name + char name[36]; // Player's name + int gametype; // Gametype + int promode; // Promode enabled + int submode; // Sub-mode + int interferenceOff; // Interference off flag + int obEnabled; // Out of bounds enabled + int version; // Version number + char date[16]; // Date string (YYYY-MM-DD) +} timeInfo_t; + typedef struct client_s { clientState_t state; char userinfo[MAX_INFO_STRING]; // name, etc @@ -229,6 +245,28 @@ typedef struct client_s { char tld[3]; // "XX\0" const char *country; +#ifdef ENABLE_RS + qboolean loggedIn; + qboolean demoWaiting; + qboolean awaitingLogin; + qboolean awaitingLogout; + qboolean isRecording; + qboolean isSpectating; + qboolean awaitingDemoSave; + int timerStopTime; + timeInfo_t *timerStopInfo; + char uuid[UUID_LENGTH]; + char displayName[MAX_NAME_LENGTH]; + fileHandle_t demoFile; + char demoName[MAX_OSPATH]; + + int eventMask; + int demoCommandSequence; + int demoDeltaNum; + int demoMessageSequence; + clientSnapshot_t savedSnap; + entityState_t savedEnts[ MAX_SNAPSHOT_ENTITIES ]; +#endif } client_t; //============================================================================= @@ -389,7 +427,7 @@ client_t *SV_GetPlayerByHandle( void ); void SV_AddServerCommand( client_t *client, const char *cmd ); void SV_UpdateServerCommandsToClient( client_t *client, msg_t *msg ); void SV_WriteFrameToClient( client_t *client, msg_t *msg ); -void SV_SendMessageToClient( msg_t *msg, client_t *client ); +void SV_SendMessageToClient(msg_t *msg, client_t *client, qboolean isSnapshot); void SV_SendClientMessages( void ); void SV_SendClientSnapshot( client_t *client ); @@ -498,3 +536,7 @@ void SV_LoadFilters( const char *filename ); const char *SV_RunFilters( const char *userinfo, const netadr_t *addr ); void SV_AddFilter_f( void ); void SV_AddFilterCmd_f( void ); + +#ifdef ENABLE_RS +#include "../recordsystem/recordsystem.h" +#endif \ No newline at end of file diff --git a/code/server/sv_ccmds.c b/code/server/sv_ccmds.c index 417df49d5b..0029775e5d 100644 --- a/code/server/sv_ccmds.c +++ b/code/server/sv_ccmds.c @@ -158,12 +158,16 @@ static void SV_Map_f( void ) { char expanded[MAX_QPATH]; char mapname[MAX_QPATH]; int len; + int i; map = Cmd_Argv(1); if ( !map || !*map ) { return; } + for(i = 0; i < MAX_QPATH; i++) + expanded[i] = tolower(expanded[i]); + // make sure the level exists before trying to change, so that // a typo at the server console won't end the game Com_sprintf( expanded, sizeof( expanded ), "maps/%s.bsp", map ); diff --git a/code/server/sv_client.c b/code/server/sv_client.c index 5e8458cd74..710a443c91 100644 --- a/code/server/sv_client.c +++ b/code/server/sv_client.c @@ -867,6 +867,10 @@ void SV_DropClient( client_t *drop, const char *reason ) { return; // already dropped } + #ifdef ENABLE_RS + RS_StopRecord(drop); + #endif + isBot = drop->netchan.remoteAddress.type == NA_BOT; Q_strncpyz( name, drop->name, sizeof( name ) ); // for further DPrintf() because drop->name will be nuked in SV_SetUserinfo() @@ -1128,7 +1132,7 @@ static void SV_SendClientGameState( client_t *client ) { } // deliver this to the client - SV_SendMessageToClient( &msg, client ); + SV_SendMessageToClient( &msg, client, qfalse ); } @@ -1169,9 +1173,14 @@ void SV_ClientEnterWorld( client_t *client ) { client->deltaMessage = client->netchan.outgoingSequence - (PACKET_BACKUP + 1); // force delta reset client->lastSnapshotTime = svs.time - 9999; // generate a snapshot immediately - // call the game begin function VM_Call( gvm, 1, GAME_CLIENT_BEGIN, clientNum ); + #ifdef ENABLE_RS + client->isRecording = qfalse; + Com_DPrintf("-----here----\n"); + Com_DPrintf("Logged: %i, Sequence: %i\n", client->loggedIn, client->reliableSequence); + // client->loggedIn = qfalse; + #endif } @@ -2039,7 +2048,7 @@ qboolean SV_ExecuteClientCommand( client_t *cl, const char *s ) { #ifndef DEDICATED if ( !com_cl_running->integer && bFloodProtect && SV_FloodProtect( cl ) ) { #else - if ( bFloodProtect && SV_FloodProtect( cl ) ) { + if ( bFloodProtect && SV_FloodProtect( cl ) ) { #endif // ignore any other text messages from this client but let them keep playing Com_DPrintf( "client text ignored for %s: %s\n", cl->name, Cmd_Argv(0) ); @@ -2050,6 +2059,7 @@ qboolean SV_ExecuteClientCommand( client_t *cl, const char *s ) { Cmd_Args_Sanitize( "\n\r;" ); // handle ';' for OSP else Cmd_Args_Sanitize( "\n\r" ); + VM_Call( gvm, 1, GAME_CLIENT_COMMAND, cl - svs.clients ); } } @@ -2084,10 +2094,17 @@ static qboolean SV_ClientCommand( client_t *cl, msg_t *msg ) { return qfalse; } +#ifdef ENABLE_RS + if (!RS_ExecuteClientCommand(cl, s)) { + if ( !SV_ExecuteClientCommand( cl, s ) ) { + return qfalse; + } + } +#else if ( !SV_ExecuteClientCommand( cl, s ) ) { return qfalse; } - +#endif cl->lastClientCommand = seq; Q_strncpyz( cl->lastClientCommandString, s, sizeof( cl->lastClientCommandString ) ); diff --git a/code/server/sv_game.c b/code/server/sv_game.c index f8d05651e5..6c4a17e3d4 100644 --- a/code/server/sv_game.c +++ b/code/server/sv_game.c @@ -22,9 +22,9 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // sv_game.c -- interface to the game dll #include "server.h" - #include "../botlib/botlib.h" + botlib_export_t *botlib_export; // these functions must be used instead of pointer arithmetic, because @@ -361,6 +361,9 @@ The module is making a system call static intptr_t SV_GameSystemCalls( intptr_t *args ) { switch( args[0] ) { case G_PRINT: + #ifdef ENABLE_RS + RS_Gateway((const char *)VMA(1)); + #endif Com_Printf( "%s", (const char*)VMA(1) ); return 0; case G_ERROR: diff --git a/code/server/sv_init.c b/code/server/sv_init.c index 1cd02b8bb7..93c273924a 100644 --- a/code/server/sv_init.c +++ b/code/server/sv_init.c @@ -832,6 +832,9 @@ void SV_Init( void ) SV_TrackCvarChanges(); SV_InitChallenger(); + // #ifdef ENABLE_RS + // RS_InitThreadedDemos(); + // #endif } @@ -882,7 +885,9 @@ void SV_Shutdown( const char *finalmsg ) { if ( !com_sv_running || !com_sv_running->integer ) { return; } - + // #ifdef ENABLE_RS + // RS_ShutdownThreadedDemos(); + // #endif Com_Printf( "----- Server Shutdown (%s) -----\n", finalmsg ); #ifdef USE_IPV6 diff --git a/code/server/sv_main.c b/code/server/sv_main.c index 5b46961078..6a1663f425 100644 --- a/code/server/sv_main.c +++ b/code/server/sv_main.c @@ -1117,6 +1117,9 @@ static void SV_CheckTimeouts( void ) { if ( cl->state == CS_ZOMBIE && cl->lastPacketTime - zombiepoint < 0 ) { // using the client id cause the cl->name is empty at this point SV_PrintClientStateChange( cl, CS_FREE ); + #ifdef ENABLE_RS + RS_StopRecord(cl); + #endif cl->state = CS_FREE; // can now be reused continue; } @@ -1385,7 +1388,7 @@ void SV_Frame( int msec ) { sv.timeResidual -= frameMsec; svs.time += frameMsec; sv.time += frameMsec; - + // let everything in the world think and move VM_Call( gvm, 1, GAME_RUN_FRAME, sv.time ); } diff --git a/code/server/sv_snapshot.c b/code/server/sv_snapshot.c index e790ab2598..11e03e2eae 100644 --- a/code/server/sv_snapshot.c +++ b/code/server/sv_snapshot.c @@ -22,7 +22,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "server.h" - /* ============================================================================= @@ -686,15 +685,20 @@ SV_SendMessageToClient Called by SV_SendClientSnapshot and SV_SendClientGameState ======================= */ -void SV_SendMessageToClient( msg_t *msg, client_t *client ) -{ - // record information about the message - client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg->cursize; - client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.msgTime; - client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = 0; +void SV_SendMessageToClient(msg_t *msg, client_t *client, qboolean isSnapshot) { + // record information about the message + + client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg->cursize; + client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.msgTime; + client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = 0; - // send the datagram - SV_Netchan_Transmit( client, msg ); + // send the datagram + SV_Netchan_Transmit(client, msg); + +#ifdef ENABLE_RS + if (isSnapshot) + RS_DemoHandler(client); +#endif } @@ -739,7 +743,7 @@ void SV_SendClientSnapshot( client_t *client ) { MSG_Clear( &msg ); } - SV_SendMessageToClient( &msg, client ); + SV_SendMessageToClient( &msg, client, qtrue ); }