/* cJSON.c - JSON parser in C.

 * Copyright (c) 2009 Dave Gamble

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 *

 * SPDX-License-Identifier: MIT

 *

 * Note that this code has been modified from the original code taken

 * from cjson-code-58.zip before 2014 (my first local commit was in

 * 2014 but I may used the code even earlier).  Since 2016 the project

 * was revived and moved to https://github.com/DaveGamble/cJSON.git.

 * It is now a lot more complex and has substantial changes so that it

 * is not possible to merge them directly.  In any case we only need a

 * simple parser and not a complete library.  I have looked through

 * the commits and fixed a few things which should apply; I also added

 * a few references to the upstream code.  Regression test are missing!

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <string.h>

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <stdint.h>

#include <float.h>

#include <limits.h>

#include <ctype.h>

#include <errno.h>

#include <gpg-error.h>

#include "cJSON.h"

/* Only use calloc. */

#define CALLOC_ONLY 1

/* Maximum recursion depth */

#define MAX_DEPTH 512

/* To avoid that a compiler optimizes certain memset calls away, these

   macros may be used instead. */

#define wipememory2(_ptr,_set,_len) do { \

        volatile char *_vptr=(volatile char *)(_ptr); \

        size_t _vlen=(_len); \

        while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \

    } while(0)

#define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)

/* We use malloc function wrappers from gpgrt (aka libgpg-error).  */

#if GPGRT_VERSION_NUMBER >= 0x011c00 /* 1.28 */

# include <gpgrt.h>

# define xtrycalloc(a,b) gpgrt_calloc ((a), (b))

# define xtrystrdup(a)   gpgrt_strdup ((a))

# define xfree(a)        gpgrt_free ((a))

# if CALLOC_ONLY

#  define xtrymalloc(a)  gpgrt_calloc (1, (a))

# else

#  define xtrymalloc(a)  gpgrt_malloc ((a))

# endif

#else /* Without gpgrt (aka libgpg-error).  */

# define xtrycalloc(a,b) calloc ((a), (b))

# define xtrystrdup(a)   strdup ((a))

# define xfree(a)        free ((a))

# if CALLOC_ONLY

#  define xtrymalloc(a)  calloc (1, (a))

# else

#  define xtrymalloc(a)  malloc ((a))

# endif

#endif

static int

cJSON_strcasecmp (const char *s1, const char *s2)

{

  if (!s1)

    return (s1 == s2) ? 0 : 1;

  if (!s2)

    return 1;

  for (; tolower (*(const unsigned char *)s1)

         == tolower (*(const unsigned char *) s2); ++s1, ++s2)

    if (*s1 == 0)

      return 0;

  return tolower (*(const unsigned char *) s1) -

    tolower (*(const unsigned char *) s2);

}

/* Internal constructor. */

static cJSON *

cJSON_New_Item (void)

{

  return xtrycalloc (1, sizeof (cJSON));

}

/* Delete a cJSON structure.  (Does not clobber ERRNO). */

void

cJSON_Delete (cJSON * c)

{

  cJSON *next;

  int save_errno;

  if (!c)

    return;

  save_errno = errno;

  while (c)

    {

      next = c->next;

      if (!(c->type & cJSON_IsReference) && c->child)

	cJSON_Delete (c->child);

      if (!(c->type & cJSON_IsReference) && c->valuestring)

        {

          wipememory (c->valuestring, strlen (c->valuestring));

          xfree (c->valuestring);

        }

      if (c->string)

        {

          wipememory (c->string, strlen (c->string));

          xfree (c->string);

        }

      xfree (c);

      c = next;

    }

  errno = save_errno;

}

/* Parse the input text to generate a number, and populate the result

 * into item. */

static const char *

parse_number (cJSON * item, const char *num)

{

  int subscale = 0;

  int signsubscale = 1;

  double n = 0;

  double sign = 1;

  double scale = 0;

  double dblmin = INT32_MIN;

  double dblmax = INT32_MAX;

  if (*num == '-')

    sign = -1, num++;		/* Has sign? */

  if (*num == '0')

    num++;			/* is zero */

  if (*num >= '1' && *num <= '9')

    do

      n = (n * 10.0) + (*num++ - '0');

    while (*num >= '0' && *num <= '9');	/* Number? */

  if (*num == '.' && num[1] >= '0' && num[1] <= '9')

    {

      num++;

      do

	n = (n * 10.0) + (*num++ - '0'), scale--;

      while (*num >= '0' && *num <= '9');

    }				/* Fractional part? */

  if (*num == 'e' || *num == 'E')	/* Exponent? */

    {

      num++;

      if (*num == '+')

	num++;

      else if (*num == '-')       /* With sign? */

	signsubscale = -1, num++;

      while (*num >= '0' && *num <= '9')

        {

          if ((10 * (double)subscale) > dblmax)

            break;

          subscale = (subscale * 10) + (*num++ - '0');

        }

    }

  /* number = +/- number.fraction * 10^+/- exponent */

  n = sign * n * pow (10.0, (scale + subscale * signsubscale));

  /* For NAN set both parts to 0.  For out of range values let the

   * integer part be 0.  */

  if (isnan (n) || isinf (n))

    {

      item->valuedouble = 0;

      item->valueint = 0;

    }

  else if (n > dblmax || n < dblmin)

    {

      item->valuedouble = n;

      item->valueint = 0;

    }

  else

    {

      item->valuedouble = n;

      item->valueint = (int)n;

    }

  item->type = cJSON_Number;

  return num;

}

/* Render the number nicely from the given item into a string. */

static char *

print_number (cJSON * item)

{

  char *str;

  double d = item->valuedouble;

  int i;

  if (fabs (((double) item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX

      && d >= INT_MIN)

    {

      /* 2^64+1 can be represented in 21 chars. */

      str = xtrymalloc (21);

      if (str)

	sprintf (str, "%d", item->valueint);

    }

  else

    {

      str = xtrymalloc (64);	/* This is a nice tradeoff. */

      if (str)

	{

          if (isnan (d))

            strcpy (str, "nan");

          else if ((i = isinf (d)))

            strcpy (str, i > 0? "inf" : ":-inf");

	  else if (fabs (floor (d) - d) <= DBL_EPSILON && fabs (d) < 1.0e60)

	    sprintf (str, "%.0f", d);

	  else if (fabs (d) < 1.0e-6 || fabs (d) > 1.0e9)

	    sprintf (str, "%e", d);

	  else

	    sprintf (str, "%f", d);

	}

    }

  return str;

}

static unsigned

parse_hex4 (const char *str)

{

  unsigned h = 0;

  if (*str >= '0' && *str <= '9')

    h += (*str) - '0';

  else if (*str >= 'A' && *str <= 'F')

    h += 10 + (*str) - 'A';

  else if (*str >= 'a' && *str <= 'f')

    h += 10 + (*str) - 'a';

  else

    return 0;

  h = h << 4;

  str++;

  if (*str >= '0' && *str <= '9')

    h += (*str) - '0';

  else if (*str >= 'A' && *str <= 'F')

    h += 10 + (*str) - 'A';

  else if (*str >= 'a' && *str <= 'f')

    h += 10 + (*str) - 'a';

  else

    return 0;

  h = h << 4;

  str++;

  if (*str >= '0' && *str <= '9')

    h += (*str) - '0';

  else if (*str >= 'A' && *str <= 'F')

    h += 10 + (*str) - 'A';

  else if (*str >= 'a' && *str <= 'f')

    h += 10 + (*str) - 'a';

  else

    return 0;

  h = h << 4;

  str++;

  if (*str >= '0' && *str <= '9')

    h += (*str) - '0';

  else if (*str >= 'A' && *str <= 'F')

    h += 10 + (*str) - 'A';

  else if (*str >= 'a' && *str <= 'f')

    h += 10 + (*str) - 'a';

  else

    return 0;

  return h;

}

/* Parse the input text into an unescaped cstring, and populate item. */

static const unsigned char firstByteMark[7] =

  { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

static const char *

parse_string (cJSON * item, const char *str, const char **ep)

{

  const char *ptr = str + 1;

  char *ptr2;

  char *out;

  int len = 0;

  unsigned uc, uc2;

  /* FIXME: We should consider eary failure like it is done with

   * commit 8656386c4f4a12f1cf3d6b26158407fd05e65029 in upstream.  */

  if (*str != '\"')

    {

      *ep = str;

      return 0;

    }				/* not a string! */

  while (*ptr != '\"' && *ptr && ++len)

    if (*ptr++ == '\\' && *ptr)

      ptr++;			/* Skip escaped quotes. */

  out = xtrymalloc (len + 2);	/* This is how long we need for the

                                 * string, roughly.  We add one extra

                                 * byte in case the last input

                                 * character is a backslash.  */

  if (!out)

    return 0;

  ptr = str + 1;

  ptr2 = out;

  while (*ptr != '\"' && *ptr)

    {

      if (*ptr != '\\')

	*ptr2++ = *ptr++;

      else

	{

	  ptr++;

          if (!*ptr)

            break;

	  switch (*ptr)

	    {

	    case 'b':

	      *ptr2++ = '\b';

	      break;

	    case 'f':

	      *ptr2++ = '\f';

	      break;

	    case 'n':

	      *ptr2++ = '\n';

	      break;

	    case 'r':

	      *ptr2++ = '\r';

	      break;

	    case 't':

	      *ptr2++ = '\t';

	      break;

	    case 'u':		/* transcode utf16 to utf8. */

	      uc = parse_hex4 (ptr + 1);

              if (!uc)

                break;          /* Bad hex; continue right after the 'u'. */

	      ptr += 4;		/* get the unicode char. */

	      if ((uc >= 0xDC00 && uc <= 0xDFFF))

		break;		/* check for invalid.   */

	      if (uc >= 0xD800 && uc <= 0xDBFF)	/* UTF16 surrogate pairs. */

		{

		  if (ptr[1] != '\\' || ptr[2] != 'u')

		    break;	/* missing second-half of surrogate.    */

                  ptr += 2;

		  uc2 = parse_hex4 (ptr + 1);

                  if (!uc2)

                    break;      /* Bad hex; continue right after the 'u'. */

		  ptr += 4;

		  if (uc2 < 0xDC00 || uc2 > 0xDFFF)

		    break;	/* invalid second-half of surrogate.    */

		  uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));

		}

	      len = 4;

	      if (uc < 0x80)

		len = 1;

	      else if (uc < 0x800)

		len = 2;

	      else if (uc < 0x10000)

		len = 3;

	      ptr2 += len;

	      switch (len)

		{

		case 4:

		  *--ptr2 = ((uc | 0x80) & 0xBF);

		  uc >>= 6;

                  /*FALLTHRU*/

		case 3:

		  *--ptr2 = ((uc | 0x80) & 0xBF);

		  uc >>= 6;

                  /*FALLTHRU*/

		case 2:

		  *--ptr2 = ((uc | 0x80) & 0xBF);

		  uc >>= 6;

                  /*FALLTHRU*/

		case 1:

		  *--ptr2 = (uc | firstByteMark[len]);

		}

	      ptr2 += len;

	      break;

	    default:

              /* Fixme: Should we fail here: See

               * https://github.com/DaveGamble/cJSON/issues/10  */

	      *ptr2++ = *ptr;

	      break;

	    }

	  ptr++;

	}

    }

  *ptr2 = 0;

  if (*ptr == '\"')

    ptr++;

  item->valuestring = out;

  item->type = cJSON_String;

  return ptr;

}

/* Render the cstring provided to an escaped version that can be printed. */

static char *

print_string_ptr (const char *str)

{

  const char *ptr;

  char *ptr2, *out;

  int len = 0;

  unsigned char token;

  if (!str)

    return xtrystrdup ("");

  ptr = str;

  while ((token = *ptr) && ++len)

    {

      if (strchr ("\"\\\b\f\n\r\t", token))

	len++;

      else if (token < 32)

	len += 5;

      ptr++;

    }

  out = xtrymalloc (len + 3);

  if (!out)

    return 0;

  ptr2 = out;

  ptr = str;

  *ptr2++ = '\"';

  while (*ptr)

    {

      if ((unsigned char) *ptr > 31 && *ptr != '\"' && *ptr != '\\')

	*ptr2++ = *ptr++;

      else

	{

	  *ptr2++ = '\\';

	  switch (token = *ptr++)

	    {

	    case '\\':

	      *ptr2++ = '\\';

	      break;

	    case '\"':

	      *ptr2++ = '\"';

	      break;

	    case '\b':

	      *ptr2++ = 'b';

	      break;

	    case '\f':

	      *ptr2++ = 'f';

	      break;

	    case '\n':

	      *ptr2++ = 'n';

	      break;

	    case '\r':

	      *ptr2++ = 'r';

	      break;

	    case '\t':

	      *ptr2++ = 't';

	      break;

	    default:

	      sprintf (ptr2, "u%04x", token);

	      ptr2 += 5;

	      break;		/* escape and print */

	    }

	}

    }

  *ptr2++ = '\"';

  *ptr2++ = 0;

  return out;

}

/* Invote print_string_ptr (which is useful) on an item. */

static char *

print_string (cJSON * item)

{

  return print_string_ptr (item->valuestring);

}

/* Predeclare these prototypes. */

static const char *parse_value (cJSON * item, const char *value,

                                const char **ep, size_t depth);

static char *print_value (cJSON * item, int depth, int fmt);

static const char *parse_array (cJSON * item, const char *value,

                                const char **ep, size_t depth);

static char *print_array (cJSON * item, int depth, int fmt);

static const char *parse_object (cJSON * item, const char *value,

                                 const char **ep, size_t depth);

static char *print_object (cJSON * item, int depth, int fmt);

/* Utility to jump whitespace and cr/lf */

static const char *

skip (const char *in)

{

  while (in && *in && (unsigned char) *in <= 32)

    in++;

  return in;

}

/* Parse an object - create a new root, and populate. */

cJSON *

cJSON_ParseWithOpts (const char *value, const char **return_parse_end,

		     int require_null_terminated, size_t *r_erroff)

{

  const char *end = 0;

  const char *ep = 0;

  cJSON *c;

  if (r_erroff)

    *r_erroff = 0;

  c = cJSON_New_Item ();

  if (!c)

    return NULL; /* memory fail */

  end = parse_value (c, skip (value), &ep, 0);

  if (!end)

    {

      cJSON_Delete (c);

      errno = EINVAL;

      if (r_erroff)

        *r_erroff = ep - value;

      return 0;

    }				/* parse failure. ep is set. */

  /* if we require null-terminated JSON without appended garbage, skip

     and then check for a null terminator */

  if (require_null_terminated)

    {

      end = skip (end);

      if (*end)

	{

	  cJSON_Delete (c);

	  ep = end;

          errno = EINVAL;

          if (r_erroff)

            *r_erroff = ep - value;

	  return 0;

	}

    }

  if (return_parse_end)

    *return_parse_end = end;

  return c;

}

/* Default options for cJSON_Parse */

cJSON *

cJSON_Parse (const char *value, size_t *r_erroff)

{

  return cJSON_ParseWithOpts (value, 0, 0, r_erroff);

}

/* Render a cJSON item/entity/structure to text. */

char *

cJSON_Print (cJSON * item)

{

  return print_value (item, 0, 1);

}

char *

cJSON_PrintUnformatted (cJSON * item)

{

  return print_value (item, 0, 0);

}

/* Parser core - when encountering text, process appropriately. */

static const char *

parse_value (cJSON * item, const char *value, const char **ep,

             size_t depth)

{

  if (depth > MAX_DEPTH)

    {

      *ep = value;

      return 0;

    }

  if (!value)

    return 0;			/* Fail on null. */

  if (!strncmp (value, "null", 4))

    {

      item->type = cJSON_NULL;

      return value + 4;

    }

  if (!strncmp (value, "false", 5))

    {

      item->type = cJSON_False;

      return value + 5;

    }

  if (!strncmp (value, "true", 4))

    {

      item->type = cJSON_True;

      item->valueint = 1;

      return value + 4;

    }

  if (*value == '\"')

    {

      return parse_string (item, value, ep);

    }

  if (*value == '-' || (*value >= '0' && *value <= '9'))

    {

      return parse_number (item, value);

    }

  if (*value == '[')

    {

      return parse_array (item, value, ep, depth + 1);

    }

  if (*value == '{')

    {

      return parse_object (item, value, ep, depth + 1);

    }

  *ep = value;

  return 0;			/* failure. */

}

/* Render a value to text. */

static char *

print_value (cJSON * item, int depth, int fmt)

{

  char *out = 0;

  if (!item)

    return 0;

  switch ((item->type) & 255)

    {

    case cJSON_NULL:

      out = xtrystrdup ("null");

      break;

    case cJSON_False:

      out = xtrystrdup ("false");

      break;

    case cJSON_True:

      out = xtrystrdup ("true");

      break;

    case cJSON_Number:

      out = print_number (item);

      break;

    case cJSON_String:

      out = print_string (item);

      break;

    case cJSON_Array:

      out = print_array (item, depth, fmt);

      break;

    case cJSON_Object:

      out = print_object (item, depth, fmt);

      break;

    }

  return out;

}

/* Build an array from input text. */

static const char *

parse_array (cJSON * item, const char *value, const char **ep,

             size_t depth)

{

  cJSON *child;

  if (depth > MAX_DEPTH)

    {

      *ep = value;

      return 0;

    }

  if (*value != '[')

    {

      *ep = value;

      return 0;

    }				/* not an array! */

  item->type = cJSON_Array;

  value = skip (value + 1);

  if (*value == ']')

    return value + 1;		/* empty array. */

  item->child = child = cJSON_New_Item ();

  if (!item->child)

    return 0;			/* memory fail */

  /* skip any spacing, get the value. */

  value = skip (parse_value (child, skip (value), ep,

                             depth + 1));

  if (!value)

    return 0;

  while (*value == ',')

    {

      cJSON *new_item;

      if (!(new_item = cJSON_New_Item ()))

	return 0;		/* memory fail */

      child->next = new_item;

      new_item->prev = child;

      child = new_item;

      value = skip (parse_value (child, skip (value + 1), ep,

                                 depth + 1));

      if (!value)

	return 0;		/* memory fail */

    }

  if (*value == ']')

    return value + 1;		/* end of array */

  *ep = value;

  return 0;			/* malformed. */

}

/* Render an array to text */

static char *

print_array (cJSON * item, int depth, int fmt)

{

  char **entries;

  char *out = 0, *ptr, *ret;

  int len = 5;

  cJSON *child = item->child;

  int numentries = 0, i = 0, fail = 0;

  /* How many entries in the array? */

  while (child)

    numentries++, child = child->next;

  /* Explicitly handle numentries==0 */

  if (!numentries)

    {

      out = xtrymalloc (3);

      if (out)

	strcpy (out, "[]");

      return out;

    }

  /* Allocate an array to hold the values for each */

  entries = xtrymalloc (numentries * sizeof (char *));

  if (!entries)

    return 0;

  memset (entries, 0, numentries * sizeof (char *));

  /* Retrieve all the results: */

  child = item->child;

  while (child && !fail)

    {

      ret = print_value (child, depth + 1, fmt);

      entries[i++] = ret;

      if (ret)

	len += strlen (ret) + 2 + (fmt ? 1 : 0);

      else

	fail = 1;

      child = child->next;

    }

  /* If we didn't fail, try to xtrymalloc the output string */

  if (!fail)

    out = xtrymalloc (len);

  /* If that fails, we fail. */

  if (!out)

    fail = 1;

  /* Handle failure. */

  if (fail)

    {

      for (i = 0; i < numentries; i++)

	if (entries[i])

	  xfree (entries[i]);

      xfree (entries);

      return 0;

    }

  /* Compose the output array. */

  *out = '[';

  ptr = out + 1;

  *ptr = 0;

  for (i = 0; i < numentries; i++)

    {

      strcpy (ptr, entries[i]);

      ptr += strlen (entries[i]);

      if (i != numentries - 1)

	{

	  *ptr++ = ',';

	  if (fmt)

	    *ptr++ = ' ';

	  *ptr = 0;

	}

      xfree (entries[i]);

    }

  xfree (entries);

  *ptr++ = ']';

  *ptr++ = 0;

  return out;

}

/* Build an object from the text. */

static const char *

parse_object (cJSON * item, const char *value, const char **ep,

              size_t depth)

{

  cJSON *child;

  if (depth > MAX_DEPTH)

    {

      *ep = value;

      return 0;

    }

  if (*value != '{')

    {

      *ep = value;

      return 0;

    }				/* not an object! */

  item->type = cJSON_Object;

  value = skip (value + 1);

  if (*value == '}')

    return value + 1;		/* empty array. */

  item->child = child = cJSON_New_Item ();

  if (!item->child)

    return 0;

  value = skip (parse_string (child, skip (value), ep));

  if (!value)

    return 0;

  child->string = child->valuestring;

  child->valuestring = 0;

  if (*value != ':')

    {

      *ep = value;

      return 0;

    }				/* fail! */

  /* skip any spacing, get the value. */

  value = skip (parse_value (child, skip (value + 1), ep,

                             depth + 1));

  if (!value)

    return 0;

  while (*value == ',')

    {

      cJSON *new_item;

      if (!(new_item = cJSON_New_Item ()))

	return 0;		/* memory fail */

      child->next = new_item;

      new_item->prev = child;

      child = new_item;

      value = skip (parse_string (child, skip (value + 1), ep));

      if (!value)

	return 0;

      child->string = child->valuestring;

      child->valuestring = 0;

      if (*value != ':')

	{

	  *ep = value;

	  return 0;

	}			/* fail! */

      /* skip any spacing, get the value. */

      value = skip (parse_value (child, skip (value + 1), ep, depth + 1));

      if (!value)

	return 0;

    }

  if (*value == '}')

    return value + 1;		/* end of array */

  *ep = value;

  return 0;			/* malformed. */

}

/* Render an object to text. */

static char *

print_object (cJSON * item, int depth, int fmt)

{

  char **entries = 0, **names = 0;

  char *out = 0, *ptr, *ret, *str;

  int len = 7, i = 0, j;

  cJSON *child = item->child;

  int numentries = 0, fail = 0;