tranfi 0.1.2 → 0.2.1

package/csrc/buffer.c

@@ -4,10 +4,13 @@
  */
 
 #include "internal.h"
+#include "cJSON.h"
 #include <stdlib.h>
 #include <string.h>
 
 #define INITIAL_CAP 4096
+#define COMPACT_AFTER_READ_POS (64 * 1024)
+#define MAX_RETAINED_EMPTY_CAP (1024 * 1024)
 
 void tf_buffer_init(tf_buffer *b) {
     b->data = NULL;
@@ -16,12 +19,11 @@ void tf_buffer_init(tf_buffer *b) {
     b->read_pos = 0;
 }
 
-static int buffer_ensure(tf_buffer *b, size_t extra) {
-    size_t needed = b->len + extra;
+static int buffer_ensure(tf_buffer *b, size_t needed) {
     if (needed <= b->cap) return TF_OK;
-    size_t new_cap = b->cap ? b->cap : INITIAL_CAP;
-    while (new_cap < needed) new_cap *= 2;
-    uint8_t *new_data = realloc(b->data, new_cap);
+    size_t new_cap = 0;
+    if (tf_size_grow_pow2(b->cap, needed, INITIAL_CAP, &new_cap) != TF_OK) return TF_ERROR;
+    uint8_t *new_data = tf_reallocarray_checked(b->data, new_cap, sizeof(uint8_t));
     if (!new_data) return TF_ERROR;
     b->data = new_data;
     b->cap = new_cap;
@@ -30,9 +32,11 @@ static int buffer_ensure(tf_buffer *b, size_t extra) {
 
 int tf_buffer_write(tf_buffer *b, const uint8_t *data, size_t len) {
     if (len == 0) return TF_OK;
-    if (buffer_ensure(b, len) != TF_OK) return TF_ERROR;
+    size_t new_len = 0;
+    if (tf_size_add(b->len, len, &new_len) != TF_OK) return TF_ERROR;
+    if (buffer_ensure(b, new_len) != TF_OK) return TF_ERROR;
     memcpy(b->data + b->len, data, len);
-    b->len += len;
+    b->len = new_len;
     return TF_OK;
 }
 
@@ -40,6 +44,67 @@ int tf_buffer_write_str(tf_buffer *b, const char *s) {
     return tf_buffer_write(b, (const uint8_t *)s, strlen(s));
 }
 
+int tf_buffer_write_line(tf_buffer *b, const char *s) {
+    int rc = tf_buffer_write_str(b, s);
+    if (rc == TF_OK) rc = tf_buffer_write(b, (const uint8_t *)"\n", 1);
+    return rc;
+}
+
+int tf_buffer_write_json_line(tf_buffer *b, const cJSON *obj) {
+    if (!b || !obj) return TF_ERROR;
+    char *printed = cJSON_PrintUnformatted(obj);
+    if (!printed) return TF_ERROR;
+    int rc = tf_buffer_write_line(b, printed);
+    free(printed);
+    return rc;
+}
+
+int tf_side_write_error(tf_side_channels *side, const char *msg) {
+    if (msg) tf_set_last_error(msg);
+    if (!side || !side->errors || !msg) return TF_OK;
+    return tf_buffer_write_line(side->errors, msg);
+}
+
+int tf_json_add_string(cJSON *obj, const char *name, const char *value) {
+    return cJSON_AddStringToObject(obj, name, value ? value : "") ? TF_OK : TF_ERROR;
+}
+
+int tf_json_add_number(cJSON *obj, const char *name, double value) {
+    return cJSON_AddNumberToObject(obj, name, value) ? TF_OK : TF_ERROR;
+}
+
+int tf_json_add_bool(cJSON *obj, const char *name, int value) {
+    return cJSON_AddBoolToObject(obj, name, value ? 1 : 0) ? TF_OK : TF_ERROR;
+}
+
+int tf_json_add_null(cJSON *obj, const char *name) {
+    return cJSON_AddNullToObject(obj, name) ? TF_OK : TF_ERROR;
+}
+
+int tf_json_add_item(cJSON *obj, const char *name, cJSON *item) {
+    if (!obj || !name || !item) {
+        cJSON_Delete(item);
+        return TF_ERROR;
+    }
+    if (!cJSON_AddItemToObject(obj, name, item)) {
+        cJSON_Delete(item);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+int tf_json_add_array_item(cJSON *arr, cJSON *item) {
+    if (!arr || !item) {
+        cJSON_Delete(item);
+        return TF_ERROR;
+    }
+    if (!cJSON_AddItemToArray(arr, item)) {
+        cJSON_Delete(item);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
 size_t tf_buffer_read(tf_buffer *b, uint8_t *out, size_t len) {
     size_t avail = b->len - b->read_pos;
     if (len > avail) len = avail;
@@ -47,10 +112,21 @@ size_t tf_buffer_read(tf_buffer *b, uint8_t *out, size_t len) {
         memcpy(out, b->data + b->read_pos, len);
         b->read_pos += len;
     }
-    /* Auto-compact when all data consumed */
+    /* Auto-compact when all data consumed. Keep a modest scratch buffer for
+     * future chunks, but release one-off large output buffers after drains. */
     if (b->read_pos == b->len) {
         b->read_pos = 0;
         b->len = 0;
+        if (b->cap > MAX_RETAINED_EMPTY_CAP) {
+            uint8_t *new_data = tf_reallocarray_checked(b->data, MAX_RETAINED_EMPTY_CAP,
+                                                        sizeof(uint8_t));
+            if (new_data) {
+                b->data = new_data;
+                b->cap = MAX_RETAINED_EMPTY_CAP;
+            }
+        }
+    } else if (b->read_pos >= COMPACT_AFTER_READ_POS && b->read_pos > b->cap / 2) {
+        tf_buffer_compact(b);
     }
     return len;
 }

package/csrc/cJSON.c

@@ -42,6 +42,7 @@
 #include <math.h>
 #include <stdlib.h>
 #include <limits.h>
+#include <stdint.h>
 #include <ctype.h>
 #include <float.h>
 
@@ -89,13 +90,40 @@ typedef struct {
     const unsigned char *json;
     size_t position;
 } error;
-static error global_error = { NULL, 0 };
+
+/* Tranfi local patch: parse errors are thread-local for concurrent embedders. */
+#if defined(_MSC_VER)
+#define CJSON_THREAD_LOCAL __declspec(thread)
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+#define CJSON_THREAD_LOCAL _Thread_local
+#elif defined(__GNUC__) || defined(__clang__)
+#define CJSON_THREAD_LOCAL __thread
+#else
+#define CJSON_THREAD_LOCAL
+#endif
+
+static CJSON_THREAD_LOCAL error global_error = { NULL, 0 };
+static CJSON_THREAD_LOCAL cJSON_bool global_parse_tracking = false;
+static CJSON_THREAD_LOCAL cJSON_bool global_parse_allocation_failed = false;
+
+static void cJSON_mark_parse_allocation_failure(void)
+{
+    if (global_parse_tracking)
+    {
+        global_parse_allocation_failed = true;
+    }
+}
 
 CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
 {
     return (const char*) (global_error.json + global_error.position);
 }
 
+CJSON_PUBLIC(cJSON_bool) cJSON_ParseHadAllocationFailure(void)
+{
+    return global_parse_allocation_failed;
+}
+
 CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)
 {
     if (!cJSON_IsString(item))
@@ -117,7 +145,7 @@ CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)
 }
 
 /* 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)
+#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 19)
     #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
 #endif
 
@@ -199,6 +227,7 @@ static unsigned char* cJSON_strdup(const unsigned char* string, const internal_h
     copy = (unsigned char*)hooks->allocate(length);
     if (copy == NULL)
     {
+        cJSON_mark_parse_allocation_failure();
         return NULL;
     }
     memcpy(copy, string, length);
@@ -245,6 +274,10 @@ static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
     {
         memset(node, '\0', sizeof(cJSON));
     }
+    else
+    {
+        cJSON_mark_parse_allocation_failure();
+    }
 
     return node;
 }
@@ -293,8 +326,69 @@ typedef struct
     size_t offset;
     size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
     internal_hooks hooks;
+    cJSON_ParsePollFn poll;
+    void *poll_user_data;
+    size_t poll_byte_interval;
+    size_t poll_iteration_interval;
+    size_t poll_bytes;
+    size_t poll_iterations;
+    cJSON_bool poll_failed;
 } parse_buffer;
 
+static cJSON_bool parse_poll_progress(
+    parse_buffer * const buffer, size_t bytes, size_t iterations)
+{
+    if ((buffer == NULL) || buffer->poll_failed)
+    {
+        return false;
+    }
+    if (bytes > (SIZE_MAX - buffer->poll_bytes)
+        || iterations > (SIZE_MAX - buffer->poll_iterations))
+    {
+        buffer->poll_failed = true;
+        return false;
+    }
+    buffer->poll_bytes += bytes;
+    buffer->poll_iterations += iterations;
+    if (buffer->poll != NULL
+        && ((buffer->poll_bytes >= buffer->poll_byte_interval)
+            || (buffer->poll_iterations >= buffer->poll_iteration_interval)))
+    {
+        if (!buffer->poll(buffer->poll_user_data))
+        {
+            buffer->poll_failed = true;
+            return false;
+        }
+        buffer->poll_bytes = 0;
+        buffer->poll_iterations = 0;
+    }
+    return true;
+}
+
+static void parse_delete(cJSON *item, parse_buffer *buffer)
+{
+    cJSON *next = NULL;
+    while (item != NULL)
+    {
+        next = item->next;
+        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
+        {
+            parse_delete(item->child, buffer);
+        }
+        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
+        {
+            buffer->hooks.deallocate(item->valuestring);
+        }
+        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+        {
+            buffer->hooks.deallocate(item->string);
+        }
+        buffer->hooks.deallocate(item);
+        (void)parse_poll_progress(buffer, 0, 1);
+        item = next;
+    }
+}
+
 /* 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) */
@@ -308,9 +402,11 @@ static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_bu
 {
     double number = 0;
     unsigned char *after_end = NULL;
-    unsigned char number_c_string[64];
+    unsigned char *number_c_string;
     unsigned char decimal_point = get_decimal_point();
     size_t i = 0;
+    size_t number_string_length = 0;
+    cJSON_bool has_decimal_point = false;
 
     if ((input_buffer == NULL) || (input_buffer->content == NULL))
     {
@@ -320,8 +416,12 @@ static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_bu
     /* 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++)
+    for (i = 0; can_access_at_index(input_buffer, i); i++)
     {
+        if (!parse_poll_progress(input_buffer, 1, 0))
+        {
+            return false;
+        }
         switch (buffer_at_offset(input_buffer)[i])
         {
             case '0':
@@ -338,11 +438,12 @@ static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_bu
             case '-':
             case 'e':
             case 'E':
-                number_c_string[i] = buffer_at_offset(input_buffer)[i];
+                number_string_length++;
                 break;
 
             case '.':
-                number_c_string[i] = decimal_point;
+                number_string_length++;
+                has_decimal_point = true;
                 break;
 
             default:
@@ -350,11 +451,50 @@ static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_bu
         }
     }
 loop_end:
-    number_c_string[i] = '\0';
+    if (!parse_poll_progress(input_buffer, 0, 1))
+    {
+        return false;
+    }
+    /* malloc for temporary buffer, add 1 for '\0' */
+    number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1);
+    if (number_c_string == NULL)
+    {
+        cJSON_mark_parse_allocation_failure();
+        return false; /* allocation failure */
+    }
+
+    for (i = 0; i < number_string_length;)
+    {
+        size_t remaining = number_string_length - i;
+        size_t chunk = remaining < input_buffer->poll_byte_interval
+            ? remaining : input_buffer->poll_byte_interval;
+        memcpy(number_c_string + i, buffer_at_offset(input_buffer) + i, chunk);
+        i += chunk;
+        if (!parse_poll_progress(input_buffer, chunk, 0))
+        {
+            input_buffer->hooks.deallocate(number_c_string);
+            return false;
+        }
+    }
+    number_c_string[number_string_length] = '\0';
+
+    if (has_decimal_point)
+    {
+        for (i = 0; i < number_string_length; i++)
+        {
+            if (number_c_string[i] == '.')
+            {
+                /* replace '.' with the decimal point of the current locale (for strtod) */
+                number_c_string[i] = decimal_point;
+            }
+        }
+    }
 
     number = strtod((const char*)number_c_string, (char**)&after_end);
     if (number_c_string == after_end)
     {
+        /* free the temporary buffer */
+        input_buffer->hooks.deallocate(number_c_string);
         return false; /* parse_error */
     }
 
@@ -377,6 +517,8 @@ loop_end:
     item->type = cJSON_Number;
 
     input_buffer->offset += (size_t)(after_end - number_c_string);
+    /* free the temporary buffer */
+    input_buffer->hooks.deallocate(number_c_string);
     return true;
 }
 
@@ -403,6 +545,8 @@ CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
 CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
 {
     char *copy = NULL;
+    size_t v1_len;
+    size_t v2_len;
     /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
     if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference))
     {
@@ -413,8 +557,17 @@ CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
     {
         return NULL;
     }
-    if (strlen(valuestring) <= strlen(object->valuestring))
+
+    v1_len = strlen(valuestring);
+    v2_len = strlen(object->valuestring);
+
+    if (v1_len <= v2_len)
     {
+        /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */
+        if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring ))
+        {
+            return NULL;
+        }
         strcpy(object->valuestring, valuestring);
         return object->valuestring;
     }
@@ -570,10 +723,10 @@ static cJSON_bool print_number(const cJSON * const item, printbuffer * const out
     {
         length = sprintf((char*)number_buffer, "null");
     }
-	else if(d == (double)item->valueint)
-	{
-		length = sprintf((char*)number_buffer, "%d", item->valueint);
-	}
+    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 */
@@ -797,6 +950,10 @@ static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_bu
         size_t skipped_bytes = 0;
         while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
         {
+            if (!parse_poll_progress(input_buffer, 1, 0))
+            {
+                goto fail;
+            }
             /* is escape sequence */
             if (input_end[0] == '\\')
             {
@@ -806,6 +963,10 @@ static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_bu
                     goto fail;
                 }
                 skipped_bytes++;
+                if (!parse_poll_progress(input_buffer, 1, 0))
+                {
+                    goto fail;
+                }
                 input_end++;
             }
             input_end++;
@@ -817,9 +978,14 @@ static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_bu
 
         /* This is at most how much we need for the output */
         allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        if (!parse_poll_progress(input_buffer, 0, 1))
+        {
+            goto fail;
+        }
         output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
         if (output == NULL)
         {
+            cJSON_mark_parse_allocation_failure();
             goto fail; /* allocation failure */
         }
     }
@@ -828,6 +994,10 @@ static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_bu
     /* loop through the string literal */
     while (input_pointer < input_end)
     {
+        if (!parse_poll_progress(input_buffer, 1, 0))
+        {
+            goto fail;
+        }
         if (*input_pointer != '\\')
         {
             *output_pointer++ = *input_pointer++;
@@ -877,6 +1047,11 @@ static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_bu
                 default:
                     goto fail;
             }
+            if ((sequence_length > 1)
+                && !parse_poll_progress(input_buffer, sequence_length - 1, 0))
+            {
+                goto fail;
+            }
             input_pointer += sequence_length;
         }
     }
@@ -1058,6 +1233,10 @@ static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
 
     while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
     {
+       if (!parse_poll_progress(buffer, 1, 0))
+       {
+           return buffer;
+       }
        buffer->offset++;
     }
 
@@ -1101,14 +1280,19 @@ CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return
 }
 
 /* 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)
+static cJSON *cJSON_ParseWithLengthOptsInternal(
+    const char *value, size_t buffer_length, const char **return_parse_end,
+    cJSON_bool require_null_terminated, cJSON_ParsePollFn poll,
+    void *poll_user_data, size_t byte_interval, size_t iteration_interval)
 {
-    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
+    parse_buffer buffer = { 0 };
     cJSON *item = NULL;
 
     /* reset error position */
     global_error.json = NULL;
     global_error.position = 0;
+    global_parse_allocation_failed = false;
+    global_parse_tracking = true;
 
     if (value == NULL || 0 == buffer_length)
     {
@@ -1119,6 +1303,17 @@ CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer
     buffer.length = buffer_length;
     buffer.offset = 0;
     buffer.hooks = global_hooks;
+    buffer.poll = poll;
+    buffer.poll_user_data = poll_user_data;
+    buffer.poll_byte_interval = byte_interval == 0 ? SIZE_MAX : byte_interval;
+    buffer.poll_iteration_interval = iteration_interval == 0
+        ? SIZE_MAX : iteration_interval;
+
+    if (buffer.poll != NULL && !buffer.poll(buffer.poll_user_data))
+    {
+        buffer.poll_failed = true;
+        goto fail;
+    }
 
     item = cJSON_New_Item(&global_hooks);
     if (item == NULL) /* memory fail */
@@ -1141,17 +1336,25 @@ CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer
             goto fail;
         }
     }
+    if (buffer.poll_failed
+        || (buffer.poll != NULL && !buffer.poll(buffer.poll_user_data)))
+    {
+        buffer.poll_failed = true;
+        goto fail;
+    }
     if (return_parse_end)
     {
         *return_parse_end = (const char*)buffer_at_offset(&buffer);
     }
 
+    global_parse_tracking = false;
     return item;
 
 fail:
+    global_parse_tracking = false;
     if (item != NULL)
     {
-        cJSON_Delete(item);
+        parse_delete(item, &buffer);
     }
 
     if (value != NULL)
@@ -1180,6 +1383,23 @@ fail:
     return NULL;
 }
 
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    return cJSON_ParseWithLengthOptsInternal(
+        value, buffer_length, return_parse_end, require_null_terminated,
+        NULL, NULL, 0, 0);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOptsAndPoll(
+    const char *value, size_t buffer_length, const char **return_parse_end,
+    cJSON_bool require_null_terminated, cJSON_ParsePollFn poll,
+    void *poll_user_data, size_t byte_interval, size_t iteration_interval)
+{
+    return cJSON_ParseWithLengthOptsInternal(
+        value, buffer_length, return_parse_end, require_null_terminated,
+        poll, poll_user_data, byte_interval, iteration_interval);
+}
+
 /* Default options for cJSON_Parse */
 CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
 {
@@ -1329,6 +1549,11 @@ static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buf
         return false; /* no input */
     }
 
+    if (!parse_poll_progress(input_buffer, 0, 1))
+    {
+        return false;
+    }
+
     /* parse the different types of values */
     /* null */
     if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
@@ -1488,6 +1713,10 @@ static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buf
     /* loop through the comma separated array elements */
     do
     {
+        if (!parse_poll_progress(input_buffer, 0, 1))
+        {
+            goto fail;
+        }
         /* allocate next item */
         cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
         if (new_item == NULL)
@@ -1542,7 +1771,7 @@ success:
 fail:
     if (head != NULL)
     {
-        cJSON_Delete(head);
+        parse_delete(head, input_buffer);
     }
 
     return false;
@@ -1646,6 +1875,10 @@ static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_bu
     /* loop through the comma separated array elements */
     do
     {
+        if (!parse_poll_progress(input_buffer, 0, 1))
+        {
+            goto fail;
+        }
         /* allocate next item */
         cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
         if (new_item == NULL)
@@ -1722,7 +1955,7 @@ success:
 fail:
     if (head != NULL)
     {
-        cJSON_Delete(head);
+        parse_delete(head, input_buffer);
     }
 
     return false;
@@ -2204,7 +2437,7 @@ CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * c
 
 CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
 {
-    if ((parent == NULL) || (item == NULL))
+    if ((parent == NULL) || (item == NULL) || (item != parent->child && item->prev == NULL))
     {
         return NULL;
     }
@@ -2726,7 +2959,14 @@ CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int co
 }
 
 /* Duplication */
+cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse);
+
 CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
+{
+    return cJSON_Duplicate_rec(item, 0, recurse );
+}
+
+cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)
 {
     cJSON *newitem = NULL;
     cJSON *child = NULL;
@@ -2773,7 +3013,10 @@ CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
     child = item->child;
     while (child != NULL)
     {
-        newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
+        if(depth >= CJSON_CIRCULAR_LIMIT) {
+            goto fail;
+        }
+        newchild = cJSON_Duplicate_rec(child, depth + 1, true); /* Duplicate (with recurse) each item in the ->next chain */
         if (!newchild)
         {
             goto fail;