/* * JSON Parser * * Copyright IBM, Corp. 2009 * * Authors: * Anthony Liguori <aliguori@us.ibm.com> * * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. * See the COPYING.LIB file in the top-level directory. * */ #include <stdarg.h> #include "qemu-common.h" #include "qapi/qmp/qstring.h" #include "qapi/qmp/qint.h" #include "qapi/qmp/qdict.h" #include "qapi/qmp/qlist.h" #include "qapi/qmp/qfloat.h" #include "qapi/qmp/qbool.h" #include "qapi/qmp/json-parser.h" #include "qapi/qmp/json-lexer.h" #include "qapi/qmp/qerror.h" typedef struct JSONParserContext { Error *err; struct { QObject **buf; size_t pos; size_t count; } tokens; } JSONParserContext; #define BUG_ON(cond) assert(!(cond)) /** * TODO * * 0) make errors meaningful again * 1) add geometry information to tokens * 3) should we return a parsed size? * 4) deal with premature EOI */ static QObject *parse_value(JSONParserContext *ctxt, va_list *ap); /** * Token manipulators * * tokens are dictionaries that contain a type, a string value, and geometry information * about a token identified by the lexer. These are routines that make working with * these objects a bit easier. */ static const char *token_get_value(QObject *obj) { return qdict_get_str(qobject_to_qdict(obj), "token"); } static JSONTokenType token_get_type(QObject *obj) { return qdict_get_int(qobject_to_qdict(obj), "type"); } static int token_is_operator(QObject *obj, char op) { const char *val; if (token_get_type(obj) != JSON_OPERATOR) { return 0; } val = token_get_value(obj); return (val[0] == op) && (val[1] == 0); } static int token_is_keyword(QObject *obj, const char *value) { if (token_get_type(obj) != JSON_KEYWORD) { return 0; } return strcmp(token_get_value(obj), value) == 0; } static int token_is_escape(QObject *obj, const char *value) { if (token_get_type(obj) != JSON_ESCAPE) { return 0; } return (strcmp(token_get_value(obj), value) == 0); } /** * Error handler */ static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt, QObject *token, const char *msg, ...) { va_list ap; char message[1024]; va_start(ap, msg); vsnprintf(message, sizeof(message), msg, ap); va_end(ap); if (ctxt->err) { error_free(ctxt->err); ctxt->err = NULL; } error_setg(&ctxt->err, "JSON parse error, %s", message); } /** * String helpers * * These helpers are used to unescape strings. */ static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length) { if (wchar <= 0x007F) { BUG_ON(buffer_length < 2); buffer[0] = wchar & 0x7F; buffer[1] = 0; } else if (wchar <= 0x07FF) { BUG_ON(buffer_length < 3); buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F); buffer[1] = 0x80 | (wchar & 0x3F); buffer[2] = 0; } else { BUG_ON(buffer_length < 4); buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F); buffer[1] = 0x80 | ((wchar >> 6) & 0x3F); buffer[2] = 0x80 | (wchar & 0x3F); buffer[3] = 0; } } static int hex2decimal(char ch) { if (ch >= '0' && ch <= '9') { return (ch - '0'); } else if (ch >= 'a' && ch <= 'f') { return 10 + (ch - 'a'); } else if (ch >= 'A' && ch <= 'F') { return 10 + (ch - 'A'); } return -1; } /** * parse_string(): Parse a json string and return a QObject * * string * "" * " chars " * chars * char * char chars * char * any-Unicode-character- * except-"-or-\-or- * control-character * \" * \\ * \/ * \b * \f * \n * \r * \t * \u four-hex-digits */ static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token) { const char *ptr = token_get_value(token); QString *str; int double_quote = 1; if (*ptr == '"') { double_quote = 1; } else { double_quote = 0; } ptr++; str = qstring_new(); while (*ptr && ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) { if (*ptr == '\\') { ptr++; switch (*ptr) { case '"': qstring_append(str, "\""); ptr++; break; case '\'': qstring_append(str, "'"); ptr++; break; case '\\': qstring_append(str, "\\"); ptr++; break; case '/': qstring_append(str, "/"); ptr++; break; case 'b': qstring_append(str, "\b"); ptr++; break; case 'f': qstring_append(str, "\f"); ptr++; break; case 'n': qstring_append(str, "\n"); ptr++; break; case 'r': qstring_append(str, "\r"); ptr++; break; case 't': qstring_append(str, "\t"); ptr++; break; case 'u': { uint16_t unicode_char = 0; char utf8_char[4]; int i = 0; ptr++; for (i = 0; i < 4; i++) { if (qemu_isxdigit(*ptr)) { unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4); } else { parse_error(ctxt, token, "invalid hex escape sequence in string"); goto out; } ptr++; } wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char)); qstring_append(str, utf8_char); } break; default: parse_error(ctxt, token, "invalid escape sequence in string"); goto out; } } else { char dummy[2]; dummy[0] = *ptr++; dummy[1] = 0; qstring_append(str, dummy); } } return str; out: QDECREF(str); return NULL; } static QObject *parser_context_pop_token(JSONParserContext *ctxt) { QObject *token; g_assert(ctxt->tokens.pos < ctxt->tokens.count); token = ctxt->tokens.buf[ctxt->tokens.pos]; ctxt->tokens.pos++; return token; } /* Note: parser_context_{peek|pop}_token do not increment the * token object's refcount. In both cases the references will continue * to be tracked and cleaned up in parser_context_free(), so do not * attempt to free the token object. */ static QObject *parser_context_peek_token(JSONParserContext *ctxt) { QObject *token; g_assert(ctxt->tokens.pos < ctxt->tokens.count); token = ctxt->tokens.buf[ctxt->tokens.pos]; return token; } static JSONParserContext parser_context_save(JSONParserContext *ctxt) { JSONParserContext saved_ctxt = {0}; saved_ctxt.tokens.pos = ctxt->tokens.pos; saved_ctxt.tokens.count = ctxt->tokens.count; saved_ctxt.tokens.buf = ctxt->tokens.buf; return saved_ctxt; } static void parser_context_restore(JSONParserContext *ctxt, JSONParserContext saved_ctxt) { ctxt->tokens.pos = saved_ctxt.tokens.pos; ctxt->tokens.count = saved_ctxt.tokens.count; ctxt->tokens.buf = saved_ctxt.tokens.buf; } static void tokens_append_from_iter(QObject *obj, void *opaque) { JSONParserContext *ctxt = opaque; g_assert(ctxt->tokens.pos < ctxt->tokens.count); ctxt->tokens.buf[ctxt->tokens.pos++] = obj; qobject_incref(obj); } static JSONParserContext *parser_context_new(QList *tokens) { JSONParserContext *ctxt; size_t count; if (!tokens) { return NULL; } count = qlist_size(tokens); if (count == 0) { return NULL; } ctxt = g_malloc0(sizeof(JSONParserContext)); ctxt->tokens.pos = 0; ctxt->tokens.count = count; ctxt->tokens.buf = g_malloc(count * sizeof(QObject *)); qlist_iter(tokens, tokens_append_from_iter, ctxt); ctxt->tokens.pos = 0; return ctxt; } /* to support error propagation, ctxt->err must be freed separately */ static void parser_context_free(JSONParserContext *ctxt) { int i; if (ctxt) { for (i = 0; i < ctxt->tokens.count; i++) { qobject_decref(ctxt->tokens.buf[i]); } g_free(ctxt->tokens.buf); g_free(ctxt); } } /** * Parsing rules */ static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap) { QObject *key = NULL, *token = NULL, *value, *peek; JSONParserContext saved_ctxt = parser_context_save(ctxt); peek = parser_context_peek_token(ctxt); if (peek == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } key = parse_value(ctxt, ap); if (!key || qobject_type(key) != QTYPE_QSTRING) { parse_error(ctxt, peek, "key is not a string in object"); goto out; } token = parser_context_pop_token(ctxt); if (token == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } if (!token_is_operator(token, ':')) { parse_error(ctxt, token, "missing : in object pair"); goto out; } value = parse_value(ctxt, ap); if (value == NULL) { parse_error(ctxt, token, "Missing value in dict"); goto out; } qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value); qobject_decref(key); return 0; out: parser_context_restore(ctxt, saved_ctxt); qobject_decref(key); return -1; } static QObject *parse_object(JSONParserContext *ctxt, va_list *ap) { QDict *dict = NULL; QObject *token, *peek; JSONParserContext saved_ctxt = parser_context_save(ctxt); token = parser_context_pop_token(ctxt); if (token == NULL) { goto out; } if (!token_is_operator(token, '{')) { goto out; } dict = qdict_new(); peek = parser_context_peek_token(ctxt); if (peek == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } if (!token_is_operator(peek, '}')) { if (parse_pair(ctxt, dict, ap) == -1) { goto out; } token = parser_context_pop_token(ctxt); if (token == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } while (!token_is_operator(token, '}')) { if (!token_is_operator(token, ',')) { parse_error(ctxt, token, "expected separator in dict"); goto out; } if (parse_pair(ctxt, dict, ap) == -1) { goto out; } token = parser_context_pop_token(ctxt); if (token == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } } } else { (void)parser_context_pop_token(ctxt); } return QOBJECT(dict); out: parser_context_restore(ctxt, saved_ctxt); QDECREF(dict); return NULL; } static QObject *parse_array(JSONParserContext *ctxt, va_list *ap) { QList *list = NULL; QObject *token, *peek; JSONParserContext saved_ctxt = parser_context_save(ctxt); token = parser_context_pop_token(ctxt); if (token == NULL) { goto out; } if (!token_is_operator(token, '[')) { goto out; } list = qlist_new(); peek = parser_context_peek_token(ctxt); if (peek == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } if (!token_is_operator(peek, ']')) { QObject *obj; obj = parse_value(ctxt, ap); if (obj == NULL) { parse_error(ctxt, token, "expecting value"); goto out; } qlist_append_obj(list, obj); token = parser_context_pop_token(ctxt); if (token == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } while (!token_is_operator(token, ']')) { if (!token_is_operator(token, ',')) { parse_error(ctxt, token, "expected separator in list"); goto out; } obj = parse_value(ctxt, ap); if (obj == NULL) { parse_error(ctxt, token, "expecting value"); goto out; } qlist_append_obj(list, obj); token = parser_context_pop_token(ctxt); if (token == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } } } else { (void)parser_context_pop_token(ctxt); } return QOBJECT(list); out: parser_context_restore(ctxt, saved_ctxt); QDECREF(list); return NULL; } static QObject *parse_keyword(JSONParserContext *ctxt) { QObject *token, *ret; JSONParserContext saved_ctxt = parser_context_save(ctxt); token = parser_context_pop_token(ctxt); if (token == NULL) { goto out; } if (token_get_type(token) != JSON_KEYWORD) { goto out; } if (token_is_keyword(token, "true")) { ret = QOBJECT(qbool_from_int(true)); } else if (token_is_keyword(token, "false")) { ret = QOBJECT(qbool_from_int(false)); } else { parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token)); goto out; } return ret; out: parser_context_restore(ctxt, saved_ctxt); return NULL; } static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap) { QObject *token = NULL, *obj; JSONParserContext saved_ctxt = parser_context_save(ctxt); if (ap == NULL) { goto out; } token = parser_context_pop_token(ctxt); if (token == NULL) { goto out; } if (token_is_escape(token, "%p")) { obj = va_arg(*ap, QObject *); } else if (token_is_escape(token, "%i")) { obj = QOBJECT(qbool_from_int(va_arg(*ap, int))); } else if (token_is_escape(token, "%d")) { obj = QOBJECT(qint_from_int(va_arg(*ap, int))); } else if (token_is_escape(token, "%ld")) { obj = QOBJECT(qint_from_int(va_arg(*ap, long))); } else if (token_is_escape(token, "%lld") || token_is_escape(token, "%I64d")) { obj = QOBJECT(qint_from_int(va_arg(*ap, long long))); } else if (token_is_escape(token, "%s")) { obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *))); } else if (token_is_escape(token, "%f")) { obj = QOBJECT(qfloat_from_double(va_arg(*ap, double))); } else { goto out; } return obj; out: parser_context_restore(ctxt, saved_ctxt); return NULL; } static QObject *parse_literal(JSONParserContext *ctxt) { QObject *token, *obj; JSONParserContext saved_ctxt = parser_context_save(ctxt); token = parser_context_pop_token(ctxt); if (token == NULL) { goto out; } switch (token_get_type(token)) { case JSON_STRING: obj = QOBJECT(qstring_from_escaped_str(ctxt, token)); break; case JSON_INTEGER: { /* A possibility exists that this is a whole-valued float where the * fractional part was left out due to being 0 (.0). It's not a big * deal to treat these as ints in the parser, so long as users of the * resulting QObject know to expect a QInt in place of a QFloat in * cases like these. * * However, in some cases these values will overflow/underflow a * QInt/int64 container, thus we should assume these are to be handled * as QFloats/doubles rather than silently changing their values. * * strtoll() indicates these instances by setting errno to ERANGE */ int64_t value; errno = 0; /* strtoll doesn't set errno on success */ value = strtoll(token_get_value(token), NULL, 10); if (errno != ERANGE) { obj = QOBJECT(qint_from_int(value)); break; } /* fall through to JSON_FLOAT */ } case JSON_FLOAT: /* FIXME dependent on locale */ obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL))); break; default: goto out; } return obj; out: parser_context_restore(ctxt, saved_ctxt); return NULL; } static QObject *parse_value(JSONParserContext *ctxt, va_list *ap) { QObject *obj; obj = parse_object(ctxt, ap); if (obj == NULL) { obj = parse_array(ctxt, ap); } if (obj == NULL) { obj = parse_escape(ctxt, ap); } if (obj == NULL) { obj = parse_keyword(ctxt); } if (obj == NULL) { obj = parse_literal(ctxt); } return obj; } QObject *json_parser_parse(QList *tokens, va_list *ap) { return json_parser_parse_err(tokens, ap, NULL); } QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp) { JSONParserContext *ctxt = parser_context_new(tokens); QObject *result; if (!ctxt) { return NULL; } result = parse_value(ctxt, ap); error_propagate(errp, ctxt->err); parser_context_free(ctxt); return result; }