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