mpv/misc/json.c

357 lines
11 KiB
C
Raw Normal View History

2014-10-16 09:46:29 +00:00
/*
* This file is part of mpv.
*
Relicense some non-MPlayer source files to LGPL 2.1 or later This covers source files which were added in mplayer2 and mpv times only, and where all code is covered by LGPL relicensing agreements. There are probably more files to which this applies, but I'm being conservative here. A file named ao_sdl.c exists in MPlayer too, but the mpv one is a complete rewrite, and was added some time after the original ao_sdl.c was removed. The same applies to vo_sdl.c, for which the SDL2 API is radically different in addition (MPlayer supports SDL 1.2 only). common.c contains only code written by me. But common.h is a strange case: although it originally was named mp_common.h and exists in MPlayer too, by now it contains only definitions written by uau and me. The exceptions are the CONTROL_ defines - thus not changing the license of common.h yet. codec_tags.c contained once large tables generated from MPlayer's codecs.conf, but all of these tables were removed. From demux_playlist.c I'm removing a code fragment from someone who was not asked; this probably could be done later (see commit 15dccc37). misc.c is a bit complicated to reason about (it was split off mplayer.c and thus contains random functions out of this file), but actually all functions have been added post-MPlayer. Except get_relative_time(), which was written by uau, but looks similar to 3 different versions of something similar in each of the Unix/win32/OSX timer source files. I'm not sure what that means in regards to copyright, so I've just moved it into another still-GPL source file for now. screenshot.c once had some minor parts of MPlayer's vf_screenshot.c, but they're all gone.
2016-01-19 17:36:06 +00:00
* 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.
2014-10-16 09:46:29 +00:00
*
* 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
Relicense some non-MPlayer source files to LGPL 2.1 or later This covers source files which were added in mplayer2 and mpv times only, and where all code is covered by LGPL relicensing agreements. There are probably more files to which this applies, but I'm being conservative here. A file named ao_sdl.c exists in MPlayer too, but the mpv one is a complete rewrite, and was added some time after the original ao_sdl.c was removed. The same applies to vo_sdl.c, for which the SDL2 API is radically different in addition (MPlayer supports SDL 1.2 only). common.c contains only code written by me. But common.h is a strange case: although it originally was named mp_common.h and exists in MPlayer too, by now it contains only definitions written by uau and me. The exceptions are the CONTROL_ defines - thus not changing the license of common.h yet. codec_tags.c contained once large tables generated from MPlayer's codecs.conf, but all of these tables were removed. From demux_playlist.c I'm removing a code fragment from someone who was not asked; this probably could be done later (see commit 15dccc37). misc.c is a bit complicated to reason about (it was split off mplayer.c and thus contains random functions out of this file), but actually all functions have been added post-MPlayer. Except get_relative_time(), which was written by uau, but looks similar to 3 different versions of something similar in each of the Unix/win32/OSX timer source files. I'm not sure what that means in regards to copyright, so I've just moved it into another still-GPL source file for now. screenshot.c once had some minor parts of MPlayer's vf_screenshot.c, but they're all gone.
2016-01-19 17:36:06 +00:00
* GNU Lesser General Public License for more details.
2014-10-16 09:46:29 +00:00
*
Relicense some non-MPlayer source files to LGPL 2.1 or later This covers source files which were added in mplayer2 and mpv times only, and where all code is covered by LGPL relicensing agreements. There are probably more files to which this applies, but I'm being conservative here. A file named ao_sdl.c exists in MPlayer too, but the mpv one is a complete rewrite, and was added some time after the original ao_sdl.c was removed. The same applies to vo_sdl.c, for which the SDL2 API is radically different in addition (MPlayer supports SDL 1.2 only). common.c contains only code written by me. But common.h is a strange case: although it originally was named mp_common.h and exists in MPlayer too, by now it contains only definitions written by uau and me. The exceptions are the CONTROL_ defines - thus not changing the license of common.h yet. codec_tags.c contained once large tables generated from MPlayer's codecs.conf, but all of these tables were removed. From demux_playlist.c I'm removing a code fragment from someone who was not asked; this probably could be done later (see commit 15dccc37). misc.c is a bit complicated to reason about (it was split off mplayer.c and thus contains random functions out of this file), but actually all functions have been added post-MPlayer. Except get_relative_time(), which was written by uau, but looks similar to 3 different versions of something similar in each of the Unix/win32/OSX timer source files. I'm not sure what that means in regards to copyright, so I've just moved it into another still-GPL source file for now. screenshot.c once had some minor parts of MPlayer's vf_screenshot.c, but they're all gone.
2016-01-19 17:36:06 +00:00
* You should have received a copy of the GNU Lesser General Public
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
2014-10-16 09:46:29 +00:00
*/
/* 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)
2014-10-16 09:46:29 +00:00
*
* Also see: http://tools.ietf.org/html/rfc8259
2014-10-16 09:46:29 +00:00
*
* 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"
2014-10-16 09:46:29 +00:00
#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;
}
2014-10-16 09:46:29 +00:00
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++;
2014-10-16 09:46:29 +00:00
}
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;
2014-10-16 09:46:29 +00:00
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)
2014-10-16 09:46:29 +00:00
return -1; // key is not a string
eat_ws(src);
// non-standard extension: allow "=" instead of ":"
if (!eat_c(src, ':') && !eat_c(src, '='))
2014-10-16 09:46:29 +00:00
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)
2014-10-16 09:46:29 +00:00
{
APPEND(b, "\"");
while (1) {
unsigned char *cur = str;
while (cur[0] >= 32 && cur[0] != '"' && cur[0] != '\\')
2014-10-16 09:46:29 +00:00
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]);
}
2014-10-16 09:46:29 +00:00
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)
2014-10-16 09:46:29 +00:00
{
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);
2014-10-16 09:46:29 +00:00
return 0;
}
2014-10-16 09:46:29 +00:00
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;
2014-10-16 09:46:29 +00:00
for (int n = 0; n < list->num; n++) {
if (n)
APPEND(b, ",");
add_indent(b, next_indent);
2014-10-16 09:46:29 +00:00
if (is_obj) {
write_json_str(b, list->keys[n]);
APPEND(b, ":");
}
json_append(b, &list->values[n], next_indent);
2014-10-16 09:46:29 +00:00
}
add_indent(b, indent);
2014-10-16 09:46:29 +00:00
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;
}
2014-10-16 09:46:29 +00:00
/* 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);
2014-10-16 09:46:29 +00:00
}