RedfishPkg/Library/JsonLib/load.c

   1 /*
   2  * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
   3  *
   4  * Jansson is free software; you can redistribute it and/or modify
   5  * it under the terms of the MIT license. See LICENSE for details.
   6
   7  (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
   8
   9     SPDX-License-Identifier: BSD-2-Clause-Patent AND MIT
  10  */
  11
  12 #ifndef _GNU_SOURCE
  13 #define _GNU_SOURCE
  14 #endif
  15
  16 #include "jansson_private.h"
  17
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27
  28 #include "jansson.h"
  29 #include "strbuffer.h"
  30 #include "utf.h"
  31
  32 #define STREAM_STATE_OK    0
  33 #define STREAM_STATE_EOF   -1
  34 #define STREAM_STATE_ERROR -2
  35
  36 #define TOKEN_INVALID -1
  37 #define TOKEN_EOF     0
  38 #define TOKEN_STRING  256
  39 #define TOKEN_INTEGER 257
  40 #define TOKEN_REAL    258
  41 #define TOKEN_TRUE    259
  42 #define TOKEN_FALSE   260
  43 #define TOKEN_NULL    261
  44
  45 /* Locale independent versions of isxxx() functions */
  46 #define l_isupper(c) ('A' <= (c) && (c) <= 'Z')
  47 #define l_islower(c) ('a' <= (c) && (c) <= 'z')
  48 #define l_isalpha(c) (l_isupper(c) || l_islower(c))
  49 #define l_isdigit(c) ('0' <= (c) && (c) <= '9')
  50 #define l_isxdigit(c)                                                                    \
  51     (l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
  52
  53 /* Read one byte from stream, convert to unsigned char, then int, and
  54    return. return EOF on end of file. This corresponds to the
  55    behaviour of fgetc(). */
  56 typedef int (*get_func)(void *data);
  57
  58 typedef struct {
  59     get_func get;
  60     void *data;
  61     char buffer[5];
  62     size_t buffer_pos;
  63     int state;
  64     int line;
  65     int column, last_column;
  66     size_t position;
  67 } stream_t;
  68
  69 typedef struct {
  70     stream_t stream;
  71     strbuffer_t saved_text;
  72     size_t flags;
  73     size_t depth;
  74     int token;
  75     union {
  76         struct {
  77             char *val;
  78             size_t len;
  79         } string;
  80         json_int_t integer;
  81         double real;
  82     } value;
  83 } lex_t;
  84
  85 #define stream_to_lex(stream) container_of(stream, lex_t, stream)
  86
  87 /*** error reporting ***/
  88
  89 static void error_set(json_error_t *error, const lex_t *lex, enum json_error_code code,
  90                       const char *msg, ...) {
  91     va_list ap;
  92     char msg_text[JSON_ERROR_TEXT_LENGTH];
  93     char msg_with_context[JSON_ERROR_TEXT_LENGTH];
  94
  95     int line = -1, col = -1;
  96     size_t pos = 0;
  97     const char *result = msg_text;
  98
  99     if (!error)
 100         return;
 101
 102     va_start(ap, msg);
 103     vsnprintf(msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
 104     msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 105     va_end(ap);
 106
 107     if (lex) {
 108         const char *saved_text = strbuffer_value(&lex->saved_text);
 109
 110         line = lex->stream.line;
 111         col = lex->stream.column;
 112         pos = lex->stream.position;
 113
 114         if (saved_text && saved_text[0]) {
 115             if (lex->saved_text.length <= 20) {
 116                 snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near '%s'",
 117                          msg_text, saved_text);
 118                 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 119                 result = msg_with_context;
 120             }
 121         } else {
 122             if (code == json_error_invalid_syntax) {
 123                 /* More specific error code for premature end of file. */
 124                 code = json_error_premature_end_of_input;
 125             }
 126             if (lex->stream.state == STREAM_STATE_ERROR) {
 127                 /* No context for UTF-8 decoding errors */
 128                 result = msg_text;
 129             } else {
 130                 snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near end of file",
 131                          msg_text);
 132                 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 133                 result = msg_with_context;
 134             }
 135         }
 136     }
 137
 138     jsonp_error_set(error, line, col, pos, code, "%s", result);
 139 }
 140
 141 /*** lexical analyzer ***/
 142
 143 static void stream_init(stream_t *stream, get_func get, void *data) {
 144     stream->get = get;
 145     stream->data = data;
 146     stream->buffer[0] = '\0';
 147     stream->buffer_pos = 0;
 148
 149     stream->state = STREAM_STATE_OK;
 150     stream->line = 1;
 151     stream->column = 0;
 152     stream->position = 0;
 153 }
 154
 155 static int stream_get(stream_t *stream, json_error_t *error) {
 156     int c;
 157
 158     if (stream->state != STREAM_STATE_OK)
 159         return stream->state;
 160
 161     if (!stream->buffer[stream->buffer_pos]) {
 162         c = stream->get(stream->data);
 163         if (c == EOF) {
 164             stream->state = STREAM_STATE_EOF;
 165             return STREAM_STATE_EOF;
 166         }
 167
 168         stream->buffer[0] = c;
 169         stream->buffer_pos = 0;
 170
 171         if (0x80 <= c && c <= 0xFF) {
 172             /* multi-byte UTF-8 sequence */
 173             size_t i, count;
 174
 175             count = utf8_check_first(c);
 176             if (!count)
 177                 goto out;
 178
 179             assert(count >= 2);
 180
 181             for (i = 1; i < count; i++)
 182                 stream->buffer[i] = stream->get(stream->data);
 183
 184             if (!utf8_check_full(stream->buffer, count, NULL))
 185                 goto out;
 186
 187             stream->buffer[count] = '\0';
 188         } else
 189             stream->buffer[1] = '\0';
 190     }
 191
 192     c = stream->buffer[stream->buffer_pos++];
 193
 194     stream->position++;
 195     if (c == '\n') {
 196         stream->line++;
 197         stream->last_column = stream->column;
 198         stream->column = 0;
 199     } else if (utf8_check_first(c)) {
 200         /* track the Unicode character column, so increment only if
 201            this is the first character of a UTF-8 sequence */
 202         stream->column++;
 203     }
 204
 205     return c;
 206
 207 out:
 208     stream->state = STREAM_STATE_ERROR;
 209     error_set(error, stream_to_lex(stream), json_error_invalid_utf8,
 210               "unable to decode byte 0x%x", c);
 211     return STREAM_STATE_ERROR;
 212 }
 213
 214 static void stream_unget(stream_t *stream, int c) {
 215     if (c == STREAM_STATE_EOF || c == STREAM_STATE_ERROR)
 216         return;
 217
 218     stream->position--;
 219     if (c == '\n') {
 220         stream->line--;
 221         stream->column = stream->last_column;
 222     } else if (utf8_check_first(c))
 223         stream->column--;
 224
 225     assert(stream->buffer_pos > 0);
 226     stream->buffer_pos--;
 227     assert(stream->buffer[stream->buffer_pos] == c);
 228 }
 229
 230 static int lex_get(lex_t *lex, json_error_t *error) {
 231     return stream_get(&lex->stream, error);
 232 }
 233
 234 static void lex_save(lex_t *lex, int c) { strbuffer_append_byte(&lex->saved_text, c); }
 235
 236 static int lex_get_save(lex_t *lex, json_error_t *error) {
 237     int c = stream_get(&lex->stream, error);
 238     if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR)
 239         lex_save(lex, c);
 240     return c;
 241 }
 242
 243 static void lex_unget(lex_t *lex, int c) { stream_unget(&lex->stream, c); }
 244
 245 static void lex_unget_unsave(lex_t *lex, int c) {
 246     if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR) {
 247 /* Since we treat warnings as errors, when assertions are turned
 248  * off the "d" variable would be set but never used. Which is
 249  * treated as an error by GCC.
 250  */
 251 #ifndef NDEBUG
 252         char d;
 253 #endif
 254         stream_unget(&lex->stream, c);
 255 #ifndef NDEBUG
 256         d =
 257 #endif
 258             strbuffer_pop(&lex->saved_text);
 259         assert(c == d);
 260     }
 261 }
 262
 263 static void lex_save_cached(lex_t *lex) {
 264     while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
 265         lex_save(lex, lex->stream.buffer[lex->stream.buffer_pos]);
 266         lex->stream.buffer_pos++;
 267         lex->stream.position++;
 268     }
 269 }
 270
 271 static void lex_free_string(lex_t *lex) {
 272     jsonp_free(lex->value.string.val);
 273     lex->value.string.val = NULL;
 274     lex->value.string.len = 0;
 275 }
 276
 277 /* assumes that str points to 'u' plus at least 4 valid hex digits */
 278 static int32_t decode_unicode_escape(const char *str) {
 279     int i;
 280     int32_t value = 0;
 281
 282     assert(str[0] == 'u');
 283
 284     for (i = 1; i <= 4; i++) {
 285         char c = str[i];
 286         value <<= 4;
 287         if (l_isdigit(c))
 288             value += c - '0';
 289         else if (l_islower(c))
 290             value += c - 'a' + 10;
 291         else if (l_isupper(c))
 292             value += c - 'A' + 10;
 293         else
 294             return -1;
 295     }
 296
 297     return value;
 298 }
 299
 300 static void lex_scan_string(lex_t *lex, json_error_t *error) {
 301     int c;
 302     const char *p;
 303     char *t;
 304     int i;
 305
 306     lex->value.string.val = NULL;
 307     lex->token = TOKEN_INVALID;
 308
 309     c = lex_get_save(lex, error);
 310
 311     while (c != '"') {
 312         if (c == STREAM_STATE_ERROR)
 313             goto out;
 314
 315         else if (c == STREAM_STATE_EOF) {
 316             error_set(error, lex, json_error_premature_end_of_input,
 317                       "premature end of input");
 318             goto out;
 319         }
 320
 321         else if (0 <= c && c <= 0x1F) {
 322             /* control character */
 323             lex_unget_unsave(lex, c);
 324             if (c == '\n')
 325                 error_set(error, lex, json_error_invalid_syntax, "unexpected newline");
 326             else
 327                 error_set(error, lex, json_error_invalid_syntax, "control character 0x%x",
 328                           c);
 329             goto out;
 330         }
 331
 332         else if (c == '\\') {
 333             c = lex_get_save(lex, error);
 334             if (c == 'u') {
 335                 c = lex_get_save(lex, error);
 336                 for (i = 0; i < 4; i++) {
 337                     if (!l_isxdigit(c)) {
 338                         error_set(error, lex, json_error_invalid_syntax,
 339                                   "invalid escape");
 340                         goto out;
 341                     }
 342                     c = lex_get_save(lex, error);
 343                 }
 344             } else if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' ||
 345                        c == 'n' || c == 'r' || c == 't')
 346                 c = lex_get_save(lex, error);
 347             else {
 348                 error_set(error, lex, json_error_invalid_syntax, "invalid escape");
 349                 goto out;
 350             }
 351         } else
 352             c = lex_get_save(lex, error);
 353     }
 354
 355     /* the actual value is at most of the same length as the source
 356        string, because:
 357          - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
 358          - a single \uXXXX escape (length 6) is converted to at most 3 bytes
 359          - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
 360            are converted to 4 bytes
 361     */
 362     t = jsonp_malloc(lex->saved_text.length + 1);
 363     if (!t) {
 364         /* this is not very nice, since TOKEN_INVALID is returned */
 365         goto out;
 366     }
 367     lex->value.string.val = t;
 368
 369     /* + 1 to skip the " */
 370     p = strbuffer_value(&lex->saved_text) + 1;
 371
 372     while (*p != '"') {
 373         if (*p == '\\') {
 374             p++;
 375             if (*p == 'u') {
 376                 size_t length;
 377                 int32_t value;
 378
 379                 value = decode_unicode_escape(p);
 380                 if (value < 0) {
 381                     error_set(error, lex, json_error_invalid_syntax,
 382                               "invalid Unicode escape '%.6s'", p - 1);
 383                     goto out;
 384                 }
 385                 p += 5;
 386
 387                 if (0xD800 <= value && value <= 0xDBFF) {
 388                     /* surrogate pair */
 389                     if (*p == '\\' && *(p + 1) == 'u') {
 390                         int32_t value2 = decode_unicode_escape(++p);
 391                         if (value2 < 0) {
 392                             error_set(error, lex, json_error_invalid_syntax,
 393                                       "invalid Unicode escape '%.6s'", p - 1);
 394                             goto out;
 395                         }
 396                         p += 5;
 397
 398                         if (0xDC00 <= value2 && value2 <= 0xDFFF) {
 399                             /* valid second surrogate */
 400                             value =
 401                                 ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
 402                         } else {
 403                             /* invalid second surrogate */
 404                             error_set(error, lex, json_error_invalid_syntax,
 405                                       "invalid Unicode '\\u%04X\\u%04X'", value, value2);
 406                             goto out;
 407                         }
 408                     } else {
 409                         /* no second surrogate */
 410                         error_set(error, lex, json_error_invalid_syntax,
 411                                   "invalid Unicode '\\u%04X'", value);
 412                         goto out;
 413                     }
 414                 } else if (0xDC00 <= value && value <= 0xDFFF) {
 415                     error_set(error, lex, json_error_invalid_syntax,
 416                               "invalid Unicode '\\u%04X'", value);
 417                     goto out;
 418                 }
 419
 420                 if (utf8_encode(value, t, &length))
 421                     assert(0);
 422                 t += length;
 423             } else {
 424                 switch (*p) {
 425                     case '"':
 426                     case '\\':
 427                     case '/':
 428                         *t = *p;
 429                         break;
 430                     case 'b':
 431                         *t = '\b';
 432                         break;
 433                     case 'f':
 434                         *t = '\f';
 435                         break;
 436                     case 'n':
 437                         *t = '\n';
 438                         break;
 439                     case 'r':
 440                         *t = '\r';
 441                         break;
 442                     case 't':
 443                         *t = '\t';
 444                         break;
 445                     default:
 446                         assert(0);
 447                 }
 448                 t++;
 449                 p++;
 450             }
 451         } else
 452             *(t++) = *(p++);
 453     }
 454     *t = '\0';
 455     lex->value.string.len = t - lex->value.string.val;
 456     lex->token = TOKEN_STRING;
 457     return;
 458
 459 out:
 460     lex_free_string(lex);
 461 }
 462
 463 #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
 464 #if JSON_INTEGER_IS_LONG_LONG
 465 #ifdef _MSC_VER /* Microsoft Visual Studio */
 466 #define json_strtoint _strtoi64
 467 #else
 468 #define json_strtoint strtoll
 469 #endif
 470 #else
 471 #define json_strtoint strtol
 472 #endif
 473 #endif
 474
 475 static int lex_scan_number(lex_t *lex, int c, json_error_t *error) {
 476     const char *saved_text;
 477     char *end;
 478     double doubleval;
 479
 480     lex->token = TOKEN_INVALID;
 481
 482     if (c == '-')
 483         c = lex_get_save(lex, error);
 484
 485     if (c == '0') {
 486         c = lex_get_save(lex, error);
 487         if (l_isdigit(c)) {
 488             lex_unget_unsave(lex, c);
 489             goto out;
 490         }
 491     } else if (l_isdigit(c)) {
 492         do
 493             c = lex_get_save(lex, error);
 494         while (l_isdigit(c));
 495     } else {
 496         lex_unget_unsave(lex, c);
 497         goto out;
 498     }
 499
 500     if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && c != '.' && c != 'E' && c != 'e') {
 501         json_int_t intval;
 502
 503         lex_unget_unsave(lex, c);
 504
 505         saved_text = strbuffer_value(&lex->saved_text);
 506
 507         errno = 0;
 508         intval = json_strtoint(saved_text, &end, 10);
 509         if (errno == ERANGE) {
 510             if (intval < 0)
 511                 error_set(error, lex, json_error_numeric_overflow,
 512                           "too big negative integer");
 513             else
 514                 error_set(error, lex, json_error_numeric_overflow, "too big integer");
 515             goto out;
 516         }
 517
 518         assert(end == saved_text + lex->saved_text.length);
 519
 520         lex->token = TOKEN_INTEGER;
 521         lex->value.integer = intval;
 522         return 0;
 523     }
 524
 525     if (c == '.') {
 526         c = lex_get(lex, error);
 527         if (!l_isdigit(c)) {
 528             lex_unget(lex, c);
 529             goto out;
 530         }
 531         lex_save(lex, c);
 532
 533         do
 534             c = lex_get_save(lex, error);
 535         while (l_isdigit(c));
 536     }
 537
 538     if (c == 'E' || c == 'e') {
 539         c = lex_get_save(lex, error);
 540         if (c == '+' || c == '-')
 541             c = lex_get_save(lex, error);
 542
 543         if (!l_isdigit(c)) {
 544             lex_unget_unsave(lex, c);
 545             goto out;
 546         }
 547
 548         do
 549             c = lex_get_save(lex, error);
 550         while (l_isdigit(c));
 551     }
 552
 553     lex_unget_unsave(lex, c);
 554
 555     if (jsonp_strtod(&lex->saved_text, &doubleval)) {
 556         error_set(error, lex, json_error_numeric_overflow, "real number overflow");
 557         goto out;
 558     }
 559
 560     lex->token = TOKEN_REAL;
 561     lex->value.real = doubleval;
 562     return 0;
 563
 564 out:
 565     return -1;
 566 }
 567
 568 static int lex_scan(lex_t *lex, json_error_t *error) {
 569     int c;
 570
 571     strbuffer_clear(&lex->saved_text);
 572
 573     if (lex->token == TOKEN_STRING)
 574         lex_free_string(lex);
 575
 576     do
 577         c = lex_get(lex, error);
 578     while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
 579
 580     if (c == STREAM_STATE_EOF) {
 581         lex->token = TOKEN_EOF;
 582         goto out;
 583     }
 584
 585     if (c == STREAM_STATE_ERROR) {
 586         lex->token = TOKEN_INVALID;
 587         goto out;
 588     }
 589
 590     lex_save(lex, c);
 591
 592     if (c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
 593         lex->token = c;
 594
 595     else if (c == '"')
 596         lex_scan_string(lex, error);
 597
 598     else if (l_isdigit(c) || c == '-') {
 599         if (lex_scan_number(lex, c, error))
 600             goto out;
 601     }
 602
 603     else if (l_isalpha(c)) {
 604         /* eat up the whole identifier for clearer error messages */
 605         const char *saved_text;
 606
 607         do
 608             c = lex_get_save(lex, error);
 609         while (l_isalpha(c));
 610         lex_unget_unsave(lex, c);
 611
 612         saved_text = strbuffer_value(&lex->saved_text);
 613
 614         if (strcmp(saved_text, "true") == 0)
 615             lex->token = TOKEN_TRUE;
 616         else if (strcmp(saved_text, "false") == 0)
 617             lex->token = TOKEN_FALSE;
 618         else if (strcmp(saved_text, "null") == 0)
 619             lex->token = TOKEN_NULL;
 620         else
 621             lex->token = TOKEN_INVALID;
 622     }
 623
 624     else {
 625         /* save the rest of the input UTF-8 sequence to get an error
 626            message of valid UTF-8 */
 627         lex_save_cached(lex);
 628         lex->token = TOKEN_INVALID;
 629     }
 630
 631 out:
 632     return lex->token;
 633 }
 634
 635 static char *lex_steal_string(lex_t *lex, size_t *out_len) {
 636     char *result = NULL;
 637     if (lex->token == TOKEN_STRING) {
 638         result = lex->value.string.val;
 639         *out_len = lex->value.string.len;
 640         lex->value.string.val = NULL;
 641         lex->value.string.len = 0;
 642     }
 643     return result;
 644 }
 645
 646 static int lex_init(lex_t *lex, get_func get, size_t flags, void *data) {
 647     stream_init(&lex->stream, get, data);
 648     if (strbuffer_init(&lex->saved_text))
 649         return -1;
 650
 651     lex->flags = flags;
 652     lex->token = TOKEN_INVALID;
 653     return 0;
 654 }
 655
 656 static void lex_close(lex_t *lex) {
 657     if (lex->token == TOKEN_STRING)
 658         lex_free_string(lex);
 659     strbuffer_close(&lex->saved_text);
 660 }
 661
 662 /*** parser ***/
 663
 664 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error);
 665
 666 static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error) {
 667     json_t *object = json_object();
 668     if (!object)
 669         return NULL;
 670
 671     lex_scan(lex, error);
 672     if (lex->token == '}')
 673         return object;
 674
 675     while (1) {
 676         char *key;
 677         size_t len;
 678         json_t *value;
 679
 680         if (lex->token != TOKEN_STRING) {
 681             error_set(error, lex, json_error_invalid_syntax, "string or '}' expected");
 682             goto error;
 683         }
 684
 685         key = lex_steal_string(lex, &len);
 686         if (!key)
 687             return NULL;
 688         if (memchr(key, '\0', len)) {
 689             jsonp_free(key);
 690             error_set(error, lex, json_error_null_byte_in_key,
 691                       "NUL byte in object key not supported");
 692             goto error;
 693         }
 694
 695         if (flags & JSON_REJECT_DUPLICATES) {
 696             if (json_object_get(object, key)) {
 697                 jsonp_free(key);
 698                 error_set(error, lex, json_error_duplicate_key, "duplicate object key");
 699                 goto error;
 700             }
 701         }
 702
 703         lex_scan(lex, error);
 704         if (lex->token != ':') {
 705             jsonp_free(key);
 706             error_set(error, lex, json_error_invalid_syntax, "':' expected");
 707             goto error;
 708         }
 709
 710         lex_scan(lex, error);
 711         value = parse_value(lex, flags, error);
 712         if (!value) {
 713             jsonp_free(key);
 714             goto error;
 715         }
 716
 717         if (json_object_set_new_nocheck(object, key, value)) {
 718             jsonp_free(key);
 719             goto error;
 720         }
 721
 722         jsonp_free(key);
 723
 724         lex_scan(lex, error);
 725         if (lex->token != ',')
 726             break;
 727
 728         lex_scan(lex, error);
 729     }
 730
 731     if (lex->token != '}') {
 732         error_set(error, lex, json_error_invalid_syntax, "'}' expected");
 733         goto error;
 734     }
 735
 736     return object;
 737
 738 error:
 739     json_decref(object);
 740     return NULL;
 741 }
 742
 743 static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error) {
 744     json_t *array = json_array();
 745     if (!array)
 746         return NULL;
 747
 748     lex_scan(lex, error);
 749     if (lex->token == ']')
 750         return array;
 751
 752     while (lex->token) {
 753         json_t *elem = parse_value(lex, flags, error);
 754         if (!elem)
 755             goto error;
 756
 757         if (json_array_append_new(array, elem)) {
 758             goto error;
 759         }
 760
 761         lex_scan(lex, error);
 762         if (lex->token != ',')
 763             break;
 764
 765         lex_scan(lex, error);
 766     }
 767
 768     if (lex->token != ']') {
 769         error_set(error, lex, json_error_invalid_syntax, "']' expected");
 770         goto error;
 771     }
 772
 773     return array;
 774
 775 error:
 776     json_decref(array);
 777     return NULL;
 778 }
 779
 780 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error) {
 781     json_t *json;
 782
 783     lex->depth++;
 784     if (lex->depth > JSON_PARSER_MAX_DEPTH) {
 785         error_set(error, lex, json_error_stack_overflow, "maximum parsing depth reached");
 786         return NULL;
 787     }
 788
 789     switch (lex->token) {
 790         case TOKEN_STRING: {
 791             const char *value = lex->value.string.val;
 792             size_t len = lex->value.string.len;
 793
 794             if (!(flags & JSON_ALLOW_NUL)) {
 795                 if (memchr(value, '\0', len)) {
 796                     error_set(error, lex, json_error_null_character,
 797                               "\\u0000 is not allowed without JSON_ALLOW_NUL");
 798                     return NULL;
 799                 }
 800             }
 801
 802             json = jsonp_stringn_nocheck_own(value, len);
 803             lex->value.string.val = NULL;
 804             lex->value.string.len = 0;
 805             break;
 806         }
 807
 808         case TOKEN_INTEGER: {
 809             json = json_integer(lex->value.integer);
 810             break;
 811         }
 812
 813         case TOKEN_REAL: {
 814             json = json_real(lex->value.real);
 815             break;
 816         }
 817
 818         case TOKEN_TRUE:
 819             json = json_true();
 820             break;
 821
 822         case TOKEN_FALSE:
 823             json = json_false();
 824             break;
 825
 826         case TOKEN_NULL:
 827             json = json_null();
 828             break;
 829
 830         case '{':
 831             json = parse_object(lex, flags, error);
 832             break;
 833
 834         case '[':
 835             json = parse_array(lex, flags, error);
 836             break;
 837
 838         case TOKEN_INVALID:
 839             error_set(error, lex, json_error_invalid_syntax, "invalid token");
 840             return NULL;
 841
 842         default:
 843             error_set(error, lex, json_error_invalid_syntax, "unexpected token");
 844             return NULL;
 845     }
 846
 847     if (!json)
 848         return NULL;
 849
 850     lex->depth--;
 851     return json;
 852 }
 853
 854 static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error) {
 855     json_t *result;
 856
 857     lex->depth = 0;
 858
 859     lex_scan(lex, error);
 860     if (!(flags & JSON_DECODE_ANY)) {
 861         if (lex->token != '[' && lex->token != '{') {
 862             error_set(error, lex, json_error_invalid_syntax, "'[' or '{' expected");
 863             return NULL;
 864         }
 865     }
 866
 867     result = parse_value(lex, flags, error);
 868     if (!result)
 869         return NULL;
 870
 871     if (!(flags & JSON_DISABLE_EOF_CHECK)) {
 872         lex_scan(lex, error);
 873         if (lex->token != TOKEN_EOF) {
 874             error_set(error, lex, json_error_end_of_input_expected,
 875                       "end of file expected");
 876             json_decref(result);
 877             return NULL;
 878         }
 879     }
 880
 881     if (error) {
 882         /* Save the position even though there was no error */
 883         error->position = (int)lex->stream.position;
 884     }
 885
 886     return result;
 887 }
 888
 889 typedef struct {
 890     const char *data;
 891     size_t pos;
 892 } string_data_t;
 893
 894 static int string_get(void *data) {
 895     char c;
 896     string_data_t *stream = (string_data_t *)data;
 897     c = stream->data[stream->pos];
 898     if (c == '\0')
 899         return EOF;
 900     else {
 901         stream->pos++;
 902         return (unsigned char)c;
 903     }
 904 }
 905
 906 json_t *json_loads(const char *string, size_t flags, json_error_t *error) {
 907     lex_t lex;
 908     json_t *result;
 909     string_data_t stream_data;
 910
 911     jsonp_error_init(error, "<string>");
 912
 913     if (string == NULL) {
 914         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
 915         return NULL;
 916     }
 917
 918     stream_data.data = string;
 919     stream_data.pos = 0;
 920
 921     if (lex_init(&lex, string_get, flags, (void *)&stream_data))
 922         return NULL;
 923
 924     result = parse_json(&lex, flags, error);
 925
 926     lex_close(&lex);
 927     return result;
 928 }
 929
 930 typedef struct {
 931     const char *data;
 932     size_t len;
 933     size_t pos;
 934 } buffer_data_t;
 935
 936 static int buffer_get(void *data) {
 937     char c;
 938     buffer_data_t *stream = data;
 939     if (stream->pos >= stream->len)
 940         return EOF;
 941
 942     c = stream->data[stream->pos];
 943     stream->pos++;
 944     return (unsigned char)c;
 945 }
 946
 947 json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error) {
 948     lex_t lex;
 949     json_t *result;
 950     buffer_data_t stream_data;
 951
 952     jsonp_error_init(error, "<buffer>");
 953
 954     if (buffer == NULL) {
 955         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
 956         return NULL;
 957     }
 958
 959     stream_data.data = buffer;
 960     stream_data.pos = 0;
 961     stream_data.len = buflen;
 962
 963     if (lex_init(&lex, buffer_get, flags, (void *)&stream_data))
 964         return NULL;
 965
 966     result = parse_json(&lex, flags, error);
 967
 968     lex_close(&lex);
 969     return result;
 970 }
 971
 972 json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) {
 973     lex_t lex;
 974     const char *source;
 975     json_t *result;
 976 #ifdef HAVE_UNISTD_H
 977     if (input == stdin)
 978         source = "<stdin>";
 979     else
 980 #endif
 981         source = "<stream>";
 982
 983     jsonp_error_init(error, source);
 984
 985     if (input == NULL) {
 986         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
 987         return NULL;
 988     }
 989
 990     if (lex_init(&lex, (get_func)fgetc, flags, input))
 991         return NULL;
 992
 993     result = parse_json(&lex, flags, error);
 994
 995     lex_close(&lex);
 996     return result;
 997 }
 998
 999 static int fd_get_func(int *fd) {
1000 #ifdef HAVE_UNISTD_H
1001     uint8_t c;
1002     if (read(*fd, &c, 1) == 1)
1003         return c;
1004 #endif
1005     return EOF;
1006 }
1007
1008 json_t *json_loadfd(int input, size_t flags, json_error_t *error) {
1009     lex_t lex;
1010     const char *source;
1011     json_t *result;
1012
1013 #ifdef HAVE_UNISTD_H
1014     if (input == STDIN_FILENO)
1015         source = "<stdin>";
1016     else
1017 #endif
1018         source = "<stream>";
1019
1020     jsonp_error_init(error, source);
1021
1022     if (input < 0) {
1023         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1024         return NULL;
1025     }
1026
1027     if (lex_init(&lex, (get_func)fd_get_func, flags, &input))
1028         return NULL;
1029
1030     result = parse_json(&lex, flags, error);
1031
1032     lex_close(&lex);
1033     return result;
1034 }
1035
1036 json_t *json_load_file(const char *path, size_t flags, json_error_t *error) {
1037     json_t *result;
1038     FILE *fp;
1039
1040     jsonp_error_init(error, path);
1041
1042     if (path == NULL) {
1043         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1044         return NULL;
1045     }
1046
1047     fp = fopen(path, "rb");
1048     if (!fp) {
1049         error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s", path,
1050                   strerror(errno));
1051         return NULL;
1052     }
1053
1054     result = json_loadf(fp, flags, error);
1055
1056     fclose(fp);
1057     return result;
1058 }
1059
1060 #define MAX_BUF_LEN 1024
1061
1062 typedef struct {
1063     char data[MAX_BUF_LEN];
1064     size_t len;
1065     size_t pos;
1066     json_load_callback_t callback;
1067     void *arg;
1068 } callback_data_t;
1069
1070 static int callback_get(void *data) {
1071     char c;
1072     callback_data_t *stream = data;
1073
1074     if (stream->pos >= stream->len) {
1075         stream->pos = 0;
1076         stream->len = stream->callback(stream->data, MAX_BUF_LEN, stream->arg);
1077         if (stream->len == 0 || stream->len == (size_t)-1)
1078             return EOF;
1079     }
1080
1081     c = stream->data[stream->pos];
1082     stream->pos++;
1083     return (unsigned char)c;
1084 }
1085
1086 json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flags,
1087                            json_error_t *error) {
1088     lex_t lex;
1089     json_t *result;
1090
1091     callback_data_t stream_data;
1092
1093     memset(&stream_data, 0, sizeof(stream_data));
1094     stream_data.callback = callback;
1095     stream_data.arg = arg;
1096
1097     jsonp_error_init(error, "<callback>");
1098
1099     if (callback == NULL) {
1100         error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1101         return NULL;
1102     }
1103
1104     if (lex_init(&lex, (get_func)callback_get, flags, &stream_data))
1105         return NULL;
1106
1107     result = parse_json(&lex, flags, error);
1108
1109     lex_close(&lex);
1110     return result;
1111 }