mpv/misc/json.c

357 lines
11 KiB
C

/*
* This file is part of mpv.
*
* mpv is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* mpv is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
*/
/* JSON parser:
*
* Unlike standard JSON, \u escapes don't allow you to specify UTF-16 surrogate
* pairs. There may be some differences how numbers are parsed (this parser
* doesn't verify what's passed to strtod(), and also prefers parsing numbers
* as integers with stroll() if possible).
*
* It has some non-standard extensions which shouldn't conflict with JSON:
* - a list or object item can have a trailing ","
* - object syntax accepts "=" in addition of ":"
* - object keys can be unquoted, if they start with a character in [A-Za-z_]
* and contain only characters in [A-Za-z0-9_]
* - byte escapes with "\xAB" are allowed (with AB being a 2 digit hex number)
*
* Also see: http://tools.ietf.org/html/rfc8259
*
* JSON writer:
*
* Doesn't insert whitespace. It's literally a waste of space.
*
* Can output invalid UTF-8, if input is invalid UTF-8. Consumers are supposed
* to deal with somehow: either by using byte-strings for JSON, or by running
* a "fixup" pass on the input data. The latter could for example change
* invalid UTF-8 sequences to replacement characters.
*/
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <inttypes.h>
#include <assert.h>
#include "common/common.h"
#include "misc/bstr.h"
#include "misc/ctype.h"
#include "json.h"
static bool eat_c(char **s, char c)
{
if (**s == c) {
*s += 1;
return true;
}
return false;
}
static void eat_ws(char **src)
{
while (1) {
char c = **src;
if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
return;
*src += 1;
}
}
void json_skip_whitespace(char **src)
{
eat_ws(src);
}
static int read_id(void *ta_parent, struct mpv_node *dst, char **src)
{
char *start = *src;
if (!mp_isalpha(**src) && **src != '_')
return -1;
while (mp_isalnum(**src) || **src == '_')
*src += 1;
if (**src == ' ') {
**src = '\0'; // we're allowed to mutate it => can avoid the strndup
*src += 1;
} else {
start = talloc_strndup(ta_parent, start, *src - start);
}
dst->format = MPV_FORMAT_STRING;
dst->u.string = start;
return 0;
}
static int read_str(void *ta_parent, struct mpv_node *dst, char **src)
{
if (!eat_c(src, '"'))
return -1; // not a string
char *str = *src;
char *cur = str;
bool has_escapes = false;
while (cur[0] && cur[0] != '"') {
if (cur[0] == '\\') {
has_escapes = true;
// skip >\"< and >\\< (latter to handle >\\"< correctly)
if (cur[1] == '"' || cur[1] == '\\')
cur++;
}
cur++;
}
if (cur[0] != '"')
return -1; // invalid termination
// Mutate input string so we have a null-terminated string to the literal.
// This is a stupid micro-optimization, so we can avoid allocation.
cur[0] = '\0';
*src = cur + 1;
if (has_escapes) {
bstr unescaped = {0};
bstr r = bstr0(str);
if (!mp_append_escaped_string(ta_parent, &unescaped, &r))
return -1; // broken escapes
str = unescaped.start; // the function guarantees null-termination
}
dst->format = MPV_FORMAT_STRING;
dst->u.string = str;
return 0;
}
static int read_sub(void *ta_parent, struct mpv_node *dst, char **src,
int max_depth)
{
bool is_arr = eat_c(src, '[');
bool is_obj = !is_arr && eat_c(src, '{');
if (!is_arr && !is_obj)
return -1; // not an array or object
char term = is_obj ? '}' : ']';
struct mpv_node_list *list = talloc_zero(ta_parent, struct mpv_node_list);
while (1) {
eat_ws(src);
if (eat_c(src, term))
break;
if (list->num > 0 && !eat_c(src, ','))
return -1; // missing ','
eat_ws(src);
// non-standard extension: allow a trailing ","
if (eat_c(src, term))
break;
if (is_obj) {
struct mpv_node keynode;
// non-standard extension: allow unquoted strings as keys
if (read_id(list, &keynode, src) < 0 &&
read_str(list, &keynode, src) < 0)
return -1; // key is not a string
eat_ws(src);
// non-standard extension: allow "=" instead of ":"
if (!eat_c(src, ':') && !eat_c(src, '='))
return -1; // ':' missing
eat_ws(src);
MP_TARRAY_GROW(list, list->keys, list->num);
list->keys[list->num] = keynode.u.string;
}
MP_TARRAY_GROW(list, list->values, list->num);
if (json_parse(ta_parent, &list->values[list->num], src, max_depth) < 0)
return -1;
list->num++;
}
dst->format = is_obj ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NODE_ARRAY;
dst->u.list = list;
return 0;
}
/* Parse the string in *src as JSON, and write the result into *dst.
* max_depth limits the recursion and JSON tree depth.
* Warning: this overwrites the input string (what *src points to)!
* Returns:
* 0: success, *dst is valid, *src points to the end (the caller must check
* whether *src really terminates)
* -1: failure, *dst is invalid, there may be dead allocs under ta_parent
* (ta_free_children(ta_parent) is the only way to free them)
* The input string can be mutated in both cases. *dst might contain string
* elements, which point into the (mutated) input string.
*/
int json_parse(void *ta_parent, struct mpv_node *dst, char **src, int max_depth)
{
max_depth -= 1;
if (max_depth < 0)
return -1;
eat_ws(src);
char c = **src;
if (!c)
return -1; // early EOF
if (c == 'n' && strncmp(*src, "null", 4) == 0) {
*src += 4;
dst->format = MPV_FORMAT_NONE;
return 0;
} else if (c == 't' && strncmp(*src, "true", 4) == 0) {
*src += 4;
dst->format = MPV_FORMAT_FLAG;
dst->u.flag = 1;
return 0;
} else if (c == 'f' && strncmp(*src, "false", 5) == 0) {
*src += 5;
dst->format = MPV_FORMAT_FLAG;
dst->u.flag = 0;
return 0;
} else if (c == '"') {
return read_str(ta_parent, dst, src);
} else if (c == '[' || c == '{') {
return read_sub(ta_parent, dst, src, max_depth);
} else if (c == '-' || (c >= '0' && c <= '9')) {
// The number could be either a float or an int. JSON doesn't make a
// difference, but the client API does.
char *nsrci = *src, *nsrcf = *src;
errno = 0;
long long int numi = strtoll(*src, &nsrci, 0);
if (errno)
nsrci = *src;
errno = 0;
double numf = strtod(*src, &nsrcf);
if (errno)
nsrcf = *src;
if (nsrci >= nsrcf) {
*src = nsrci;
dst->format = MPV_FORMAT_INT64; // long long is usually 64 bits
dst->u.int64 = numi;
return 0;
}
if (nsrcf > *src && isfinite(numf)) {
*src = nsrcf;
dst->format = MPV_FORMAT_DOUBLE;
dst->u.double_ = numf;
return 0;
}
return -1;
}
return -1; // character doesn't start a valid token
}
#define APPEND(b, s) bstr_xappend(NULL, (b), bstr0(s))
static const char special_escape[] = {
['\b'] = 'b',
['\f'] = 'f',
['\n'] = 'n',
['\r'] = 'r',
['\t'] = 't',
};
static void write_json_str(bstr *b, unsigned char *str)
{
APPEND(b, "\"");
while (1) {
unsigned char *cur = str;
while (cur[0] >= 32 && cur[0] != '"' && cur[0] != '\\')
cur++;
if (!cur[0])
break;
bstr_xappend(NULL, b, (bstr){str, cur - str});
if (cur[0] == '\"') {
bstr_xappend(NULL, b, (bstr){"\\\"", 2});
} else if (cur[0] == '\\') {
bstr_xappend(NULL, b, (bstr){"\\\\", 2});
} else if (cur[0] < sizeof(special_escape) && special_escape[cur[0]]) {
bstr_xappend_asprintf(NULL, b, "\\%c", special_escape[cur[0]]);
} else {
bstr_xappend_asprintf(NULL, b, "\\u%04x", (unsigned char)cur[0]);
}
str = cur + 1;
}
APPEND(b, str);
APPEND(b, "\"");
}
static void add_indent(bstr *b, int indent)
{
if (indent < 0)
return;
bstr_xappend(NULL, b, bstr0("\n"));
for (int n = 0; n < indent; n++)
bstr_xappend(NULL, b, bstr0(" "));
}
static int json_append(bstr *b, const struct mpv_node *src, int indent)
{
switch (src->format) {
case MPV_FORMAT_NONE:
APPEND(b, "null");
return 0;
case MPV_FORMAT_FLAG:
APPEND(b, src->u.flag ? "true" : "false");
return 0;
case MPV_FORMAT_INT64:
bstr_xappend_asprintf(NULL, b, "%"PRId64, src->u.int64);
return 0;
case MPV_FORMAT_DOUBLE: {
const char *px = isfinite(src->u.double_) ? "" : "\"";
bstr_xappend_asprintf(NULL, b, "%s%f%s", px, src->u.double_, px);
return 0;
}
case MPV_FORMAT_STRING:
write_json_str(b, src->u.string);
return 0;
case MPV_FORMAT_NODE_ARRAY:
case MPV_FORMAT_NODE_MAP: {
struct mpv_node_list *list = src->u.list;
bool is_obj = src->format == MPV_FORMAT_NODE_MAP;
APPEND(b, is_obj ? "{" : "[");
int next_indent = indent >= 0 ? indent + 1 : -1;
for (int n = 0; n < list->num; n++) {
if (n)
APPEND(b, ",");
add_indent(b, next_indent);
if (is_obj) {
write_json_str(b, list->keys[n]);
APPEND(b, ":");
}
json_append(b, &list->values[n], next_indent);
}
add_indent(b, indent);
APPEND(b, is_obj ? "}" : "]");
return 0;
}
}
return -1; // unknown format
}
static int json_append_str(char **dst, struct mpv_node *src, int indent)
{
bstr buffer = bstr0(*dst);
int r = json_append(&buffer, src, indent);
*dst = buffer.start;
return r;
}
/* Write the contents of *src as JSON, and append the JSON string to *dst.
* This will use strlen() to determine the start offset, and ta_get_size()
* and ta_realloc() to extend the memory allocation of *dst.
* Returns: 0 on success, <0 on failure.
*/
int json_write(char **dst, struct mpv_node *src)
{
return json_append_str(dst, src, -1);
}
// Same as json_write(), but add whitespace to make it readable.
int json_write_pretty(char **dst, struct mpv_node *src)
{
return json_append_str(dst, src, 0);
}