Statistics
| Branch: | Revision:

root / json-streamer.c @ 5e2dafeb

History | View | Annotate | Download (3.2 kB)

1
/*
2
 * JSON streaming support
3
 *
4
 * Copyright IBM, Corp. 2009
5
 *
6
 * Authors:
7
 *  Anthony Liguori   <aliguori@us.ibm.com>
8
 *
9
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10
 * See the COPYING.LIB file in the top-level directory.
11
 *
12
 */
13

    
14
#include "qlist.h"
15
#include "qint.h"
16
#include "qdict.h"
17
#include "qemu-common.h"
18
#include "json-lexer.h"
19
#include "json-streamer.h"
20

    
21
#define MAX_TOKEN_SIZE (64ULL << 20)
22
#define MAX_NESTING (1ULL << 10)
23

    
24
static void json_message_process_token(JSONLexer *lexer, QString *token, JSONTokenType type, int x, int y)
25
{
26
    JSONMessageParser *parser = container_of(lexer, JSONMessageParser, lexer);
27
    QDict *dict;
28

    
29
    if (type == JSON_OPERATOR) {
30
        switch (qstring_get_str(token)[0]) {
31
        case '{':
32
            parser->brace_count++;
33
            break;
34
        case '}':
35
            parser->brace_count--;
36
            break;
37
        case '[':
38
            parser->bracket_count++;
39
            break;
40
        case ']':
41
            parser->bracket_count--;
42
            break;
43
        default:
44
            break;
45
        }
46
    }
47

    
48
    dict = qdict_new();
49
    qdict_put(dict, "type", qint_from_int(type));
50
    QINCREF(token);
51
    qdict_put(dict, "token", token);
52
    qdict_put(dict, "x", qint_from_int(x));
53
    qdict_put(dict, "y", qint_from_int(y));
54

    
55
    parser->token_size += token->length;
56

    
57
    qlist_append(parser->tokens, dict);
58

    
59
    if (type == JSON_ERROR) {
60
        goto out_emit_bad;
61
    } else if (parser->brace_count < 0 ||
62
        parser->bracket_count < 0 ||
63
        (parser->brace_count == 0 &&
64
         parser->bracket_count == 0)) {
65
        goto out_emit;
66
    } else if (parser->token_size > MAX_TOKEN_SIZE ||
67
               parser->bracket_count > MAX_NESTING ||
68
               parser->brace_count > MAX_NESTING) {
69
        /* Security consideration, we limit total memory allocated per object
70
         * and the maximum recursion depth that a message can force.
71
         */
72
        goto out_emit;
73
    }
74

    
75
    return;
76

    
77
out_emit_bad:
78
    /* clear out token list and tell the parser to emit and error
79
     * indication by passing it a NULL list
80
     */
81
    QDECREF(parser->tokens);
82
    parser->tokens = NULL;
83
out_emit:
84
    /* send current list of tokens to parser and reset tokenizer */
85
    parser->brace_count = 0;
86
    parser->bracket_count = 0;
87
    parser->emit(parser, parser->tokens);
88
    if (parser->tokens) {
89
        QDECREF(parser->tokens);
90
    }
91
    parser->tokens = qlist_new();
92
    parser->token_size = 0;
93
}
94

    
95
void json_message_parser_init(JSONMessageParser *parser,
96
                              void (*func)(JSONMessageParser *, QList *))
97
{
98
    parser->emit = func;
99
    parser->brace_count = 0;
100
    parser->bracket_count = 0;
101
    parser->tokens = qlist_new();
102
    parser->token_size = 0;
103

    
104
    json_lexer_init(&parser->lexer, json_message_process_token);
105
}
106

    
107
int json_message_parser_feed(JSONMessageParser *parser,
108
                             const char *buffer, size_t size)
109
{
110
    return json_lexer_feed(&parser->lexer, buffer, size);
111
}
112

    
113
int json_message_parser_flush(JSONMessageParser *parser)
114
{
115
    return json_lexer_flush(&parser->lexer);
116
}
117

    
118
void json_message_parser_destroy(JSONMessageParser *parser)
119
{
120
    json_lexer_destroy(&parser->lexer);
121
    QDECREF(parser->tokens);
122
}