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