sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
d2b18e6bc22365bcb51fe4246a681569491f3a40
system76-edk2/RedfishPkg/Library/JsonLib/load.c
Nickle Wang d65b183f92 RedfishPkg/RedfishCrtLib: handle floating point number in JSON 
When the value type is defined as number in Redfish schema, floating
point number is allowed. RedfishCrtLib raises assert without handling
this case now. Follow the way in EDK2 to call AsciiStrDecimalToUintnS
and handle the floating point number. Only the integer value is
returned.

Signed-off-by: Nickle Wang <nicklew@nvidia.com>
Cc: Abner Chang <abner.chang@amd.com>
Cc: Igor Kulchytskyy <igork@ami.com>
Cc: Nick Ramirez <nramirez@nvidia.com>
Reviewed-by: Abner Chang <abner.chang@amd.com>
2024-01-15 08:11:22 +00:00

1425 lines
29 KiB
C
Raw Blame History

/*
* Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
*
* Jansson is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent AND MIT
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include "jansson_private.h"
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include "jansson.h"
#include "strbuffer.h"
#include "utf.h"
#define STREAM_STATE_OK 0
#define STREAM_STATE_EOF -1
#define STREAM_STATE_ERROR -2
#define TOKEN_INVALID -1
#define TOKEN_EOF 0
#define TOKEN_STRING 256
#define TOKEN_INTEGER 257
#define TOKEN_REAL 258
#define TOKEN_TRUE 259
#define TOKEN_FALSE 260
#define TOKEN_NULL 261
/* Locale independent versions of isxxx() functions */
#define l_isupper(c) ('A' <= (c) && (c) <= 'Z')
#define l_islower(c) ('a' <= (c) && (c) <= 'z')
#define l_isalpha(c) (l_isupper(c) || l_islower(c))
#define l_isdigit(c) ('0' <= (c) && (c) <= '9')
#define l_isxdigit(c) \
(l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
/* Read one byte from stream, convert to unsigned char, then int, and
return. return EOF on end of file. This corresponds to the
behaviour of fgetc(). */
typedef int (*get_func)(
void *data
);
typedef struct {
get_func get;
void *data;
char buffer[5];
size_t buffer_pos;
int state;
int line;
int column, last_column;
size_t position;
} stream_t;
typedef struct {
stream_t stream;
strbuffer_t saved_text;
size_t flags;
size_t depth;
int token;
union {
struct {
char *val;
size_t len;
} string;
json_int_t integer;
double real;
} value;
} lex_t;
#define stream_to_lex(stream) container_of(stream, lex_t, stream)
/*** error reporting ***/
static void
error_set (
json_error_t *error,
const lex_t *lex,
enum json_error_code code,
const char *msg,
...
)
{
va_list ap;
char msg_text[JSON_ERROR_TEXT_LENGTH];
char msg_with_context[JSON_ERROR_TEXT_LENGTH];
int line = -1, col = -1;
size_t pos = 0;
const char *result = msg_text;
if (!error) {
return;
}
va_start (ap, msg);
vsnprintf (msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
va_end (ap);
if (lex) {
const char *saved_text = strbuffer_value (&lex->saved_text);
line = lex->stream.line;
col = lex->stream.column;
pos = lex->stream.position;
if (saved_text && saved_text[0]) {
if (lex->saved_text.length <= 20) {
snprintf (
msg_with_context,
JSON_ERROR_TEXT_LENGTH,
"%s near '%s'",
msg_text,
saved_text
);
msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
result = msg_with_context;
}
} else {
if (code == json_error_invalid_syntax) {
/* More specific error code for premature end of file. */
code = json_error_premature_end_of_input;
}
if (lex->stream.state == STREAM_STATE_ERROR) {
/* No context for UTF-8 decoding errors */
result = msg_text;
} else {
snprintf (
msg_with_context,
JSON_ERROR_TEXT_LENGTH,
"%s near end of file",
msg_text
);
msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
result = msg_with_context;
}
}
}
jsonp_error_set (error, line, col, pos, code, "%s", result);
}
/*** lexical analyzer ***/
static void
stream_init (
stream_t *stream,
get_func get,
void *data
)
{
stream->get = get;
stream->data = data;
stream->buffer[0] = '\0';
stream->buffer_pos = 0;
stream->state = STREAM_STATE_OK;
stream->line = 1;
stream->column = 0;
stream->position = 0;
}
static int
stream_get (
stream_t *stream,
json_error_t *error
)
{
int c;
if (stream->state != STREAM_STATE_OK) {
return stream->state;
}
if (!stream->buffer[stream->buffer_pos]) {
c = stream->get (stream->data);
if (c == EOF) {
stream->state = STREAM_STATE_EOF;
return STREAM_STATE_EOF;
}
stream->buffer[0] = c;
stream->buffer_pos = 0;
if ((0x80 <= c) && (c <= 0xFF)) {
/* multi-byte UTF-8 sequence */
size_t i, count;
count = utf8_check_first (c);
if (!count) {
goto out;
}
assert (count >= 2);
for (i = 1; i < count; i++) {
stream->buffer[i] = stream->get (stream->data);
}
if (!utf8_check_full (stream->buffer, count, NULL)) {
goto out;
}
stream->buffer[count] = '\0';
} else {
stream->buffer[1] = '\0';
}
}
c = stream->buffer[stream->buffer_pos++];
stream->position++;
if (c == '\n') {
stream->line++;
stream->last_column = stream->column;
stream->column = 0;
} else if (utf8_check_first (c)) {
/* track the Unicode character column, so increment only if
this is the first character of a UTF-8 sequence */
stream->column++;
}
return c;
out:
stream->state = STREAM_STATE_ERROR;
error_set (
error,
stream_to_lex (stream),
json_error_invalid_utf8,
"unable to decode byte 0x%x",
c
);
return STREAM_STATE_ERROR;
}
static void
stream_unget (
stream_t *stream,
int c
)
{
if ((c == STREAM_STATE_EOF) || (c == STREAM_STATE_ERROR)) {
return;
}
stream->position--;
if (c == '\n') {
stream->line--;
stream->column = stream->last_column;
} else if (utf8_check_first (c)) {
stream->column--;
}
assert (stream->buffer_pos > 0);
stream->buffer_pos--;
assert (stream->buffer[stream->buffer_pos] == c);
}
static int
lex_get (
lex_t *lex,
json_error_t *error
)
{
return stream_get (&lex->stream, error);
}
static void
lex_save (
lex_t *lex,
int c
)
{
strbuffer_append_byte (&lex->saved_text, c);
}
static int
lex_get_save (
lex_t *lex,
json_error_t *error
)
{
int c = stream_get (&lex->stream, error);
if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
lex_save (lex, c);
}
return c;
}
static void
lex_unget (
lex_t *lex,
int c
)
{
stream_unget (&lex->stream, c);
}
static void
lex_unget_unsave (
lex_t *lex,
int c
)
{
if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
/* Since we treat warnings as errors, when assertions are turned
* off the "d" variable would be set but never used. Which is
* treated as an error by GCC.
*/
#ifndef NDEBUG
char d;
#endif
stream_unget (&lex->stream, c);
#ifndef NDEBUG
d =
#endif
strbuffer_pop (&lex->saved_text);
assert (c == d);
}
}
static void
lex_save_cached (
lex_t *lex
)
{
while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
lex_save (lex, lex->stream.buffer[lex->stream.buffer_pos]);
lex->stream.buffer_pos++;
lex->stream.position++;
}
}
static void
lex_free_string (
lex_t *lex
)
{
jsonp_free (lex->value.string.val);
lex->value.string.val = NULL;
lex->value.string.len = 0;
}
/* assumes that str points to 'u' plus at least 4 valid hex digits */
static int32_t
decode_unicode_escape (
const char *str
)
{
int i;
int32_t value = 0;
assert (str[0] == 'u');
for (i = 1; i <= 4; i++) {
char c = str[i];
value <<= 4;
if (l_isdigit (c)) {
value += c - '0';
} else if (l_islower (c)) {
value += c - 'a' + 10;
} else if (l_isupper (c)) {
value += c - 'A' + 10;
} else {
return -1;
}
}
return value;
}
static void
lex_scan_string (
lex_t *lex,
json_error_t *error
)
{
int c;
const char *p;
char *t;
int i;
lex->value.string.val = NULL;
lex->token = TOKEN_INVALID;
c = lex_get_save (lex, error);
while (c != '"') {
if (c == STREAM_STATE_ERROR) {
goto out;
} else if (c == STREAM_STATE_EOF) {
error_set (
error,
lex,
json_error_premature_end_of_input,
"premature end of input"
);
goto out;
} else if ((0 <= c) && (c <= 0x1F)) {
/* control character */
lex_unget_unsave (lex, c);
if (c == '\n') {
error_set (error, lex, json_error_invalid_syntax, "unexpected newline");
} else {
error_set (
error,
lex,
json_error_invalid_syntax,
"control character 0x%x",
c
);
}
goto out;
} else if (c == '\\') {
c = lex_get_save (lex, error);
if (c == 'u') {
c = lex_get_save (lex, error);
for (i = 0; i < 4; i++) {
if (!l_isxdigit (c)) {
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid escape"
);
goto out;
}
c = lex_get_save (lex, error);
}
} else if ((c == '"') || (c == '\\') || (c == '/') || (c == 'b') || (c == 'f') ||
(c == 'n') || (c == 'r') || (c == 't'))
{
c = lex_get_save (lex, error);
} else {
error_set (error, lex, json_error_invalid_syntax, "invalid escape");
goto out;
}
} else {
c = lex_get_save (lex, error);
}
}
/* the actual value is at most of the same length as the source
string, because:
- shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
- a single \uXXXX escape (length 6) is converted to at most 3 bytes
- two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
are converted to 4 bytes
*/
t = jsonp_malloc (lex->saved_text.length + 1);
if (!t) {
/* this is not very nice, since TOKEN_INVALID is returned */
goto out;
}
lex->value.string.val = t;
/* + 1 to skip the " */
p = strbuffer_value (&lex->saved_text) + 1;
while (*p != '"') {
if (*p == '\\') {
p++;
if (*p == 'u') {
size_t length;
int32_t value;
value = decode_unicode_escape (p);
if (value < 0) {
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid Unicode escape '%.6s'",
p - 1
);
goto out;
}
p += 5;
if ((0xD800 <= value) && (value <= 0xDBFF)) {
/* surrogate pair */
if ((*p == '\\') && (*(p + 1) == 'u')) {
int32_t value2 = decode_unicode_escape (++p);
if (value2 < 0) {
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid Unicode escape '%.6s'",
p - 1
);
goto out;
}
p += 5;
if ((0xDC00 <= value2) && (value2 <= 0xDFFF)) {
/* valid second surrogate */
value =
((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
} else {
/* invalid second surrogate */
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid Unicode '\\u%04X\\u%04X'",
value,
value2
);
goto out;
}
} else {
/* no second surrogate */
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid Unicode '\\u%04X'",
value
);
goto out;
}
} else if ((0xDC00 <= value) && (value <= 0xDFFF)) {
error_set (
error,
lex,
json_error_invalid_syntax,
"invalid Unicode '\\u%04X'",
value
);
goto out;
}
if (utf8_encode (value, t, &length)) {
assert (0);
}
t += length;
} else {
switch (*p) {
case '"':
case '\\':
case '/':
*t = *p;
break;
case 'b':
*t = '\b';
break;
case 'f':
*t = '\f';
break;
case 'n':
*t = '\n';
break;
case 'r':
*t = '\r';
break;
case 't':
*t = '\t';
break;
default:
assert (0);
}
t++;
p++;
}
} else {
*(t++) = *(p++);
}
}
*t = '\0';
lex->value.string.len = t - lex->value.string.val;
lex->token = TOKEN_STRING;
return;
out:
lex_free_string (lex);
}
#ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
#if JSON_INTEGER_IS_LONG_LONG
#ifdef _MSC_VER /* Microsoft Visual Studio */
#define json_strtoint _strtoi64
#else
#define json_strtoint strtoll
#endif
#else
#define json_strtoint strtol
#endif
#endif
static int
lex_scan_number (
lex_t *lex,
int c,
json_error_t *error
)
{
const char *saved_text;
char *end;
double doubleval;
lex->token = TOKEN_INVALID;
if (c == '-') {
c = lex_get_save (lex, error);
}
if (c == '0') {
c = lex_get_save (lex, error);
if (l_isdigit (c)) {
lex_unget_unsave (lex, c);
goto out;
}
} else if (l_isdigit (c)) {
do {
c = lex_get_save (lex, error);
} while (l_isdigit (c));
} else {
lex_unget_unsave (lex, c);
goto out;
}
if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && (c != '.') && (c != 'E') && (c != 'e')) {
json_int_t intval;
lex_unget_unsave (lex, c);
saved_text = strbuffer_value (&lex->saved_text);
errno = 0;
intval = json_strtoint (saved_text, &end, 10);
if (errno == ERANGE) {
if (intval < 0) {
error_set (
error,
lex,
json_error_numeric_overflow,
"too big negative integer"
);
} else {
error_set (error, lex, json_error_numeric_overflow, "too big integer");
}
goto out;
}
assert (end == saved_text + lex->saved_text.length);
lex->token = TOKEN_INTEGER;
lex->value.integer = intval;
return 0;
}
if (c == '.') {
c = lex_get (lex, error);
if (!l_isdigit (c)) {
lex_unget (lex, c);
goto out;
}
lex_save (lex, c);
do {
c = lex_get_save (lex, error);
} while (l_isdigit (c));
}
if ((c == 'E') || (c == 'e')) {
c = lex_get_save (lex, error);
if ((c == '+') || (c == '-')) {
c = lex_get_save (lex, error);
}
if (!l_isdigit (c)) {
lex_unget_unsave (lex, c);
goto out;
}
do {
c = lex_get_save (lex, error);
} while (l_isdigit (c));
}
lex_unget_unsave (lex, c);
if (jsonp_strtod (&lex->saved_text, &doubleval)) {
error_set (error, lex, json_error_numeric_overflow, "real number overflow");
goto out;
}
lex->token = TOKEN_INTEGER;
lex->value.integer = doubleval;
return 0;
out:
return -1;
}
static int
lex_scan (
lex_t *lex,
json_error_t *error
)
{
int c;
strbuffer_clear (&lex->saved_text);
if (lex->token == TOKEN_STRING) {
lex_free_string (lex);
}
do {
c = lex_get (lex, error);
} while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
if (c == STREAM_STATE_EOF) {
lex->token = TOKEN_EOF;
goto out;
}
if (c == STREAM_STATE_ERROR) {
lex->token = TOKEN_INVALID;
goto out;
}
lex_save (lex, c);
if ((c == '{') || (c == '}') || (c == '[') || (c == ']') || (c == ':') || (c == ',')) {
lex->token = c;
} else if (c == '"') {
lex_scan_string (lex, error);
} else if (l_isdigit (c) || (c == '-')) {
if (lex_scan_number (lex, c, error)) {
goto out;
}
} else if (l_isalpha (c)) {
/* eat up the whole identifier for clearer error messages */
const char *saved_text;
do {
c = lex_get_save (lex, error);
} while (l_isalpha (c));
lex_unget_unsave (lex, c);
saved_text = strbuffer_value (&lex->saved_text);
if (strcmp (saved_text, "true") == 0) {
lex->token = TOKEN_TRUE;
} else if (strcmp (saved_text, "false") == 0) {
lex->token = TOKEN_FALSE;
} else if (strcmp (saved_text, "null") == 0) {
lex->token = TOKEN_NULL;
} else {
lex->token = TOKEN_INVALID;
}
} else {
/* save the rest of the input UTF-8 sequence to get an error
message of valid UTF-8 */
lex_save_cached (lex);
lex->token = TOKEN_INVALID;
}
out:
return lex->token;
}
static char *
lex_steal_string (
lex_t *lex,
size_t *out_len
)
{
char *result = NULL;
if (lex->token == TOKEN_STRING) {
result = lex->value.string.val;
*out_len = lex->value.string.len;
lex->value.string.val = NULL;
lex->value.string.len = 0;
}
return result;
}
static int
lex_init (
lex_t *lex,
get_func get,
size_t flags,
void *data
)
{
stream_init (&lex->stream, get, data);
if (strbuffer_init (&lex->saved_text)) {
return -1;
}
lex->flags = flags;
lex->token = TOKEN_INVALID;
return 0;
}
static void
lex_close (
lex_t *lex
)
{
if (lex->token == TOKEN_STRING) {
lex_free_string (lex);
}
strbuffer_close (&lex->saved_text);
}
/*** parser ***/
static json_t *
parse_value (
lex_t *lex,
size_t flags,
json_error_t *error
);
static json_t *
parse_object (
lex_t *lex,
size_t flags,
json_error_t *error
)
{
json_t *object = json_object ();
if (!object) {
return NULL;
}
lex_scan (lex, error);
if (lex->token == '}') {
return object;
}
while (1) {
char *key;
size_t len;
json_t *value;
if (lex->token != TOKEN_STRING) {
error_set (error, lex, json_error_invalid_syntax, "string or '}' expected");
goto error;
}
key = lex_steal_string (lex, &len);
if (!key) {
return NULL;
}
if (memchr (key, '\0', len)) {
jsonp_free (key);
error_set (
error,
lex,
json_error_null_byte_in_key,
"NUL byte in object key not supported"
);
goto error;
}
if (flags & JSON_REJECT_DUPLICATES) {
if (json_object_get (object, key)) {
jsonp_free (key);
error_set (error, lex, json_error_duplicate_key, "duplicate object key");
goto error;
}
}
lex_scan (lex, error);
if (lex->token != ':') {
jsonp_free (key);
error_set (error, lex, json_error_invalid_syntax, "':' expected");
goto error;
}
lex_scan (lex, error);
value = parse_value (lex, flags, error);
if (!value) {
jsonp_free (key);
goto error;
}
if (json_object_set_new_nocheck (object, key, value)) {
jsonp_free (key);
goto error;
}
jsonp_free (key);
lex_scan (lex, error);
if (lex->token != ',') {
break;
}
lex_scan (lex, error);
}
if (lex->token != '}') {
error_set (error, lex, json_error_invalid_syntax, "'}' expected");
goto error;
}
return object;
error:
json_decref (object);
return NULL;
}
static json_t *
parse_array (
lex_t *lex,
size_t flags,
json_error_t *error
)
{
json_t *array = json_array ();
if (!array) {
return NULL;
}
lex_scan (lex, error);
if (lex->token == ']') {
return array;
}
while (lex->token) {
json_t *elem = parse_value (lex, flags, error);
if (!elem) {
goto error;
}
if (json_array_append_new (array, elem)) {
goto error;
}
lex_scan (lex, error);
if (lex->token != ',') {
break;
}
lex_scan (lex, error);
}
if (lex->token != ']') {
error_set (error, lex, json_error_invalid_syntax, "']' expected");
goto error;
}
return array;
error:
json_decref (array);
return NULL;
}
static json_t *
parse_value (
lex_t *lex,
size_t flags,
json_error_t *error
)
{
json_t *json;
lex->depth++;
if (lex->depth > JSON_PARSER_MAX_DEPTH) {
error_set (error, lex, json_error_stack_overflow, "maximum parsing depth reached");
return NULL;
}
switch (lex->token) {
case TOKEN_STRING:
{
const char *value = lex->value.string.val;
size_t len = lex->value.string.len;
if (!(flags & JSON_ALLOW_NUL)) {
if (memchr (value, '\0', len)) {
error_set (
error,
lex,
json_error_null_character,
"\\u0000 is not allowed without JSON_ALLOW_NUL"
);
return NULL;
}
}
json = jsonp_stringn_nocheck_own (value, len);
lex->value.string.val = NULL;
lex->value.string.len = 0;
break;
}
case TOKEN_INTEGER:
{
json = json_integer (lex->value.integer);
break;
}
case TOKEN_REAL:
{
json = json_real (lex->value.real);
break;
}
case TOKEN_TRUE:
json = json_true ();
break;
case TOKEN_FALSE:
json = json_false ();
break;
case TOKEN_NULL:
json = json_null ();
break;
case '{':
json = parse_object (lex, flags, error);
break;
case '[':
json = parse_array (lex, flags, error);
break;
case TOKEN_INVALID:
error_set (error, lex, json_error_invalid_syntax, "invalid token");
return NULL;
default:
error_set (error, lex, json_error_invalid_syntax, "unexpected token");
return NULL;
}
if (!json) {
return NULL;
}
lex->depth--;
return json;
}
static json_t *
parse_json (
lex_t *lex,
size_t flags,
json_error_t *error
)
{
json_t *result;
lex->depth = 0;
lex_scan (lex, error);
if (!(flags & JSON_DECODE_ANY)) {
if ((lex->token != '[') && (lex->token != '{')) {
error_set (error, lex, json_error_invalid_syntax, "'[' or '{' expected");
return NULL;
}
}
result = parse_value (lex, flags, error);
if (!result) {
return NULL;
}
if (!(flags & JSON_DISABLE_EOF_CHECK)) {
lex_scan (lex, error);
if (lex->token != TOKEN_EOF) {
error_set (
error,
lex,
json_error_end_of_input_expected,
"end of file expected"
);
json_decref (result);
return NULL;
}
}
if (error) {
/* Save the position even though there was no error */
error->position = (int)lex->stream.position;
}
return result;
}
typedef struct {
const char *data;
size_t pos;
} string_data_t;
static int
string_get (
void *data
)
{
char c;
string_data_t *stream = (string_data_t *)data;
c = stream->data[stream->pos];
if (c == '\0') {
return EOF;
} else {
stream->pos++;
return (unsigned char)c;
}
}
json_t *
json_loads (
const char *string,
size_t flags,
json_error_t *error
)
{
lex_t lex;
json_t *result;
string_data_t stream_data;
jsonp_error_init (error, "<string>");
if (string == NULL) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
stream_data.data = string;
stream_data.pos = 0;
if (lex_init (&lex, string_get, flags, (void *)&stream_data)) {
return NULL;
}
result = parse_json (&lex, flags, error);
lex_close (&lex);
return result;
}
typedef struct {
const char *data;
size_t len;
size_t pos;
} buffer_data_t;
static int
buffer_get (
void *data
)
{
char c;
buffer_data_t *stream = data;
if (stream->pos >= stream->len) {
return EOF;
}
c = stream->data[stream->pos];
stream->pos++;
return (unsigned char)c;
}
json_t *
json_loadb (
const char *buffer,
size_t buflen,
size_t flags,
json_error_t *error
)
{
lex_t lex;
json_t *result;
buffer_data_t stream_data;
jsonp_error_init (error, "<buffer>");
if (buffer == NULL) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
stream_data.data = buffer;
stream_data.pos = 0;
stream_data.len = buflen;
if (lex_init (&lex, buffer_get, flags, (void *)&stream_data)) {
return NULL;
}
result = parse_json (&lex, flags, error);
lex_close (&lex);
return result;
}
json_t *
json_loadf (
FILE *input,
size_t flags,
json_error_t *error
)
{
lex_t lex;
const char *source;
json_t *result;
#ifdef HAVE_UNISTD_H
if (input == stdin) {
source = "<stdin>";
} else
#endif
source = "<stream>";
jsonp_error_init (error, source);
if (input == NULL) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
if (lex_init (&lex, (get_func)fgetc, flags, input)) {
return NULL;
}
result = parse_json (&lex, flags, error);
lex_close (&lex);
return result;
}
static int
fd_get_func (
int *fd
)
{
#ifdef HAVE_UNISTD_H
uint8_t c;
if (read (*fd, &c, 1) == 1) {
return c;
}
#endif
return EOF;
}
json_t *
json_loadfd (
int input,
size_t flags,
json_error_t *error
)
{
lex_t lex;
const char *source;
json_t *result;
#ifdef HAVE_UNISTD_H
if (input == STDIN_FILENO) {
source = "<stdin>";
} else
#endif
source = "<stream>";
jsonp_error_init (error, source);
if (input < 0) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
if (lex_init (&lex, (get_func)fd_get_func, flags, &input)) {
return NULL;
}
result = parse_json (&lex, flags, error);
lex_close (&lex);
return result;
}
json_t *
json_load_file (
const char *path,
size_t flags,
json_error_t *error
)
{
json_t *result;
FILE *fp;
jsonp_error_init (error, path);
if (path == NULL) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
fp = fopen (path, "rb");
if (!fp) {
error_set (
error,
NULL,
json_error_cannot_open_file,
"unable to open %s: %s",
path,
strerror (errno)
);
return NULL;
}
result = json_loadf (fp, flags, error);
fclose (fp);
return result;
}
#define MAX_BUF_LEN 1024
typedef struct {
char data[MAX_BUF_LEN];
size_t len;
size_t pos;
json_load_callback_t callback;
void *arg;
} callback_data_t;
static int
callback_get (
void *data
)
{
char c;
callback_data_t *stream = data;
if (stream->pos >= stream->len) {
stream->pos = 0;
stream->len = stream->callback (stream->data, MAX_BUF_LEN, stream->arg);
if ((stream->len == 0) || (stream->len == (size_t)-1)) {
return EOF;
}
}
c = stream->data[stream->pos];
stream->pos++;
return (unsigned char)c;
}
json_t *
json_load_callback (
json_load_callback_t callback,
void *arg,
size_t flags,
json_error_t *error
)
{
lex_t lex;
json_t *result;
callback_data_t stream_data;
memset (&stream_data, 0, sizeof (stream_data));
stream_data.callback = callback;
stream_data.arg = arg;
jsonp_error_init (error, "<callback>");
if (callback == NULL) {
error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
return NULL;
}
if (lex_init (&lex, (get_func)callback_get, flags, &stream_data)) {
return NULL;
}
result = parse_json (&lex, flags, error);
lex_close (&lex);
return result;
}
Reference in New Issue View Git Blame Copy Permalink