1 /*
2 Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 THE SOFTWARE.
21 */
22
23 /* cJSON */
24 /* JSON parser in C. */
25
26 /* disable warnings about old C89 functions in MSVC */
27 #if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
28 #define _CRT_SECURE_NO_DEPRECATE
29 #endif
30
31 #ifdef __GNUC__
32 #pragma GCC visibility push(default)
33 #endif
34 #if defined(_MSC_VER)
35 #pragma warning (push)
36 /* disable warning about single line comments in system headers */
37 #pragma warning (disable : 4001)
38 #endif
39
40 #include <string.h>
41 #include <stdio.h>
42 #include <math.h>
43 #include <stdlib.h>
44 #include <limits.h>
45 #include <ctype.h>
46 #include <float.h>
47
48 #ifdef ENABLE_LOCALES
49 #include <locale.h>
50 #endif
51
52 #if defined(_MSC_VER)
53 #pragma warning (pop)
54 #endif
55 #ifdef __GNUC__
56 #pragma GCC visibility pop
57 #endif
58
59 #include "cJSON.h"
60
61 /* define our own boolean type */
62 #ifdef true
63 #undef true
64 #endif
65 #define true ((cJSON_bool)1)
66
67 #ifdef false
68 #undef false
69 #endif
70 #define false ((cJSON_bool)0)
71
72 /* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */
73 #ifndef isinf
74 #define isinf(d) (isnan((d - d)) && !isnan(d))
75 #endif
76 #ifndef isnan
77 #define isnan(d) (d != d)
78 #endif
79
80 #ifndef NAN
81 #define NAN 0.0/0.0
82 #endif
83
84 typedef struct {
85 const unsigned char *json;
86 size_t position;
87 } error;
88 static error global_error = { NULL, 0 };
89
cJSON_GetErrorPtr(void)90 CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
91 {
92 return (const char*) (global_error.json + global_error.position);
93 }
94
cJSON_GetStringValue(const cJSON * const item)95 CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)
96 {
97 if (!cJSON_IsString(item))
98 {
99 return NULL;
100 }
101
102 return item->valuestring;
103 }
104
cJSON_GetNumberValue(const cJSON * const item)105 CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)
106 {
107 if (!cJSON_IsNumber(item))
108 {
109 return (double) NAN;
110 }
111
112 return item->valuedouble;
113 }
114
115 /* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
116 #if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 14)
117 #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
118 #endif
119
cJSON_Version(void)120 CJSON_PUBLIC(const char*) cJSON_Version(void)
121 {
122 static char version[15];
123 sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
124
125 return version;
126 }
127
128 /* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
case_insensitive_strcmp(const unsigned char * string1,const unsigned char * string2)129 static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
130 {
131 if ((string1 == NULL) || (string2 == NULL))
132 {
133 return 1;
134 }
135
136 if (string1 == string2)
137 {
138 return 0;
139 }
140
141 for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
142 {
143 if (*string1 == '\0')
144 {
145 return 0;
146 }
147 }
148
149 return tolower(*string1) - tolower(*string2);
150 }
151
152 typedef struct internal_hooks
153 {
154 void *(CJSON_CDECL *allocate)(size_t size);
155 void (CJSON_CDECL *deallocate)(void *pointer);
156 void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);
157 } internal_hooks;
158
159 #if defined(_MSC_VER)
160 /* work around MSVC error C2322: '...' address of dllimport '...' is not static */
internal_malloc(size_t size)161 static void * CJSON_CDECL internal_malloc(size_t size)
162 {
163 return malloc(size);
164 }
internal_free(void * pointer)165 static void CJSON_CDECL internal_free(void *pointer)
166 {
167 free(pointer);
168 }
internal_realloc(void * pointer,size_t size)169 static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)
170 {
171 return realloc(pointer, size);
172 }
173 #else
174 #define internal_malloc malloc
175 #define internal_free free
176 #define internal_realloc realloc
177 #endif
178
179 /* strlen of character literals resolved at compile time */
180 #define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
181
182 static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
183
cJSON_strdup(const unsigned char * string,const internal_hooks * const hooks)184 static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
185 {
186 size_t length = 0;
187 unsigned char *copy = NULL;
188
189 if (string == NULL)
190 {
191 return NULL;
192 }
193
194 length = strlen((const char*)string) + sizeof("");
195 copy = (unsigned char*)hooks->allocate(length);
196 if (copy == NULL)
197 {
198 return NULL;
199 }
200 memcpy(copy, string, length);
201
202 return copy;
203 }
204
cJSON_InitHooks(cJSON_Hooks * hooks)205 CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
206 {
207 if (hooks == NULL)
208 {
209 /* Reset hooks */
210 global_hooks.allocate = malloc;
211 global_hooks.deallocate = free;
212 global_hooks.reallocate = realloc;
213 return;
214 }
215
216 global_hooks.allocate = malloc;
217 if (hooks->malloc_fn != NULL)
218 {
219 global_hooks.allocate = hooks->malloc_fn;
220 }
221
222 global_hooks.deallocate = free;
223 if (hooks->free_fn != NULL)
224 {
225 global_hooks.deallocate = hooks->free_fn;
226 }
227
228 /* use realloc only if both free and malloc are used */
229 global_hooks.reallocate = NULL;
230 if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
231 {
232 global_hooks.reallocate = realloc;
233 }
234 }
235
236 /* Internal constructor. */
cJSON_New_Item(const internal_hooks * const hooks)237 static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
238 {
239 cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
240 if (node)
241 {
242 memset(node, '\0', sizeof(cJSON));
243 }
244
245 return node;
246 }
247
248 /* Delete a cJSON structure. */
cJSON_Delete(cJSON * item)249 CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
250 {
251 cJSON *next = NULL;
252 while (item != NULL)
253 {
254 next = item->next;
255 if (!(item->type & cJSON_IsReference) && (item->child != NULL))
256 {
257 cJSON_Delete(item->child);
258 }
259 if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
260 {
261 global_hooks.deallocate(item->valuestring);
262 }
263 if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
264 {
265 global_hooks.deallocate(item->string);
266 }
267 global_hooks.deallocate(item);
268 item = next;
269 }
270 }
271
272 /* get the decimal point character of the current locale */
get_decimal_point(void)273 static unsigned char get_decimal_point(void)
274 {
275 #ifdef ENABLE_LOCALES
276 struct lconv *lconv = localeconv();
277 return (unsigned char) lconv->decimal_point[0];
278 #else
279 return '.';
280 #endif
281 }
282
283 typedef struct
284 {
285 const unsigned char *content;
286 size_t length;
287 size_t offset;
288 size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
289 internal_hooks hooks;
290 } parse_buffer;
291
292 /* check if the given size is left to read in a given parse buffer (starting with 1) */
293 #define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
294 /* check if the buffer can be accessed at the given index (starting with 0) */
295 #define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
296 #define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
297 /* get a pointer to the buffer at the position */
298 #define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
299
300 /* Parse the input text to generate a number, and populate the result into item. */
parse_number(cJSON * const item,parse_buffer * const input_buffer)301 static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
302 {
303 double number = 0;
304 unsigned char *after_end = NULL;
305 unsigned char number_c_string[64];
306 unsigned char decimal_point = get_decimal_point();
307 size_t i = 0;
308
309 if ((input_buffer == NULL) || (input_buffer->content == NULL))
310 {
311 return false;
312 }
313
314 /* copy the number into a temporary buffer and replace '.' with the decimal point
315 * of the current locale (for strtod)
316 * This also takes care of '\0' not necessarily being available for marking the end of the input */
317 for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
318 {
319 switch (buffer_at_offset(input_buffer)[i])
320 {
321 case '0':
322 case '1':
323 case '2':
324 case '3':
325 case '4':
326 case '5':
327 case '6':
328 case '7':
329 case '8':
330 case '9':
331 case '+':
332 case '-':
333 case 'e':
334 case 'E':
335 number_c_string[i] = buffer_at_offset(input_buffer)[i];
336 break;
337
338 case '.':
339 number_c_string[i] = decimal_point;
340 break;
341
342 default:
343 goto loop_end;
344 }
345 }
346 loop_end:
347 number_c_string[i] = '\0';
348
349 number = strtod((const char*)number_c_string, (char**)&after_end);
350 if (number_c_string == after_end)
351 {
352 return false; /* parse_error */
353 }
354
355 item->valuedouble = number;
356
357 /* use saturation in case of overflow */
358 if (number >= INT_MAX)
359 {
360 item->valueint = INT_MAX;
361 }
362 else if (number <= (double)INT_MIN)
363 {
364 item->valueint = INT_MIN;
365 }
366 else
367 {
368 item->valueint = (int)number;
369 }
370
371 item->type = cJSON_Number;
372
373 input_buffer->offset += (size_t)(after_end - number_c_string);
374 return true;
375 }
376
377 /* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
cJSON_SetNumberHelper(cJSON * object,double number)378 CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
379 {
380 if (number >= INT_MAX)
381 {
382 object->valueint = INT_MAX;
383 }
384 else if (number <= (double)INT_MIN)
385 {
386 object->valueint = INT_MIN;
387 }
388 else
389 {
390 object->valueint = (int)number;
391 }
392
393 return object->valuedouble = number;
394 }
395
cJSON_SetValuestring(cJSON * object,const char * valuestring)396 CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
397 {
398 char *copy = NULL;
399 /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
400 if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference))
401 {
402 return NULL;
403 }
404 if (strlen(valuestring) <= strlen(object->valuestring))
405 {
406 strcpy(object->valuestring, valuestring);
407 return object->valuestring;
408 }
409 copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);
410 if (copy == NULL)
411 {
412 return NULL;
413 }
414 if (object->valuestring != NULL)
415 {
416 cJSON_free(object->valuestring);
417 }
418 object->valuestring = copy;
419
420 return copy;
421 }
422
423 typedef struct
424 {
425 unsigned char *buffer;
426 size_t length;
427 size_t offset;
428 size_t depth; /* current nesting depth (for formatted printing) */
429 cJSON_bool noalloc;
430 cJSON_bool format; /* is this print a formatted print */
431 internal_hooks hooks;
432 } printbuffer;
433
434 /* realloc printbuffer if necessary to have at least "needed" bytes more */
ensure(printbuffer * const p,size_t needed)435 static unsigned char* ensure(printbuffer * const p, size_t needed)
436 {
437 unsigned char *newbuffer = NULL;
438 size_t newsize = 0;
439
440 if ((p == NULL) || (p->buffer == NULL))
441 {
442 return NULL;
443 }
444
445 if ((p->length > 0) && (p->offset >= p->length))
446 {
447 /* make sure that offset is valid */
448 return NULL;
449 }
450
451 if (needed > INT_MAX)
452 {
453 /* sizes bigger than INT_MAX are currently not supported */
454 return NULL;
455 }
456
457 needed += p->offset + 1;
458 if (needed <= p->length)
459 {
460 return p->buffer + p->offset;
461 }
462
463 if (p->noalloc) {
464 return NULL;
465 }
466
467 /* calculate new buffer size */
468 if (needed > (INT_MAX / 2))
469 {
470 /* overflow of int, use INT_MAX if possible */
471 if (needed <= INT_MAX)
472 {
473 newsize = INT_MAX;
474 }
475 else
476 {
477 return NULL;
478 }
479 }
480 else
481 {
482 newsize = needed * 2;
483 }
484
485 if (p->hooks.reallocate != NULL)
486 {
487 /* reallocate with realloc if available */
488 newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
489 if (newbuffer == NULL)
490 {
491 p->hooks.deallocate(p->buffer);
492 p->length = 0;
493 p->buffer = NULL;
494
495 return NULL;
496 }
497 }
498 else
499 {
500 /* otherwise reallocate manually */
501 newbuffer = (unsigned char*)p->hooks.allocate(newsize);
502 if (!newbuffer)
503 {
504 p->hooks.deallocate(p->buffer);
505 p->length = 0;
506 p->buffer = NULL;
507
508 return NULL;
509 }
510 if (newbuffer)
511 {
512 memcpy(newbuffer, p->buffer, p->offset + 1);
513 }
514 p->hooks.deallocate(p->buffer);
515 }
516 p->length = newsize;
517 p->buffer = newbuffer;
518
519 return newbuffer + p->offset;
520 }
521
522 /* calculate the new length of the string in a printbuffer and update the offset */
update_offset(printbuffer * const buffer)523 static void update_offset(printbuffer * const buffer)
524 {
525 const unsigned char *buffer_pointer = NULL;
526 if ((buffer == NULL) || (buffer->buffer == NULL))
527 {
528 return;
529 }
530 buffer_pointer = buffer->buffer + buffer->offset;
531
532 buffer->offset += strlen((const char*)buffer_pointer);
533 }
534
535 /* securely comparison of floating-point variables */
compare_double(double a,double b)536 static cJSON_bool compare_double(double a, double b)
537 {
538 double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
539 return (fabs(a - b) <= maxVal * DBL_EPSILON);
540 }
541
542 /* Render the number nicely from the given item into a string. */
print_number(const cJSON * const item,printbuffer * const output_buffer)543 static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
544 {
545 unsigned char *output_pointer = NULL;
546 double d = item->valuedouble;
547 int length = 0;
548 size_t i = 0;
549 unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */
550 unsigned char decimal_point = get_decimal_point();
551 double test = 0.0;
552
553 if (output_buffer == NULL)
554 {
555 return false;
556 }
557
558 /* This checks for NaN and Infinity */
559 if (isnan(d) || isinf(d))
560 {
561 length = sprintf((char*)number_buffer, "null");
562 }
563 else
564 {
565 /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
566 length = sprintf((char*)number_buffer, "%1.15g", d);
567
568 /* Check whether the original double can be recovered */
569 if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d))
570 {
571 /* If not, print with 17 decimal places of precision */
572 length = sprintf((char*)number_buffer, "%1.17g", d);
573 }
574 }
575
576 /* sprintf failed or buffer overrun occurred */
577 if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
578 {
579 return false;
580 }
581
582 /* reserve appropriate space in the output */
583 output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
584 if (output_pointer == NULL)
585 {
586 return false;
587 }
588
589 /* copy the printed number to the output and replace locale
590 * dependent decimal point with '.' */
591 for (i = 0; i < ((size_t)length); i++)
592 {
593 if (number_buffer[i] == decimal_point)
594 {
595 output_pointer[i] = '.';
596 continue;
597 }
598
599 output_pointer[i] = number_buffer[i];
600 }
601 output_pointer[i] = '\0';
602
603 output_buffer->offset += (size_t)length;
604
605 return true;
606 }
607
608 /* parse 4 digit hexadecimal number */
parse_hex4(const unsigned char * const input)609 static unsigned parse_hex4(const unsigned char * const input)
610 {
611 unsigned int h = 0;
612 size_t i = 0;
613
614 for (i = 0; i < 4; i++)
615 {
616 /* parse digit */
617 if ((input[i] >= '0') && (input[i] <= '9'))
618 {
619 h += (unsigned int) input[i] - '0';
620 }
621 else if ((input[i] >= 'A') && (input[i] <= 'F'))
622 {
623 h += (unsigned int) 10 + input[i] - 'A';
624 }
625 else if ((input[i] >= 'a') && (input[i] <= 'f'))
626 {
627 h += (unsigned int) 10 + input[i] - 'a';
628 }
629 else /* invalid */
630 {
631 return 0;
632 }
633
634 if (i < 3)
635 {
636 /* shift left to make place for the next nibble */
637 h = h << 4;
638 }
639 }
640
641 return h;
642 }
643
644 /* converts a UTF-16 literal to UTF-8
645 * A literal can be one or two sequences of the form \uXXXX */
utf16_literal_to_utf8(const unsigned char * const input_pointer,const unsigned char * const input_end,unsigned char ** output_pointer)646 static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
647 {
648 long unsigned int codepoint = 0;
649 unsigned int first_code = 0;
650 const unsigned char *first_sequence = input_pointer;
651 unsigned char utf8_length = 0;
652 unsigned char utf8_position = 0;
653 unsigned char sequence_length = 0;
654 unsigned char first_byte_mark = 0;
655
656 if ((input_end - first_sequence) < 6)
657 {
658 /* input ends unexpectedly */
659 goto fail;
660 }
661
662 /* get the first utf16 sequence */
663 first_code = parse_hex4(first_sequence + 2);
664
665 /* check that the code is valid */
666 if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
667 {
668 goto fail;
669 }
670
671 /* UTF16 surrogate pair */
672 if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
673 {
674 const unsigned char *second_sequence = first_sequence + 6;
675 unsigned int second_code = 0;
676 sequence_length = 12; /* \uXXXX\uXXXX */
677
678 if ((input_end - second_sequence) < 6)
679 {
680 /* input ends unexpectedly */
681 goto fail;
682 }
683
684 if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
685 {
686 /* missing second half of the surrogate pair */
687 goto fail;
688 }
689
690 /* get the second utf16 sequence */
691 second_code = parse_hex4(second_sequence + 2);
692 /* check that the code is valid */
693 if ((second_code < 0xDC00) || (second_code > 0xDFFF))
694 {
695 /* invalid second half of the surrogate pair */
696 goto fail;
697 }
698
699
700 /* calculate the unicode codepoint from the surrogate pair */
701 codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
702 }
703 else
704 {
705 sequence_length = 6; /* \uXXXX */
706 codepoint = first_code;
707 }
708
709 /* encode as UTF-8
710 * takes at maximum 4 bytes to encode:
711 * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
712 if (codepoint < 0x80)
713 {
714 /* normal ascii, encoding 0xxxxxxx */
715 utf8_length = 1;
716 }
717 else if (codepoint < 0x800)
718 {
719 /* two bytes, encoding 110xxxxx 10xxxxxx */
720 utf8_length = 2;
721 first_byte_mark = 0xC0; /* 11000000 */
722 }
723 else if (codepoint < 0x10000)
724 {
725 /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
726 utf8_length = 3;
727 first_byte_mark = 0xE0; /* 11100000 */
728 }
729 else if (codepoint <= 0x10FFFF)
730 {
731 /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
732 utf8_length = 4;
733 first_byte_mark = 0xF0; /* 11110000 */
734 }
735 else
736 {
737 /* invalid unicode codepoint */
738 goto fail;
739 }
740
741 /* encode as utf8 */
742 for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
743 {
744 /* 10xxxxxx */
745 (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
746 codepoint >>= 6;
747 }
748 /* encode first byte */
749 if (utf8_length > 1)
750 {
751 (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
752 }
753 else
754 {
755 (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
756 }
757
758 *output_pointer += utf8_length;
759
760 return sequence_length;
761
762 fail:
763 return 0;
764 }
765
766 /* Parse the input text into an unescaped cinput, and populate item. */
parse_string(cJSON * const item,parse_buffer * const input_buffer)767 static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
768 {
769 const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
770 const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
771 unsigned char *output_pointer = NULL;
772 unsigned char *output = NULL;
773
774 /* not a string */
775 if (buffer_at_offset(input_buffer)[0] != '\"')
776 {
777 goto fail;
778 }
779
780 {
781 /* calculate approximate size of the output (overestimate) */
782 size_t allocation_length = 0;
783 size_t skipped_bytes = 0;
784 while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
785 {
786 /* is escape sequence */
787 if (input_end[0] == '\\')
788 {
789 if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
790 {
791 /* prevent buffer overflow when last input character is a backslash */
792 goto fail;
793 }
794 skipped_bytes++;
795 input_end++;
796 }
797 input_end++;
798 }
799 if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
800 {
801 goto fail; /* string ended unexpectedly */
802 }
803
804 /* This is at most how much we need for the output */
805 allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
806 output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
807 if (output == NULL)
808 {
809 goto fail; /* allocation failure */
810 }
811 }
812
813 output_pointer = output;
814 /* loop through the string literal */
815 while (input_pointer < input_end)
816 {
817 if (*input_pointer != '\\')
818 {
819 *output_pointer++ = *input_pointer++;
820 }
821 /* escape sequence */
822 else
823 {
824 unsigned char sequence_length = 2;
825 if ((input_end - input_pointer) < 1)
826 {
827 goto fail;
828 }
829
830 switch (input_pointer[1])
831 {
832 case 'b':
833 *output_pointer++ = '\b';
834 break;
835 case 'f':
836 *output_pointer++ = '\f';
837 break;
838 case 'n':
839 *output_pointer++ = '\n';
840 break;
841 case 'r':
842 *output_pointer++ = '\r';
843 break;
844 case 't':
845 *output_pointer++ = '\t';
846 break;
847 case '\"':
848 case '\\':
849 case '/':
850 *output_pointer++ = input_pointer[1];
851 break;
852
853 /* UTF-16 literal */
854 case 'u':
855 sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
856 if (sequence_length == 0)
857 {
858 /* failed to convert UTF16-literal to UTF-8 */
859 goto fail;
860 }
861 break;
862
863 default:
864 goto fail;
865 }
866 input_pointer += sequence_length;
867 }
868 }
869
870 /* zero terminate the output */
871 *output_pointer = '\0';
872
873 item->type = cJSON_String;
874 item->valuestring = (char*)output;
875
876 input_buffer->offset = (size_t) (input_end - input_buffer->content);
877 input_buffer->offset++;
878
879 return true;
880
881 fail:
882 if (output != NULL)
883 {
884 input_buffer->hooks.deallocate(output);
885 }
886
887 if (input_pointer != NULL)
888 {
889 input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
890 }
891
892 return false;
893 }
894
895 /* Render the cstring provided to an escaped version that can be printed. */
print_string_ptr(const unsigned char * const input,printbuffer * const output_buffer)896 static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
897 {
898 const unsigned char *input_pointer = NULL;
899 unsigned char *output = NULL;
900 unsigned char *output_pointer = NULL;
901 size_t output_length = 0;
902 /* numbers of additional characters needed for escaping */
903 size_t escape_characters = 0;
904
905 if (output_buffer == NULL)
906 {
907 return false;
908 }
909
910 /* empty string */
911 if (input == NULL)
912 {
913 output = ensure(output_buffer, sizeof("\"\""));
914 if (output == NULL)
915 {
916 return false;
917 }
918 strcpy((char*)output, "\"\"");
919
920 return true;
921 }
922
923 /* set "flag" to 1 if something needs to be escaped */
924 for (input_pointer = input; *input_pointer; input_pointer++)
925 {
926 switch (*input_pointer)
927 {
928 case '\"':
929 case '\\':
930 case '\b':
931 case '\f':
932 case '\n':
933 case '\r':
934 case '\t':
935 /* one character escape sequence */
936 escape_characters++;
937 break;
938 default:
939 if (*input_pointer < 32)
940 {
941 /* UTF-16 escape sequence uXXXX */
942 escape_characters += 5;
943 }
944 break;
945 }
946 }
947 output_length = (size_t)(input_pointer - input) + escape_characters;
948
949 output = ensure(output_buffer, output_length + sizeof("\"\""));
950 if (output == NULL)
951 {
952 return false;
953 }
954
955 /* no characters have to be escaped */
956 if (escape_characters == 0)
957 {
958 output[0] = '\"';
959 memcpy(output + 1, input, output_length);
960 output[output_length + 1] = '\"';
961 output[output_length + 2] = '\0';
962
963 return true;
964 }
965
966 output[0] = '\"';
967 output_pointer = output + 1;
968 /* copy the string */
969 for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
970 {
971 if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
972 {
973 /* normal character, copy */
974 *output_pointer = *input_pointer;
975 }
976 else
977 {
978 /* character needs to be escaped */
979 *output_pointer++ = '\\';
980 switch (*input_pointer)
981 {
982 case '\\':
983 *output_pointer = '\\';
984 break;
985 case '\"':
986 *output_pointer = '\"';
987 break;
988 case '\b':
989 *output_pointer = 'b';
990 break;
991 case '\f':
992 *output_pointer = 'f';
993 break;
994 case '\n':
995 *output_pointer = 'n';
996 break;
997 case '\r':
998 *output_pointer = 'r';
999 break;
1000 case '\t':
1001 *output_pointer = 't';
1002 break;
1003 default:
1004 /* escape and print as unicode codepoint */
1005 sprintf((char*)output_pointer, "u%04x", *input_pointer);
1006 output_pointer += 4;
1007 break;
1008 }
1009 }
1010 }
1011 output[output_length + 1] = '\"';
1012 output[output_length + 2] = '\0';
1013
1014 return true;
1015 }
1016
1017 /* Invoke print_string_ptr (which is useful) on an item. */
print_string(const cJSON * const item,printbuffer * const p)1018 static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)
1019 {
1020 return print_string_ptr((unsigned char*)item->valuestring, p);
1021 }
1022
1023 /* Predeclare these prototypes. */
1024 static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);
1025 static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);
1026 static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);
1027 static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);
1028 static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);
1029 static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);
1030
1031 /* Utility to jump whitespace and cr/lf */
buffer_skip_whitespace(parse_buffer * const buffer)1032 static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
1033 {
1034 if ((buffer == NULL) || (buffer->content == NULL))
1035 {
1036 return NULL;
1037 }
1038
1039 if (cannot_access_at_index(buffer, 0))
1040 {
1041 return buffer;
1042 }
1043
1044 while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
1045 {
1046 buffer->offset++;
1047 }
1048
1049 if (buffer->offset == buffer->length)
1050 {
1051 buffer->offset--;
1052 }
1053
1054 return buffer;
1055 }
1056
1057 /* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
skip_utf8_bom(parse_buffer * const buffer)1058 static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
1059 {
1060 if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
1061 {
1062 return NULL;
1063 }
1064
1065 if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
1066 {
1067 buffer->offset += 3;
1068 }
1069
1070 return buffer;
1071 }
1072
cJSON_ParseWithOpts(const char * value,const char ** return_parse_end,cJSON_bool require_null_terminated)1073 CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
1074 {
1075 size_t buffer_length;
1076
1077 if (NULL == value)
1078 {
1079 return NULL;
1080 }
1081
1082 /* Adding null character size due to require_null_terminated. */
1083 buffer_length = strlen(value) + sizeof("");
1084
1085 return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
1086 }
1087
1088 /* Parse an object - create a new root, and populate. */
cJSON_ParseWithLengthOpts(const char * value,size_t buffer_length,const char ** return_parse_end,cJSON_bool require_null_terminated)1089 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)
1090 {
1091 parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
1092 cJSON *item = NULL;
1093
1094 /* reset error position */
1095 global_error.json = NULL;
1096 global_error.position = 0;
1097
1098 if (value == NULL || 0 == buffer_length)
1099 {
1100 goto fail;
1101 }
1102
1103 buffer.content = (const unsigned char*)value;
1104 buffer.length = buffer_length;
1105 buffer.offset = 0;
1106 buffer.hooks = global_hooks;
1107
1108 item = cJSON_New_Item(&global_hooks);
1109 if (item == NULL) /* memory fail */
1110 {
1111 goto fail;
1112 }
1113
1114 if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
1115 {
1116 /* parse failure. ep is set. */
1117 goto fail;
1118 }
1119
1120 /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
1121 if (require_null_terminated)
1122 {
1123 buffer_skip_whitespace(&buffer);
1124 if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
1125 {
1126 goto fail;
1127 }
1128 }
1129 if (return_parse_end)
1130 {
1131 *return_parse_end = (const char*)buffer_at_offset(&buffer);
1132 }
1133
1134 return item;
1135
1136 fail:
1137 if (item != NULL)
1138 {
1139 cJSON_Delete(item);
1140 }
1141
1142 if (value != NULL)
1143 {
1144 error local_error;
1145 local_error.json = (const unsigned char*)value;
1146 local_error.position = 0;
1147
1148 if (buffer.offset < buffer.length)
1149 {
1150 local_error.position = buffer.offset;
1151 }
1152 else if (buffer.length > 0)
1153 {
1154 local_error.position = buffer.length - 1;
1155 }
1156
1157 if (return_parse_end != NULL)
1158 {
1159 *return_parse_end = (const char*)local_error.json + local_error.position;
1160 }
1161
1162 global_error = local_error;
1163 }
1164
1165 return NULL;
1166 }
1167
1168 /* Default options for cJSON_Parse */
cJSON_Parse(const char * value)1169 CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
1170 {
1171 return cJSON_ParseWithOpts(value, 0, 0);
1172 }
1173
cJSON_ParseWithLength(const char * value,size_t buffer_length)1174 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length)
1175 {
1176 return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0);
1177 }
1178
1179 #define cjson_min(a, b) (((a) < (b)) ? (a) : (b))
1180
print(const cJSON * const item,cJSON_bool format,const internal_hooks * const hooks)1181 static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
1182 {
1183 static const size_t default_buffer_size = 256;
1184 printbuffer buffer[1];
1185 unsigned char *printed = NULL;
1186
1187 memset(buffer, 0, sizeof(buffer));
1188
1189 /* create buffer */
1190 buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
1191 buffer->length = default_buffer_size;
1192 buffer->format = format;
1193 buffer->hooks = *hooks;
1194 if (buffer->buffer == NULL)
1195 {
1196 goto fail;
1197 }
1198
1199 /* print the value */
1200 if (!print_value(item, buffer))
1201 {
1202 goto fail;
1203 }
1204 update_offset(buffer);
1205
1206 /* check if reallocate is available */
1207 if (hooks->reallocate != NULL)
1208 {
1209 printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
1210 if (printed == NULL) {
1211 goto fail;
1212 }
1213 buffer->buffer = NULL;
1214 }
1215 else /* otherwise copy the JSON over to a new buffer */
1216 {
1217 printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
1218 if (printed == NULL)
1219 {
1220 goto fail;
1221 }
1222 memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
1223 printed[buffer->offset] = '\0'; /* just to be sure */
1224
1225 /* free the buffer */
1226 hooks->deallocate(buffer->buffer);
1227 }
1228
1229 return printed;
1230
1231 fail:
1232 if (buffer->buffer != NULL)
1233 {
1234 hooks->deallocate(buffer->buffer);
1235 }
1236
1237 if (printed != NULL)
1238 {
1239 hooks->deallocate(printed);
1240 }
1241
1242 return NULL;
1243 }
1244
1245 /* Render a cJSON item/entity/structure to text. */
cJSON_Print(const cJSON * item)1246 CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)
1247 {
1248 return (char*)print(item, true, &global_hooks);
1249 }
1250
cJSON_PrintUnformatted(const cJSON * item)1251 CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)
1252 {
1253 return (char*)print(item, false, &global_hooks);
1254 }
1255
cJSON_PrintBuffered(const cJSON * item,int prebuffer,cJSON_bool fmt)1256 CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
1257 {
1258 printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
1259
1260 if (prebuffer < 0)
1261 {
1262 return NULL;
1263 }
1264
1265 p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
1266 if (!p.buffer)
1267 {
1268 return NULL;
1269 }
1270
1271 p.length = (size_t)prebuffer;
1272 p.offset = 0;
1273 p.noalloc = false;
1274 p.format = fmt;
1275 p.hooks = global_hooks;
1276
1277 if (!print_value(item, &p))
1278 {
1279 global_hooks.deallocate(p.buffer);
1280 return NULL;
1281 }
1282
1283 return (char*)p.buffer;
1284 }
1285
cJSON_PrintPreallocated(cJSON * item,char * buffer,const int length,const cJSON_bool format)1286 CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)
1287 {
1288 printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
1289
1290 if ((length < 0) || (buffer == NULL))
1291 {
1292 return false;
1293 }
1294
1295 p.buffer = (unsigned char*)buffer;
1296 p.length = (size_t)length;
1297 p.offset = 0;
1298 p.noalloc = true;
1299 p.format = format;
1300 p.hooks = global_hooks;
1301
1302 return print_value(item, &p);
1303 }
1304
1305 /* Parser core - when encountering text, process appropriately. */
parse_value(cJSON * const item,parse_buffer * const input_buffer)1306 static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
1307 {
1308 if ((input_buffer == NULL) || (input_buffer->content == NULL))
1309 {
1310 return false; /* no input */
1311 }
1312
1313 /* parse the different types of values */
1314 /* null */
1315 if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
1316 {
1317 item->type = cJSON_NULL;
1318 input_buffer->offset += 4;
1319 return true;
1320 }
1321 /* false */
1322 if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
1323 {
1324 item->type = cJSON_False;
1325 input_buffer->offset += 5;
1326 return true;
1327 }
1328 /* true */
1329 if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
1330 {
1331 item->type = cJSON_True;
1332 item->valueint = 1;
1333 input_buffer->offset += 4;
1334 return true;
1335 }
1336 /* string */
1337 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
1338 {
1339 return parse_string(item, input_buffer);
1340 }
1341 /* number */
1342 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'))))
1343 {
1344 return parse_number(item, input_buffer);
1345 }
1346 /* array */
1347 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
1348 {
1349 return parse_array(item, input_buffer);
1350 }
1351 /* object */
1352 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
1353 {
1354 return parse_object(item, input_buffer);
1355 }
1356
1357 return false;
1358 }
1359
1360 /* Render a value to text. */
print_value(const cJSON * const item,printbuffer * const output_buffer)1361 static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)
1362 {
1363 unsigned char *output = NULL;
1364
1365 if ((item == NULL) || (output_buffer == NULL))
1366 {
1367 return false;
1368 }
1369
1370 switch ((item->type) & 0xFF)
1371 {
1372 case cJSON_NULL:
1373 output = ensure(output_buffer, 5);
1374 if (output == NULL)
1375 {
1376 return false;
1377 }
1378 strcpy((char*)output, "null");
1379 return true;
1380
1381 case cJSON_False:
1382 output = ensure(output_buffer, 6);
1383 if (output == NULL)
1384 {
1385 return false;
1386 }
1387 strcpy((char*)output, "false");
1388 return true;
1389
1390 case cJSON_True:
1391 output = ensure(output_buffer, 5);
1392 if (output == NULL)
1393 {
1394 return false;
1395 }
1396 strcpy((char*)output, "true");
1397 return true;
1398
1399 case cJSON_Number:
1400 return print_number(item, output_buffer);
1401
1402 case cJSON_Raw:
1403 {
1404 size_t raw_length = 0;
1405 if (item->valuestring == NULL)
1406 {
1407 return false;
1408 }
1409
1410 raw_length = strlen(item->valuestring) + sizeof("");
1411 output = ensure(output_buffer, raw_length);
1412 if (output == NULL)
1413 {
1414 return false;
1415 }
1416 memcpy(output, item->valuestring, raw_length);
1417 return true;
1418 }
1419
1420 case cJSON_String:
1421 return print_string(item, output_buffer);
1422
1423 case cJSON_Array:
1424 return print_array(item, output_buffer);
1425
1426 case cJSON_Object:
1427 return print_object(item, output_buffer);
1428
1429 default:
1430 return false;
1431 }
1432 }
1433
1434 /* Build an array from input text. */
parse_array(cJSON * const item,parse_buffer * const input_buffer)1435 static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
1436 {
1437 cJSON *head = NULL; /* head of the linked list */
1438 cJSON *current_item = NULL;
1439
1440 if (input_buffer->depth >= CJSON_NESTING_LIMIT)
1441 {
1442 return false; /* to deeply nested */
1443 }
1444 input_buffer->depth++;
1445
1446 if (buffer_at_offset(input_buffer)[0] != '[')
1447 {
1448 /* not an array */
1449 goto fail;
1450 }
1451
1452 input_buffer->offset++;
1453 buffer_skip_whitespace(input_buffer);
1454 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
1455 {
1456 /* empty array */
1457 goto success;
1458 }
1459
1460 /* check if we skipped to the end of the buffer */
1461 if (cannot_access_at_index(input_buffer, 0))
1462 {
1463 input_buffer->offset--;
1464 goto fail;
1465 }
1466
1467 /* step back to character in front of the first element */
1468 input_buffer->offset--;
1469 /* loop through the comma separated array elements */
1470 do
1471 {
1472 /* allocate next item */
1473 cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
1474 if (new_item == NULL)
1475 {
1476 goto fail; /* allocation failure */
1477 }
1478
1479 /* attach next item to list */
1480 if (head == NULL)
1481 {
1482 /* start the linked list */
1483 current_item = head = new_item;
1484 }
1485 else
1486 {
1487 /* add to the end and advance */
1488 current_item->next = new_item;
1489 new_item->prev = current_item;
1490 current_item = new_item;
1491 }
1492
1493 /* parse next value */
1494 input_buffer->offset++;
1495 buffer_skip_whitespace(input_buffer);
1496 if (!parse_value(current_item, input_buffer))
1497 {
1498 goto fail; /* failed to parse value */
1499 }
1500 buffer_skip_whitespace(input_buffer);
1501 }
1502 while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
1503
1504 if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
1505 {
1506 goto fail; /* expected end of array */
1507 }
1508
1509 success:
1510 input_buffer->depth--;
1511
1512 if (head != NULL) {
1513 head->prev = current_item;
1514 }
1515
1516 item->type = cJSON_Array;
1517 item->child = head;
1518
1519 input_buffer->offset++;
1520
1521 return true;
1522
1523 fail:
1524 if (head != NULL)
1525 {
1526 cJSON_Delete(head);
1527 }
1528
1529 return false;
1530 }
1531
1532 /* Render an array to text */
print_array(const cJSON * const item,printbuffer * const output_buffer)1533 static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
1534 {
1535 unsigned char *output_pointer = NULL;
1536 size_t length = 0;
1537 cJSON *current_element = item->child;
1538
1539 if (output_buffer == NULL)
1540 {
1541 return false;
1542 }
1543
1544 /* Compose the output array. */
1545 /* opening square bracket */
1546 output_pointer = ensure(output_buffer, 1);
1547 if (output_pointer == NULL)
1548 {
1549 return false;
1550 }
1551
1552 *output_pointer = '[';
1553 output_buffer->offset++;
1554 output_buffer->depth++;
1555
1556 while (current_element != NULL)
1557 {
1558 if (!print_value(current_element, output_buffer))
1559 {
1560 return false;
1561 }
1562 update_offset(output_buffer);
1563 if (current_element->next)
1564 {
1565 length = (size_t) (output_buffer->format ? 2 : 1);
1566 output_pointer = ensure(output_buffer, length + 1);
1567 if (output_pointer == NULL)
1568 {
1569 return false;
1570 }
1571 *output_pointer++ = ',';
1572 if(output_buffer->format)
1573 {
1574 *output_pointer++ = ' ';
1575 }
1576 *output_pointer = '\0';
1577 output_buffer->offset += length;
1578 }
1579 current_element = current_element->next;
1580 }
1581
1582 output_pointer = ensure(output_buffer, 2);
1583 if (output_pointer == NULL)
1584 {
1585 return false;
1586 }
1587 *output_pointer++ = ']';
1588 *output_pointer = '\0';
1589 output_buffer->depth--;
1590
1591 return true;
1592 }
1593
1594 /* Build an object from the text. */
parse_object(cJSON * const item,parse_buffer * const input_buffer)1595 static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
1596 {
1597 cJSON *head = NULL; /* linked list head */
1598 cJSON *current_item = NULL;
1599
1600 if (input_buffer->depth >= CJSON_NESTING_LIMIT)
1601 {
1602 return false; /* to deeply nested */
1603 }
1604 input_buffer->depth++;
1605
1606 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
1607 {
1608 goto fail; /* not an object */
1609 }
1610
1611 input_buffer->offset++;
1612 buffer_skip_whitespace(input_buffer);
1613 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
1614 {
1615 goto success; /* empty object */
1616 }
1617
1618 /* check if we skipped to the end of the buffer */
1619 if (cannot_access_at_index(input_buffer, 0))
1620 {
1621 input_buffer->offset--;
1622 goto fail;
1623 }
1624
1625 /* step back to character in front of the first element */
1626 input_buffer->offset--;
1627 /* loop through the comma separated array elements */
1628 do
1629 {
1630 /* allocate next item */
1631 cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
1632 if (new_item == NULL)
1633 {
1634 goto fail; /* allocation failure */
1635 }
1636
1637 /* attach next item to list */
1638 if (head == NULL)
1639 {
1640 /* start the linked list */
1641 current_item = head = new_item;
1642 }
1643 else
1644 {
1645 /* add to the end and advance */
1646 current_item->next = new_item;
1647 new_item->prev = current_item;
1648 current_item = new_item;
1649 }
1650
1651 /* parse the name of the child */
1652 input_buffer->offset++;
1653 buffer_skip_whitespace(input_buffer);
1654 if (!parse_string(current_item, input_buffer))
1655 {
1656 goto fail; /* failed to parse name */
1657 }
1658 buffer_skip_whitespace(input_buffer);
1659
1660 /* swap valuestring and string, because we parsed the name */
1661 current_item->string = current_item->valuestring;
1662 current_item->valuestring = NULL;
1663
1664 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
1665 {
1666 goto fail; /* invalid object */
1667 }
1668
1669 /* parse the value */
1670 input_buffer->offset++;
1671 buffer_skip_whitespace(input_buffer);
1672 if (!parse_value(current_item, input_buffer))
1673 {
1674 goto fail; /* failed to parse value */
1675 }
1676 buffer_skip_whitespace(input_buffer);
1677 }
1678 while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
1679
1680 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
1681 {
1682 goto fail; /* expected end of object */
1683 }
1684
1685 success:
1686 input_buffer->depth--;
1687
1688 if (head != NULL) {
1689 head->prev = current_item;
1690 }
1691
1692 item->type = cJSON_Object;
1693 item->child = head;
1694
1695 input_buffer->offset++;
1696 return true;
1697
1698 fail:
1699 if (head != NULL)
1700 {
1701 cJSON_Delete(head);
1702 }
1703
1704 return false;
1705 }
1706
1707 /* Render an object to text. */
print_object(const cJSON * const item,printbuffer * const output_buffer)1708 static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)
1709 {
1710 unsigned char *output_pointer = NULL;
1711 size_t length = 0;
1712 cJSON *current_item = item->child;
1713
1714 if (output_buffer == NULL)
1715 {
1716 return false;
1717 }
1718
1719 /* Compose the output: */
1720 length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
1721 output_pointer = ensure(output_buffer, length + 1);
1722 if (output_pointer == NULL)
1723 {
1724 return false;
1725 }
1726
1727 *output_pointer++ = '{';
1728 output_buffer->depth++;
1729 if (output_buffer->format)
1730 {
1731 *output_pointer++ = '\n';
1732 }
1733 output_buffer->offset += length;
1734
1735 while (current_item)
1736 {
1737 if (output_buffer->format)
1738 {
1739 size_t i;
1740 output_pointer = ensure(output_buffer, output_buffer->depth);
1741 if (output_pointer == NULL)
1742 {
1743 return false;
1744 }
1745 for (i = 0; i < output_buffer->depth; i++)
1746 {
1747 *output_pointer++ = '\t';
1748 }
1749 output_buffer->offset += output_buffer->depth;
1750 }
1751
1752 /* print key */
1753 if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
1754 {
1755 return false;
1756 }
1757 update_offset(output_buffer);
1758
1759 length = (size_t) (output_buffer->format ? 2 : 1);
1760 output_pointer = ensure(output_buffer, length);
1761 if (output_pointer == NULL)
1762 {
1763 return false;
1764 }
1765 *output_pointer++ = ':';
1766 if (output_buffer->format)
1767 {
1768 *output_pointer++ = '\t';
1769 }
1770 output_buffer->offset += length;
1771
1772 /* print value */
1773 if (!print_value(current_item, output_buffer))
1774 {
1775 return false;
1776 }
1777 update_offset(output_buffer);
1778
1779 /* print comma if not last */
1780 length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
1781 output_pointer = ensure(output_buffer, length + 1);
1782 if (output_pointer == NULL)
1783 {
1784 return false;
1785 }
1786 if (current_item->next)
1787 {
1788 *output_pointer++ = ',';
1789 }
1790
1791 if (output_buffer->format)
1792 {
1793 *output_pointer++ = '\n';
1794 }
1795 *output_pointer = '\0';
1796 output_buffer->offset += length;
1797
1798 current_item = current_item->next;
1799 }
1800
1801 output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
1802 if (output_pointer == NULL)
1803 {
1804 return false;
1805 }
1806 if (output_buffer->format)
1807 {
1808 size_t i;
1809 for (i = 0; i < (output_buffer->depth - 1); i++)
1810 {
1811 *output_pointer++ = '\t';
1812 }
1813 }
1814 *output_pointer++ = '}';
1815 *output_pointer = '\0';
1816 output_buffer->depth--;
1817
1818 return true;
1819 }
1820
1821 /* Get Array size/item / object item. */
cJSON_GetArraySize(const cJSON * array)1822 CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
1823 {
1824 cJSON *child = NULL;
1825 size_t size = 0;
1826
1827 if (array == NULL)
1828 {
1829 return 0;
1830 }
1831
1832 child = array->child;
1833
1834 while(child != NULL)
1835 {
1836 size++;
1837 child = child->next;
1838 }
1839
1840 /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
1841
1842 return (int)size;
1843 }
1844
get_array_item(const cJSON * array,size_t index)1845 static cJSON* get_array_item(const cJSON *array, size_t index)
1846 {
1847 cJSON *current_child = NULL;
1848
1849 if (array == NULL)
1850 {
1851 return NULL;
1852 }
1853
1854 current_child = array->child;
1855 while ((current_child != NULL) && (index > 0))
1856 {
1857 index--;
1858 current_child = current_child->next;
1859 }
1860
1861 return current_child;
1862 }
1863
cJSON_GetArrayItem(const cJSON * array,int index)1864 CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
1865 {
1866 if (index < 0)
1867 {
1868 return NULL;
1869 }
1870
1871 return get_array_item(array, (size_t)index);
1872 }
1873
get_object_item(const cJSON * const object,const char * const name,const cJSON_bool case_sensitive)1874 static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
1875 {
1876 cJSON *current_element = NULL;
1877
1878 if ((object == NULL) || (name == NULL))
1879 {
1880 return NULL;
1881 }
1882
1883 current_element = object->child;
1884 if (case_sensitive)
1885 {
1886 while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
1887 {
1888 current_element = current_element->next;
1889 }
1890 }
1891 else
1892 {
1893 while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
1894 {
1895 current_element = current_element->next;
1896 }
1897 }
1898
1899 if ((current_element == NULL) || (current_element->string == NULL)) {
1900 return NULL;
1901 }
1902
1903 return current_element;
1904 }
1905
cJSON_GetObjectItem(const cJSON * const object,const char * const string)1906 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)
1907 {
1908 return get_object_item(object, string, false);
1909 }
1910
cJSON_GetObjectItemCaseSensitive(const cJSON * const object,const char * const string)1911 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)
1912 {
1913 return get_object_item(object, string, true);
1914 }
1915
cJSON_HasObjectItem(const cJSON * object,const char * string)1916 CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)
1917 {
1918 return cJSON_GetObjectItem(object, string) ? 1 : 0;
1919 }
1920
1921 /* Utility for array list handling. */
suffix_object(cJSON * prev,cJSON * item)1922 static void suffix_object(cJSON *prev, cJSON *item)
1923 {
1924 prev->next = item;
1925 item->prev = prev;
1926 }
1927
1928 /* Utility for handling references. */
create_reference(const cJSON * item,const internal_hooks * const hooks)1929 static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
1930 {
1931 cJSON *reference = NULL;
1932 if (item == NULL)
1933 {
1934 return NULL;
1935 }
1936
1937 reference = cJSON_New_Item(hooks);
1938 if (reference == NULL)
1939 {
1940 return NULL;
1941 }
1942
1943 memcpy(reference, item, sizeof(cJSON));
1944 reference->string = NULL;
1945 reference->type |= cJSON_IsReference;
1946 reference->next = reference->prev = NULL;
1947 return reference;
1948 }
1949
add_item_to_array(cJSON * array,cJSON * item)1950 static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
1951 {
1952 cJSON *child = NULL;
1953
1954 if ((item == NULL) || (array == NULL) || (array == item))
1955 {
1956 return false;
1957 }
1958
1959 child = array->child;
1960 /*
1961 * To find the last item in array quickly, we use prev in array
1962 */
1963 if (child == NULL)
1964 {
1965 /* list is empty, start new one */
1966 array->child = item;
1967 item->prev = item;
1968 item->next = NULL;
1969 }
1970 else
1971 {
1972 /* append to the end */
1973 if (child->prev)
1974 {
1975 suffix_object(child->prev, item);
1976 array->child->prev = item;
1977 }
1978 }
1979
1980 return true;
1981 }
1982
1983 /* Add item to array/object. */
cJSON_AddItemToArray(cJSON * array,cJSON * item)1984 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item)
1985 {
1986 return add_item_to_array(array, item);
1987 }
1988
1989 #if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
1990 #pragma GCC diagnostic push
1991 #endif
1992 #ifdef __GNUC__
1993 #pragma GCC diagnostic ignored "-Wcast-qual"
1994 #endif
1995 /* helper function to cast away const */
cast_away_const(const void * string)1996 static void* cast_away_const(const void* string)
1997 {
1998 return (void*)string;
1999 }
2000 #if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
2001 #pragma GCC diagnostic pop
2002 #endif
2003
2004
add_item_to_object(cJSON * const object,const char * const string,cJSON * const item,const internal_hooks * const hooks,const cJSON_bool constant_key)2005 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)
2006 {
2007 char *new_key = NULL;
2008 int new_type = cJSON_Invalid;
2009
2010 if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item))
2011 {
2012 return false;
2013 }
2014
2015 if (constant_key)
2016 {
2017 new_key = (char*)cast_away_const(string);
2018 new_type = item->type | cJSON_StringIsConst;
2019 }
2020 else
2021 {
2022 new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
2023 if (new_key == NULL)
2024 {
2025 return false;
2026 }
2027
2028 new_type = item->type & ~cJSON_StringIsConst;
2029 }
2030
2031 if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
2032 {
2033 hooks->deallocate(item->string);
2034 }
2035
2036 item->string = new_key;
2037 item->type = new_type;
2038
2039 return add_item_to_array(object, item);
2040 }
2041
cJSON_AddItemToObject(cJSON * object,const char * string,cJSON * item)2042 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
2043 {
2044 return add_item_to_object(object, string, item, &global_hooks, false);
2045 }
2046
2047 /* Add an item to an object with constant string as key */
cJSON_AddItemToObjectCS(cJSON * object,const char * string,cJSON * item)2048 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
2049 {
2050 return add_item_to_object(object, string, item, &global_hooks, true);
2051 }
2052
cJSON_AddItemReferenceToArray(cJSON * array,cJSON * item)2053 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
2054 {
2055 if (array == NULL)
2056 {
2057 return false;
2058 }
2059
2060 return add_item_to_array(array, create_reference(item, &global_hooks));
2061 }
2062
cJSON_AddItemReferenceToObject(cJSON * object,const char * string,cJSON * item)2063 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
2064 {
2065 if ((object == NULL) || (string == NULL))
2066 {
2067 return false;
2068 }
2069
2070 return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
2071 }
2072
cJSON_AddNullToObject(cJSON * const object,const char * const name)2073 CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
2074 {
2075 cJSON *null = cJSON_CreateNull();
2076 if (add_item_to_object(object, name, null, &global_hooks, false))
2077 {
2078 return null;
2079 }
2080
2081 cJSON_Delete(null);
2082 return NULL;
2083 }
2084
cJSON_AddTrueToObject(cJSON * const object,const char * const name)2085 CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
2086 {
2087 cJSON *true_item = cJSON_CreateTrue();
2088 if (add_item_to_object(object, name, true_item, &global_hooks, false))
2089 {
2090 return true_item;
2091 }
2092
2093 cJSON_Delete(true_item);
2094 return NULL;
2095 }
2096
cJSON_AddFalseToObject(cJSON * const object,const char * const name)2097 CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
2098 {
2099 cJSON *false_item = cJSON_CreateFalse();
2100 if (add_item_to_object(object, name, false_item, &global_hooks, false))
2101 {
2102 return false_item;
2103 }
2104
2105 cJSON_Delete(false_item);
2106 return NULL;
2107 }
2108
cJSON_AddBoolToObject(cJSON * const object,const char * const name,const cJSON_bool boolean)2109 CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
2110 {
2111 cJSON *bool_item = cJSON_CreateBool(boolean);
2112 if (add_item_to_object(object, name, bool_item, &global_hooks, false))
2113 {
2114 return bool_item;
2115 }
2116
2117 cJSON_Delete(bool_item);
2118 return NULL;
2119 }
2120
cJSON_AddNumberToObject(cJSON * const object,const char * const name,const double number)2121 CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
2122 {
2123 cJSON *number_item = cJSON_CreateNumber(number);
2124 if (add_item_to_object(object, name, number_item, &global_hooks, false))
2125 {
2126 return number_item;
2127 }
2128
2129 cJSON_Delete(number_item);
2130 return NULL;
2131 }
2132
cJSON_AddStringToObject(cJSON * const object,const char * const name,const char * const string)2133 CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
2134 {
2135 cJSON *string_item = cJSON_CreateString(string);
2136 if (add_item_to_object(object, name, string_item, &global_hooks, false))
2137 {
2138 return string_item;
2139 }
2140
2141 cJSON_Delete(string_item);
2142 return NULL;
2143 }
2144
cJSON_AddRawToObject(cJSON * const object,const char * const name,const char * const raw)2145 CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
2146 {
2147 cJSON *raw_item = cJSON_CreateRaw(raw);
2148 if (add_item_to_object(object, name, raw_item, &global_hooks, false))
2149 {
2150 return raw_item;
2151 }
2152
2153 cJSON_Delete(raw_item);
2154 return NULL;
2155 }
2156
cJSON_AddObjectToObject(cJSON * const object,const char * const name)2157 CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
2158 {
2159 cJSON *object_item = cJSON_CreateObject();
2160 if (add_item_to_object(object, name, object_item, &global_hooks, false))
2161 {
2162 return object_item;
2163 }
2164
2165 cJSON_Delete(object_item);
2166 return NULL;
2167 }
2168
cJSON_AddArrayToObject(cJSON * const object,const char * const name)2169 CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
2170 {
2171 cJSON *array = cJSON_CreateArray();
2172 if (add_item_to_object(object, name, array, &global_hooks, false))
2173 {
2174 return array;
2175 }
2176
2177 cJSON_Delete(array);
2178 return NULL;
2179 }
2180
cJSON_DetachItemViaPointer(cJSON * parent,cJSON * const item)2181 CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
2182 {
2183 if ((parent == NULL) || (item == NULL))
2184 {
2185 return NULL;
2186 }
2187
2188 if (item != parent->child)
2189 {
2190 /* not the first element */
2191 item->prev->next = item->next;
2192 }
2193 if (item->next != NULL)
2194 {
2195 /* not the last element */
2196 item->next->prev = item->prev;
2197 }
2198
2199 if (item == parent->child)
2200 {
2201 /* first element */
2202 parent->child = item->next;
2203 }
2204 else if (item->next == NULL)
2205 {
2206 /* last element */
2207 parent->child->prev = item->prev;
2208 }
2209
2210 /* make sure the detached item doesn't point anywhere anymore */
2211 item->prev = NULL;
2212 item->next = NULL;
2213
2214 return item;
2215 }
2216
cJSON_DetachItemFromArray(cJSON * array,int which)2217 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)
2218 {
2219 if (which < 0)
2220 {
2221 return NULL;
2222 }
2223
2224 return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
2225 }
2226
cJSON_DeleteItemFromArray(cJSON * array,int which)2227 CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)
2228 {
2229 cJSON_Delete(cJSON_DetachItemFromArray(array, which));
2230 }
2231
cJSON_DetachItemFromObject(cJSON * object,const char * string)2232 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
2233 {
2234 cJSON *to_detach = cJSON_GetObjectItem(object, string);
2235
2236 return cJSON_DetachItemViaPointer(object, to_detach);
2237 }
2238
cJSON_DetachItemFromObjectCaseSensitive(cJSON * object,const char * string)2239 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
2240 {
2241 cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
2242
2243 return cJSON_DetachItemViaPointer(object, to_detach);
2244 }
2245
cJSON_DeleteItemFromObject(cJSON * object,const char * string)2246 CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)
2247 {
2248 cJSON_Delete(cJSON_DetachItemFromObject(object, string));
2249 }
2250
cJSON_DeleteItemFromObjectCaseSensitive(cJSON * object,const char * string)2251 CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)
2252 {
2253 cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
2254 }
2255
2256 /* Replace array/object items with new ones. */
cJSON_InsertItemInArray(cJSON * array,int which,cJSON * newitem)2257 CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
2258 {
2259 cJSON *after_inserted = NULL;
2260
2261 if (which < 0)
2262 {
2263 return false;
2264 }
2265
2266 after_inserted = get_array_item(array, (size_t)which);
2267 if (after_inserted == NULL)
2268 {
2269 return add_item_to_array(array, newitem);
2270 }
2271
2272 newitem->next = after_inserted;
2273 newitem->prev = after_inserted->prev;
2274 after_inserted->prev = newitem;
2275 if (after_inserted == array->child)
2276 {
2277 array->child = newitem;
2278 }
2279 else
2280 {
2281 newitem->prev->next = newitem;
2282 }
2283 return true;
2284 }
2285
cJSON_ReplaceItemViaPointer(cJSON * const parent,cJSON * const item,cJSON * replacement)2286 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
2287 {
2288 if ((parent == NULL) || (replacement == NULL) || (item == NULL))
2289 {
2290 return false;
2291 }
2292
2293 if (replacement == item)
2294 {
2295 return true;
2296 }
2297
2298 replacement->next = item->next;
2299 replacement->prev = item->prev;
2300
2301 if (replacement->next != NULL)
2302 {
2303 replacement->next->prev = replacement;
2304 }
2305 if (parent->child == item)
2306 {
2307 if (parent->child->prev == parent->child)
2308 {
2309 replacement->prev = replacement;
2310 }
2311 parent->child = replacement;
2312 }
2313 else
2314 { /*
2315 * To find the last item in array quickly, we use prev in array.
2316 * We can't modify the last item's next pointer where this item was the parent's child
2317 */
2318 if (replacement->prev != NULL)
2319 {
2320 replacement->prev->next = replacement;
2321 }
2322 if (replacement->next == NULL)
2323 {
2324 parent->child->prev = replacement;
2325 }
2326 }
2327
2328 item->next = NULL;
2329 item->prev = NULL;
2330 cJSON_Delete(item);
2331
2332 return true;
2333 }
2334
cJSON_ReplaceItemInArray(cJSON * array,int which,cJSON * newitem)2335 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
2336 {
2337 if (which < 0)
2338 {
2339 return false;
2340 }
2341
2342 return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
2343 }
2344
replace_item_in_object(cJSON * object,const char * string,cJSON * replacement,cJSON_bool case_sensitive)2345 static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
2346 {
2347 if ((replacement == NULL) || (string == NULL))
2348 {
2349 return false;
2350 }
2351
2352 /* replace the name in the replacement */
2353 if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
2354 {
2355 cJSON_free(replacement->string);
2356 }
2357 replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
2358 replacement->type &= ~cJSON_StringIsConst;
2359
2360 return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
2361 }
2362
cJSON_ReplaceItemInObject(cJSON * object,const char * string,cJSON * newitem)2363 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
2364 {
2365 return replace_item_in_object(object, string, newitem, false);
2366 }
2367
cJSON_ReplaceItemInObjectCaseSensitive(cJSON * object,const char * string,cJSON * newitem)2368 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)
2369 {
2370 return replace_item_in_object(object, string, newitem, true);
2371 }
2372
2373 /* Create basic types: */
cJSON_CreateNull(void)2374 CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
2375 {
2376 cJSON *item = cJSON_New_Item(&global_hooks);
2377 if(item)
2378 {
2379 item->type = cJSON_NULL;
2380 }
2381
2382 return item;
2383 }
2384
cJSON_CreateTrue(void)2385 CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
2386 {
2387 cJSON *item = cJSON_New_Item(&global_hooks);
2388 if(item)
2389 {
2390 item->type = cJSON_True;
2391 }
2392
2393 return item;
2394 }
2395
cJSON_CreateFalse(void)2396 CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
2397 {
2398 cJSON *item = cJSON_New_Item(&global_hooks);
2399 if(item)
2400 {
2401 item->type = cJSON_False;
2402 }
2403
2404 return item;
2405 }
2406
cJSON_CreateBool(cJSON_bool boolean)2407 CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)
2408 {
2409 cJSON *item = cJSON_New_Item(&global_hooks);
2410 if(item)
2411 {
2412 item->type = boolean ? cJSON_True : cJSON_False;
2413 }
2414
2415 return item;
2416 }
2417
cJSON_CreateNumber(double num)2418 CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
2419 {
2420 cJSON *item = cJSON_New_Item(&global_hooks);
2421 if(item)
2422 {
2423 item->type = cJSON_Number;
2424 item->valuedouble = num;
2425
2426 /* use saturation in case of overflow */
2427 if (num >= INT_MAX)
2428 {
2429 item->valueint = INT_MAX;
2430 }
2431 else if (num <= (double)INT_MIN)
2432 {
2433 item->valueint = INT_MIN;
2434 }
2435 else
2436 {
2437 item->valueint = (int)num;
2438 }
2439 }
2440
2441 return item;
2442 }
2443
cJSON_CreateString(const char * string)2444 CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
2445 {
2446 cJSON *item = cJSON_New_Item(&global_hooks);
2447 if(item)
2448 {
2449 item->type = cJSON_String;
2450 item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
2451 if(!item->valuestring)
2452 {
2453 cJSON_Delete(item);
2454 return NULL;
2455 }
2456 }
2457
2458 return item;
2459 }
2460
cJSON_CreateStringReference(const char * string)2461 CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
2462 {
2463 cJSON *item = cJSON_New_Item(&global_hooks);
2464 if (item != NULL)
2465 {
2466 item->type = cJSON_String | cJSON_IsReference;
2467 item->valuestring = (char*)cast_away_const(string);
2468 }
2469
2470 return item;
2471 }
2472
cJSON_CreateObjectReference(const cJSON * child)2473 CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
2474 {
2475 cJSON *item = cJSON_New_Item(&global_hooks);
2476 if (item != NULL) {
2477 item->type = cJSON_Object | cJSON_IsReference;
2478 item->child = (cJSON*)cast_away_const(child);
2479 }
2480
2481 return item;
2482 }
2483
cJSON_CreateArrayReference(const cJSON * child)2484 CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
2485 cJSON *item = cJSON_New_Item(&global_hooks);
2486 if (item != NULL) {
2487 item->type = cJSON_Array | cJSON_IsReference;
2488 item->child = (cJSON*)cast_away_const(child);
2489 }
2490
2491 return item;
2492 }
2493
cJSON_CreateRaw(const char * raw)2494 CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
2495 {
2496 cJSON *item = cJSON_New_Item(&global_hooks);
2497 if(item)
2498 {
2499 item->type = cJSON_Raw;
2500 item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
2501 if(!item->valuestring)
2502 {
2503 cJSON_Delete(item);
2504 return NULL;
2505 }
2506 }
2507
2508 return item;
2509 }
2510
cJSON_CreateArray(void)2511 CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
2512 {
2513 cJSON *item = cJSON_New_Item(&global_hooks);
2514 if(item)
2515 {
2516 item->type=cJSON_Array;
2517 }
2518
2519 return item;
2520 }
2521
cJSON_CreateObject(void)2522 CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
2523 {
2524 cJSON *item = cJSON_New_Item(&global_hooks);
2525 if (item)
2526 {
2527 item->type = cJSON_Object;
2528 }
2529
2530 return item;
2531 }
2532
2533 /* Create Arrays: */
cJSON_CreateIntArray(const int * numbers,int count)2534 CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
2535 {
2536 size_t i = 0;
2537 cJSON *n = NULL;
2538 cJSON *p = NULL;
2539 cJSON *a = NULL;
2540
2541 if ((count < 0) || (numbers == NULL))
2542 {
2543 return NULL;
2544 }
2545
2546 a = cJSON_CreateArray();
2547 for(i = 0; a && (i < (size_t)count); i++)
2548 {
2549 n = cJSON_CreateNumber(numbers[i]);
2550 if (!n)
2551 {
2552 cJSON_Delete(a);
2553 return NULL;
2554 }
2555 if(!i)
2556 {
2557 a->child = n;
2558 }
2559 else
2560 {
2561 suffix_object(p, n);
2562 }
2563 p = n;
2564 }
2565 a->child->prev = n;
2566
2567 return a;
2568 }
2569
cJSON_CreateFloatArray(const float * numbers,int count)2570 CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
2571 {
2572 size_t i = 0;
2573 cJSON *n = NULL;
2574 cJSON *p = NULL;
2575 cJSON *a = NULL;
2576
2577 if ((count < 0) || (numbers == NULL))
2578 {
2579 return NULL;
2580 }
2581
2582 a = cJSON_CreateArray();
2583
2584 for(i = 0; a && (i < (size_t)count); i++)
2585 {
2586 n = cJSON_CreateNumber((double)numbers[i]);
2587 if(!n)
2588 {
2589 cJSON_Delete(a);
2590 return NULL;
2591 }
2592 if(!i)
2593 {
2594 a->child = n;
2595 }
2596 else
2597 {
2598 suffix_object(p, n);
2599 }
2600 p = n;
2601 }
2602 a->child->prev = n;
2603
2604 return a;
2605 }
2606
cJSON_CreateDoubleArray(const double * numbers,int count)2607 CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)
2608 {
2609 size_t i = 0;
2610 cJSON *n = NULL;
2611 cJSON *p = NULL;
2612 cJSON *a = NULL;
2613
2614 if ((count < 0) || (numbers == NULL))
2615 {
2616 return NULL;
2617 }
2618
2619 a = cJSON_CreateArray();
2620
2621 for(i = 0;a && (i < (size_t)count); i++)
2622 {
2623 n = cJSON_CreateNumber(numbers[i]);
2624 if(!n)
2625 {
2626 cJSON_Delete(a);
2627 return NULL;
2628 }
2629 if(!i)
2630 {
2631 a->child = n;
2632 }
2633 else
2634 {
2635 suffix_object(p, n);
2636 }
2637 p = n;
2638 }
2639 a->child->prev = n;
2640
2641 return a;
2642 }
2643
cJSON_CreateStringArray(const char * const * strings,int count)2644 CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)
2645 {
2646 size_t i = 0;
2647 cJSON *n = NULL;
2648 cJSON *p = NULL;
2649 cJSON *a = NULL;
2650
2651 if ((count < 0) || (strings == NULL))
2652 {
2653 return NULL;
2654 }
2655
2656 a = cJSON_CreateArray();
2657
2658 for (i = 0; a && (i < (size_t)count); i++)
2659 {
2660 n = cJSON_CreateString(strings[i]);
2661 if(!n)
2662 {
2663 cJSON_Delete(a);
2664 return NULL;
2665 }
2666 if(!i)
2667 {
2668 a->child = n;
2669 }
2670 else
2671 {
2672 suffix_object(p,n);
2673 }
2674 p = n;
2675 }
2676 a->child->prev = n;
2677
2678 return a;
2679 }
2680
2681 /* Duplication */
cJSON_Duplicate(const cJSON * item,cJSON_bool recurse)2682 CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
2683 {
2684 cJSON *newitem = NULL;
2685 cJSON *child = NULL;
2686 cJSON *next = NULL;
2687 cJSON *newchild = NULL;
2688
2689 /* Bail on bad ptr */
2690 if (!item)
2691 {
2692 goto fail;
2693 }
2694 /* Create new item */
2695 newitem = cJSON_New_Item(&global_hooks);
2696 if (!newitem)
2697 {
2698 goto fail;
2699 }
2700 /* Copy over all vars */
2701 newitem->type = item->type & (~cJSON_IsReference);
2702 newitem->valueint = item->valueint;
2703 newitem->valuedouble = item->valuedouble;
2704 if (item->valuestring)
2705 {
2706 newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks);
2707 if (!newitem->valuestring)
2708 {
2709 goto fail;
2710 }
2711 }
2712 if (item->string)
2713 {
2714 newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks);
2715 if (!newitem->string)
2716 {
2717 goto fail;
2718 }
2719 }
2720 /* If non-recursive, then we're done! */
2721 if (!recurse)
2722 {
2723 return newitem;
2724 }
2725 /* Walk the ->next chain for the child. */
2726 child = item->child;
2727 while (child != NULL)
2728 {
2729 newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
2730 if (!newchild)
2731 {
2732 goto fail;
2733 }
2734 if (next != NULL)
2735 {
2736 /* If newitem->child already set, then crosswire ->prev and ->next and move on */
2737 next->next = newchild;
2738 newchild->prev = next;
2739 next = newchild;
2740 }
2741 else
2742 {
2743 /* Set newitem->child and move to it */
2744 newitem->child = newchild;
2745 next = newchild;
2746 }
2747 child = child->next;
2748 }
2749 if (newitem && newitem->child)
2750 {
2751 newitem->child->prev = newchild;
2752 }
2753
2754 return newitem;
2755
2756 fail:
2757 if (newitem != NULL)
2758 {
2759 cJSON_Delete(newitem);
2760 }
2761
2762 return NULL;
2763 }
2764
skip_oneline_comment(char ** input)2765 static void skip_oneline_comment(char **input)
2766 {
2767 *input += static_strlen("//");
2768
2769 for (; (*input)[0] != '\0'; ++(*input))
2770 {
2771 if ((*input)[0] == '\n') {
2772 *input += static_strlen("\n");
2773 return;
2774 }
2775 }
2776 }
2777
skip_multiline_comment(char ** input)2778 static void skip_multiline_comment(char **input)
2779 {
2780 *input += static_strlen("/*");
2781
2782 for (; (*input)[0] != '\0'; ++(*input))
2783 {
2784 if (((*input)[0] == '*') && ((*input)[1] == '/'))
2785 {
2786 *input += static_strlen("*/");
2787 return;
2788 }
2789 }
2790 }
2791
minify_string(char ** input,char ** output)2792 static void minify_string(char **input, char **output) {
2793 (*output)[0] = (*input)[0];
2794 *input += static_strlen("\"");
2795 *output += static_strlen("\"");
2796
2797
2798 for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
2799 (*output)[0] = (*input)[0];
2800
2801 if ((*input)[0] == '\"') {
2802 (*output)[0] = '\"';
2803 *input += static_strlen("\"");
2804 *output += static_strlen("\"");
2805 return;
2806 } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) {
2807 (*output)[1] = (*input)[1];
2808 *input += static_strlen("\"");
2809 *output += static_strlen("\"");
2810 }
2811 }
2812 }
2813
cJSON_Minify(char * json)2814 CJSON_PUBLIC(void) cJSON_Minify(char *json)
2815 {
2816 char *into = json;
2817
2818 if (json == NULL)
2819 {
2820 return;
2821 }
2822
2823 while (json[0] != '\0')
2824 {
2825 switch (json[0])
2826 {
2827 case ' ':
2828 case '\t':
2829 case '\r':
2830 case '\n':
2831 json++;
2832 break;
2833
2834 case '/':
2835 if (json[1] == '/')
2836 {
2837 skip_oneline_comment(&json);
2838 }
2839 else if (json[1] == '*')
2840 {
2841 skip_multiline_comment(&json);
2842 } else {
2843 json++;
2844 }
2845 break;
2846
2847 case '\"':
2848 minify_string(&json, (char**)&into);
2849 break;
2850
2851 default:
2852 into[0] = json[0];
2853 json++;
2854 into++;
2855 }
2856 }
2857
2858 /* and null-terminate. */
2859 *into = '\0';
2860 }
2861
cJSON_IsInvalid(const cJSON * const item)2862 CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)
2863 {
2864 if (item == NULL)
2865 {
2866 return false;
2867 }
2868
2869 return (item->type & 0xFF) == cJSON_Invalid;
2870 }
2871
cJSON_IsFalse(const cJSON * const item)2872 CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)
2873 {
2874 if (item == NULL)
2875 {
2876 return false;
2877 }
2878
2879 return (item->type & 0xFF) == cJSON_False;
2880 }
2881
cJSON_IsTrue(const cJSON * const item)2882 CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)
2883 {
2884 if (item == NULL)
2885 {
2886 return false;
2887 }
2888
2889 return (item->type & 0xff) == cJSON_True;
2890 }
2891
2892
cJSON_IsBool(const cJSON * const item)2893 CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)
2894 {
2895 if (item == NULL)
2896 {
2897 return false;
2898 }
2899
2900 return (item->type & (cJSON_True | cJSON_False)) != 0;
2901 }
cJSON_IsNull(const cJSON * const item)2902 CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)
2903 {
2904 if (item == NULL)
2905 {
2906 return false;
2907 }
2908
2909 return (item->type & 0xFF) == cJSON_NULL;
2910 }
2911
cJSON_IsNumber(const cJSON * const item)2912 CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)
2913 {
2914 if (item == NULL)
2915 {
2916 return false;
2917 }
2918
2919 return (item->type & 0xFF) == cJSON_Number;
2920 }
2921
cJSON_IsString(const cJSON * const item)2922 CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)
2923 {
2924 if (item == NULL)
2925 {
2926 return false;
2927 }
2928
2929 return (item->type & 0xFF) == cJSON_String;
2930 }
2931
cJSON_IsArray(const cJSON * const item)2932 CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)
2933 {
2934 if (item == NULL)
2935 {
2936 return false;
2937 }
2938
2939 return (item->type & 0xFF) == cJSON_Array;
2940 }
2941
cJSON_IsObject(const cJSON * const item)2942 CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)
2943 {
2944 if (item == NULL)
2945 {
2946 return false;
2947 }
2948
2949 return (item->type & 0xFF) == cJSON_Object;
2950 }
2951
cJSON_IsRaw(const cJSON * const item)2952 CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)
2953 {
2954 if (item == NULL)
2955 {
2956 return false;
2957 }
2958
2959 return (item->type & 0xFF) == cJSON_Raw;
2960 }
2961
cJSON_Compare(const cJSON * const a,const cJSON * const b,const cJSON_bool case_sensitive)2962 CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)
2963 {
2964 if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a))
2965 {
2966 return false;
2967 }
2968
2969 /* check if type is valid */
2970 switch (a->type & 0xFF)
2971 {
2972 case cJSON_False:
2973 case cJSON_True:
2974 case cJSON_NULL:
2975 case cJSON_Number:
2976 case cJSON_String:
2977 case cJSON_Raw:
2978 case cJSON_Array:
2979 case cJSON_Object:
2980 break;
2981
2982 default:
2983 return false;
2984 }
2985
2986 /* identical objects are equal */
2987 if (a == b)
2988 {
2989 return true;
2990 }
2991
2992 switch (a->type & 0xFF)
2993 {
2994 /* in these cases and equal type is enough */
2995 case cJSON_False:
2996 case cJSON_True:
2997 case cJSON_NULL:
2998 return true;
2999
3000 case cJSON_Number:
3001 if (compare_double(a->valuedouble, b->valuedouble))
3002 {
3003 return true;
3004 }
3005 return false;
3006
3007 case cJSON_String:
3008 case cJSON_Raw:
3009 if ((a->valuestring == NULL) || (b->valuestring == NULL))
3010 {
3011 return false;
3012 }
3013 if (strcmp(a->valuestring, b->valuestring) == 0)
3014 {
3015 return true;
3016 }
3017
3018 return false;
3019
3020 case cJSON_Array:
3021 {
3022 cJSON *a_element = a->child;
3023 cJSON *b_element = b->child;
3024
3025 for (; (a_element != NULL) && (b_element != NULL);)
3026 {
3027 if (!cJSON_Compare(a_element, b_element, case_sensitive))
3028 {
3029 return false;
3030 }
3031
3032 a_element = a_element->next;
3033 b_element = b_element->next;
3034 }
3035
3036 /* one of the arrays is longer than the other */
3037 if (a_element != b_element) {
3038 return false;
3039 }
3040
3041 return true;
3042 }
3043
3044 case cJSON_Object:
3045 {
3046 cJSON *a_element = NULL;
3047 cJSON *b_element = NULL;
3048 cJSON_ArrayForEach(a_element, a)
3049 {
3050 /* TODO This has O(n^2) runtime, which is horrible! */
3051 b_element = get_object_item(b, a_element->string, case_sensitive);
3052 if (b_element == NULL)
3053 {
3054 return false;
3055 }
3056
3057 if (!cJSON_Compare(a_element, b_element, case_sensitive))
3058 {
3059 return false;
3060 }
3061 }
3062
3063 /* doing this twice, once on a and b to prevent true comparison if a subset of b
3064 * TODO: Do this the proper way, this is just a fix for now */
3065 cJSON_ArrayForEach(b_element, b)
3066 {
3067 a_element = get_object_item(a, b_element->string, case_sensitive);
3068 if (a_element == NULL)
3069 {
3070 return false;
3071 }
3072
3073 if (!cJSON_Compare(b_element, a_element, case_sensitive))
3074 {
3075 return false;
3076 }
3077 }
3078
3079 return true;
3080 }
3081
3082 default:
3083 return false;
3084 }
3085 }
3086
cJSON_malloc(size_t size)3087 CJSON_PUBLIC(void *) cJSON_malloc(size_t size)
3088 {
3089 return global_hooks.allocate(size);
3090 }
3091
cJSON_free(void * object)3092 CJSON_PUBLIC(void) cJSON_free(void *object)
3093 {
3094 global_hooks.deallocate(object);
3095 }
3096