5e2dafeb19
This allows a JSON_ERROR state to be passed to the streamer to force a flush of the current tokens and pass a NULL token list to the parser rather that have it churn on bad data. (Alternatively we could just not pass it to the parser at all, but it may be useful to push there errors up the stack. NULL token lists are not currently handled by the parser, the next patch will address that) Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com> Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
123 lines
3.2 KiB
C
123 lines
3.2 KiB
C
/*
|
|
* JSON streaming support
|
|
*
|
|
* 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 "qlist.h"
|
|
#include "qint.h"
|
|
#include "qdict.h"
|
|
#include "qemu-common.h"
|
|
#include "json-lexer.h"
|
|
#include "json-streamer.h"
|
|
|
|
#define MAX_TOKEN_SIZE (64ULL << 20)
|
|
#define MAX_NESTING (1ULL << 10)
|
|
|
|
static void json_message_process_token(JSONLexer *lexer, QString *token, JSONTokenType type, int x, int y)
|
|
{
|
|
JSONMessageParser *parser = container_of(lexer, JSONMessageParser, lexer);
|
|
QDict *dict;
|
|
|
|
if (type == JSON_OPERATOR) {
|
|
switch (qstring_get_str(token)[0]) {
|
|
case '{':
|
|
parser->brace_count++;
|
|
break;
|
|
case '}':
|
|
parser->brace_count--;
|
|
break;
|
|
case '[':
|
|
parser->bracket_count++;
|
|
break;
|
|
case ']':
|
|
parser->bracket_count--;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
dict = qdict_new();
|
|
qdict_put(dict, "type", qint_from_int(type));
|
|
QINCREF(token);
|
|
qdict_put(dict, "token", token);
|
|
qdict_put(dict, "x", qint_from_int(x));
|
|
qdict_put(dict, "y", qint_from_int(y));
|
|
|
|
parser->token_size += token->length;
|
|
|
|
qlist_append(parser->tokens, dict);
|
|
|
|
if (type == JSON_ERROR) {
|
|
goto out_emit_bad;
|
|
} else if (parser->brace_count < 0 ||
|
|
parser->bracket_count < 0 ||
|
|
(parser->brace_count == 0 &&
|
|
parser->bracket_count == 0)) {
|
|
goto out_emit;
|
|
} else if (parser->token_size > MAX_TOKEN_SIZE ||
|
|
parser->bracket_count > MAX_NESTING ||
|
|
parser->brace_count > MAX_NESTING) {
|
|
/* Security consideration, we limit total memory allocated per object
|
|
* and the maximum recursion depth that a message can force.
|
|
*/
|
|
goto out_emit;
|
|
}
|
|
|
|
return;
|
|
|
|
out_emit_bad:
|
|
/* clear out token list and tell the parser to emit and error
|
|
* indication by passing it a NULL list
|
|
*/
|
|
QDECREF(parser->tokens);
|
|
parser->tokens = NULL;
|
|
out_emit:
|
|
/* send current list of tokens to parser and reset tokenizer */
|
|
parser->brace_count = 0;
|
|
parser->bracket_count = 0;
|
|
parser->emit(parser, parser->tokens);
|
|
if (parser->tokens) {
|
|
QDECREF(parser->tokens);
|
|
}
|
|
parser->tokens = qlist_new();
|
|
parser->token_size = 0;
|
|
}
|
|
|
|
void json_message_parser_init(JSONMessageParser *parser,
|
|
void (*func)(JSONMessageParser *, QList *))
|
|
{
|
|
parser->emit = func;
|
|
parser->brace_count = 0;
|
|
parser->bracket_count = 0;
|
|
parser->tokens = qlist_new();
|
|
parser->token_size = 0;
|
|
|
|
json_lexer_init(&parser->lexer, json_message_process_token);
|
|
}
|
|
|
|
int json_message_parser_feed(JSONMessageParser *parser,
|
|
const char *buffer, size_t size)
|
|
{
|
|
return json_lexer_feed(&parser->lexer, buffer, size);
|
|
}
|
|
|
|
int json_message_parser_flush(JSONMessageParser *parser)
|
|
{
|
|
return json_lexer_flush(&parser->lexer);
|
|
}
|
|
|
|
void json_message_parser_destroy(JSONMessageParser *parser)
|
|
{
|
|
json_lexer_destroy(&parser->lexer);
|
|
QDECREF(parser->tokens);
|
|
}
|