migration: split migration hooks out of QEMUFileOps
[qemu.git] / qobject / json-parser.c
1 /*
2 * JSON Parser
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 "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qemu-common.h"
17 #include "qapi/qmp/qstring.h"
18 #include "qapi/qmp/qint.h"
19 #include "qapi/qmp/qdict.h"
20 #include "qapi/qmp/qlist.h"
21 #include "qapi/qmp/qfloat.h"
22 #include "qapi/qmp/qbool.h"
23 #include "qapi/qmp/json-parser.h"
24 #include "qapi/qmp/json-lexer.h"
25 #include "qapi/qmp/json-streamer.h"
26
27 typedef struct JSONParserContext
28 {
29 Error *err;
30 JSONToken *current;
31 GQueue *buf;
32 } JSONParserContext;
33
34 #define BUG_ON(cond) assert(!(cond))
35
36 /**
37 * TODO
38 *
39 * 0) make errors meaningful again
40 * 1) add geometry information to tokens
41 * 3) should we return a parsed size?
42 * 4) deal with premature EOI
43 */
44
45 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap);
46
47 /**
48 * Error handler
49 */
50 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
51 JSONToken *token, const char *msg, ...)
52 {
53 va_list ap;
54 char message[1024];
55 va_start(ap, msg);
56 vsnprintf(message, sizeof(message), msg, ap);
57 va_end(ap);
58 if (ctxt->err) {
59 error_free(ctxt->err);
60 ctxt->err = NULL;
61 }
62 error_setg(&ctxt->err, "JSON parse error, %s", message);
63 }
64
65 /**
66 * String helpers
67 *
68 * These helpers are used to unescape strings.
69 */
70 static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
71 {
72 if (wchar <= 0x007F) {
73 BUG_ON(buffer_length < 2);
74
75 buffer[0] = wchar & 0x7F;
76 buffer[1] = 0;
77 } else if (wchar <= 0x07FF) {
78 BUG_ON(buffer_length < 3);
79
80 buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F);
81 buffer[1] = 0x80 | (wchar & 0x3F);
82 buffer[2] = 0;
83 } else {
84 BUG_ON(buffer_length < 4);
85
86 buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F);
87 buffer[1] = 0x80 | ((wchar >> 6) & 0x3F);
88 buffer[2] = 0x80 | (wchar & 0x3F);
89 buffer[3] = 0;
90 }
91 }
92
93 static int hex2decimal(char ch)
94 {
95 if (ch >= '0' && ch <= '9') {
96 return (ch - '0');
97 } else if (ch >= 'a' && ch <= 'f') {
98 return 10 + (ch - 'a');
99 } else if (ch >= 'A' && ch <= 'F') {
100 return 10 + (ch - 'A');
101 }
102
103 return -1;
104 }
105
106 /**
107 * parse_string(): Parse a json string and return a QObject
108 *
109 * string
110 * ""
111 * " chars "
112 * chars
113 * char
114 * char chars
115 * char
116 * any-Unicode-character-
117 * except-"-or-\-or-
118 * control-character
119 * \"
120 * \\
121 * \/
122 * \b
123 * \f
124 * \n
125 * \r
126 * \t
127 * \u four-hex-digits
128 */
129 static QString *qstring_from_escaped_str(JSONParserContext *ctxt,
130 JSONToken *token)
131 {
132 const char *ptr = token->str;
133 QString *str;
134 int double_quote = 1;
135
136 if (*ptr == '"') {
137 double_quote = 1;
138 } else {
139 double_quote = 0;
140 }
141 ptr++;
142
143 str = qstring_new();
144 while (*ptr &&
145 ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) {
146 if (*ptr == '\\') {
147 ptr++;
148
149 switch (*ptr) {
150 case '"':
151 qstring_append(str, "\"");
152 ptr++;
153 break;
154 case '\'':
155 qstring_append(str, "'");
156 ptr++;
157 break;
158 case '\\':
159 qstring_append(str, "\\");
160 ptr++;
161 break;
162 case '/':
163 qstring_append(str, "/");
164 ptr++;
165 break;
166 case 'b':
167 qstring_append(str, "\b");
168 ptr++;
169 break;
170 case 'f':
171 qstring_append(str, "\f");
172 ptr++;
173 break;
174 case 'n':
175 qstring_append(str, "\n");
176 ptr++;
177 break;
178 case 'r':
179 qstring_append(str, "\r");
180 ptr++;
181 break;
182 case 't':
183 qstring_append(str, "\t");
184 ptr++;
185 break;
186 case 'u': {
187 uint16_t unicode_char = 0;
188 char utf8_char[4];
189 int i = 0;
190
191 ptr++;
192
193 for (i = 0; i < 4; i++) {
194 if (qemu_isxdigit(*ptr)) {
195 unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4);
196 } else {
197 parse_error(ctxt, token,
198 "invalid hex escape sequence in string");
199 goto out;
200 }
201 ptr++;
202 }
203
204 wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
205 qstring_append(str, utf8_char);
206 } break;
207 default:
208 parse_error(ctxt, token, "invalid escape sequence in string");
209 goto out;
210 }
211 } else {
212 char dummy[2];
213
214 dummy[0] = *ptr++;
215 dummy[1] = 0;
216
217 qstring_append(str, dummy);
218 }
219 }
220
221 return str;
222
223 out:
224 QDECREF(str);
225 return NULL;
226 }
227
228 /* Note: the token object returned by parser_context_peek_token or
229 * parser_context_pop_token is deleted as soon as parser_context_pop_token
230 * is called again.
231 */
232 static JSONToken *parser_context_pop_token(JSONParserContext *ctxt)
233 {
234 g_free(ctxt->current);
235 assert(!g_queue_is_empty(ctxt->buf));
236 ctxt->current = g_queue_pop_head(ctxt->buf);
237 return ctxt->current;
238 }
239
240 static JSONToken *parser_context_peek_token(JSONParserContext *ctxt)
241 {
242 assert(!g_queue_is_empty(ctxt->buf));
243 return g_queue_peek_head(ctxt->buf);
244 }
245
246 static JSONParserContext *parser_context_new(GQueue *tokens)
247 {
248 JSONParserContext *ctxt;
249
250 if (!tokens) {
251 return NULL;
252 }
253
254 ctxt = g_malloc0(sizeof(JSONParserContext));
255 ctxt->buf = tokens;
256
257 return ctxt;
258 }
259
260 /* to support error propagation, ctxt->err must be freed separately */
261 static void parser_context_free(JSONParserContext *ctxt)
262 {
263 if (ctxt) {
264 while (!g_queue_is_empty(ctxt->buf)) {
265 parser_context_pop_token(ctxt);
266 }
267 g_free(ctxt->current);
268 g_queue_free(ctxt->buf);
269 g_free(ctxt);
270 }
271 }
272
273 /**
274 * Parsing rules
275 */
276 static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
277 {
278 QObject *key = NULL, *value;
279 JSONToken *peek, *token;
280
281 peek = parser_context_peek_token(ctxt);
282 if (peek == NULL) {
283 parse_error(ctxt, NULL, "premature EOI");
284 goto out;
285 }
286
287 key = parse_value(ctxt, ap);
288 if (!key || qobject_type(key) != QTYPE_QSTRING) {
289 parse_error(ctxt, peek, "key is not a string in object");
290 goto out;
291 }
292
293 token = parser_context_pop_token(ctxt);
294 if (token == NULL) {
295 parse_error(ctxt, NULL, "premature EOI");
296 goto out;
297 }
298
299 if (token->type != JSON_COLON) {
300 parse_error(ctxt, token, "missing : in object pair");
301 goto out;
302 }
303
304 value = parse_value(ctxt, ap);
305 if (value == NULL) {
306 parse_error(ctxt, token, "Missing value in dict");
307 goto out;
308 }
309
310 qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
311
312 qobject_decref(key);
313
314 return 0;
315
316 out:
317 qobject_decref(key);
318
319 return -1;
320 }
321
322 static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
323 {
324 QDict *dict = NULL;
325 JSONToken *token, *peek;
326
327 token = parser_context_pop_token(ctxt);
328 assert(token && token->type == JSON_LCURLY);
329
330 dict = qdict_new();
331
332 peek = parser_context_peek_token(ctxt);
333 if (peek == NULL) {
334 parse_error(ctxt, NULL, "premature EOI");
335 goto out;
336 }
337
338 if (peek->type != JSON_RCURLY) {
339 if (parse_pair(ctxt, dict, ap) == -1) {
340 goto out;
341 }
342
343 token = parser_context_pop_token(ctxt);
344 if (token == NULL) {
345 parse_error(ctxt, NULL, "premature EOI");
346 goto out;
347 }
348
349 while (token->type != JSON_RCURLY) {
350 if (token->type != JSON_COMMA) {
351 parse_error(ctxt, token, "expected separator in dict");
352 goto out;
353 }
354
355 if (parse_pair(ctxt, dict, ap) == -1) {
356 goto out;
357 }
358
359 token = parser_context_pop_token(ctxt);
360 if (token == NULL) {
361 parse_error(ctxt, NULL, "premature EOI");
362 goto out;
363 }
364 }
365 } else {
366 (void)parser_context_pop_token(ctxt);
367 }
368
369 return QOBJECT(dict);
370
371 out:
372 QDECREF(dict);
373 return NULL;
374 }
375
376 static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
377 {
378 QList *list = NULL;
379 JSONToken *token, *peek;
380
381 token = parser_context_pop_token(ctxt);
382 assert(token && token->type == JSON_LSQUARE);
383
384 list = qlist_new();
385
386 peek = parser_context_peek_token(ctxt);
387 if (peek == NULL) {
388 parse_error(ctxt, NULL, "premature EOI");
389 goto out;
390 }
391
392 if (peek->type != JSON_RSQUARE) {
393 QObject *obj;
394
395 obj = parse_value(ctxt, ap);
396 if (obj == NULL) {
397 parse_error(ctxt, token, "expecting value");
398 goto out;
399 }
400
401 qlist_append_obj(list, obj);
402
403 token = parser_context_pop_token(ctxt);
404 if (token == NULL) {
405 parse_error(ctxt, NULL, "premature EOI");
406 goto out;
407 }
408
409 while (token->type != JSON_RSQUARE) {
410 if (token->type != JSON_COMMA) {
411 parse_error(ctxt, token, "expected separator in list");
412 goto out;
413 }
414
415 obj = parse_value(ctxt, ap);
416 if (obj == NULL) {
417 parse_error(ctxt, token, "expecting value");
418 goto out;
419 }
420
421 qlist_append_obj(list, obj);
422
423 token = parser_context_pop_token(ctxt);
424 if (token == NULL) {
425 parse_error(ctxt, NULL, "premature EOI");
426 goto out;
427 }
428 }
429 } else {
430 (void)parser_context_pop_token(ctxt);
431 }
432
433 return QOBJECT(list);
434
435 out:
436 QDECREF(list);
437 return NULL;
438 }
439
440 static QObject *parse_keyword(JSONParserContext *ctxt)
441 {
442 JSONToken *token;
443
444 token = parser_context_pop_token(ctxt);
445 assert(token && token->type == JSON_KEYWORD);
446
447 if (!strcmp(token->str, "true")) {
448 return QOBJECT(qbool_from_bool(true));
449 } else if (!strcmp(token->str, "false")) {
450 return QOBJECT(qbool_from_bool(false));
451 } else if (!strcmp(token->str, "null")) {
452 return qnull();
453 }
454 parse_error(ctxt, token, "invalid keyword '%s'", token->str);
455 return NULL;
456 }
457
458 static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap)
459 {
460 JSONToken *token;
461
462 if (ap == NULL) {
463 return NULL;
464 }
465
466 token = parser_context_pop_token(ctxt);
467 assert(token && token->type == JSON_ESCAPE);
468
469 if (!strcmp(token->str, "%p")) {
470 return va_arg(*ap, QObject *);
471 } else if (!strcmp(token->str, "%i")) {
472 return QOBJECT(qbool_from_bool(va_arg(*ap, int)));
473 } else if (!strcmp(token->str, "%d")) {
474 return QOBJECT(qint_from_int(va_arg(*ap, int)));
475 } else if (!strcmp(token->str, "%ld")) {
476 return QOBJECT(qint_from_int(va_arg(*ap, long)));
477 } else if (!strcmp(token->str, "%lld") ||
478 !strcmp(token->str, "%I64d")) {
479 return QOBJECT(qint_from_int(va_arg(*ap, long long)));
480 } else if (!strcmp(token->str, "%s")) {
481 return QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
482 } else if (!strcmp(token->str, "%f")) {
483 return QOBJECT(qfloat_from_double(va_arg(*ap, double)));
484 }
485 return NULL;
486 }
487
488 static QObject *parse_literal(JSONParserContext *ctxt)
489 {
490 JSONToken *token;
491
492 token = parser_context_pop_token(ctxt);
493 assert(token);
494
495 switch (token->type) {
496 case JSON_STRING:
497 return QOBJECT(qstring_from_escaped_str(ctxt, token));
498 case JSON_INTEGER: {
499 /* A possibility exists that this is a whole-valued float where the
500 * fractional part was left out due to being 0 (.0). It's not a big
501 * deal to treat these as ints in the parser, so long as users of the
502 * resulting QObject know to expect a QInt in place of a QFloat in
503 * cases like these.
504 *
505 * However, in some cases these values will overflow/underflow a
506 * QInt/int64 container, thus we should assume these are to be handled
507 * as QFloats/doubles rather than silently changing their values.
508 *
509 * strtoll() indicates these instances by setting errno to ERANGE
510 */
511 int64_t value;
512
513 errno = 0; /* strtoll doesn't set errno on success */
514 value = strtoll(token->str, NULL, 10);
515 if (errno != ERANGE) {
516 return QOBJECT(qint_from_int(value));
517 }
518 /* fall through to JSON_FLOAT */
519 }
520 case JSON_FLOAT:
521 /* FIXME dependent on locale; a pervasive issue in QEMU */
522 /* FIXME our lexer matches RFC 7159 in forbidding Inf or NaN,
523 * but those might be useful extensions beyond JSON */
524 return QOBJECT(qfloat_from_double(strtod(token->str, NULL)));
525 default:
526 abort();
527 }
528 }
529
530 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
531 {
532 JSONToken *token;
533
534 token = parser_context_peek_token(ctxt);
535 if (token == NULL) {
536 parse_error(ctxt, NULL, "premature EOI");
537 return NULL;
538 }
539
540 switch (token->type) {
541 case JSON_LCURLY:
542 return parse_object(ctxt, ap);
543 case JSON_LSQUARE:
544 return parse_array(ctxt, ap);
545 case JSON_ESCAPE:
546 return parse_escape(ctxt, ap);
547 case JSON_INTEGER:
548 case JSON_FLOAT:
549 case JSON_STRING:
550 return parse_literal(ctxt);
551 case JSON_KEYWORD:
552 return parse_keyword(ctxt);
553 default:
554 parse_error(ctxt, token, "expecting value");
555 return NULL;
556 }
557 }
558
559 QObject *json_parser_parse(GQueue *tokens, va_list *ap)
560 {
561 return json_parser_parse_err(tokens, ap, NULL);
562 }
563
564 QObject *json_parser_parse_err(GQueue *tokens, va_list *ap, Error **errp)
565 {
566 JSONParserContext *ctxt = parser_context_new(tokens);
567 QObject *result;
568
569 if (!ctxt) {
570 return NULL;
571 }
572
573 result = parse_value(ctxt, ap);
574
575 error_propagate(errp, ctxt->err);
576
577 parser_context_free(ctxt);
578
579 return result;
580 }