xref: /openbmc/qemu/qobject/json-parser.c (revision 0e1d0245) 
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 <stdarg.h>
15 
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 */
522         return QOBJECT(qfloat_from_double(strtod(token->str, NULL)));
523     default:
524         abort();
525     }
526 }
527 
528 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
529 {
530     JSONToken *token;
531 
532     token = parser_context_peek_token(ctxt);
533     if (token == NULL) {
534         parse_error(ctxt, NULL, "premature EOI");
535         return NULL;
536     }
537 
538     switch (token->type) {
539     case JSON_LCURLY:
540         return parse_object(ctxt, ap);
541     case JSON_LSQUARE:
542         return parse_array(ctxt, ap);
543     case JSON_ESCAPE:
544         return parse_escape(ctxt, ap);
545     case JSON_INTEGER:
546     case JSON_FLOAT:
547     case JSON_STRING:
548         return parse_literal(ctxt);
549     case JSON_KEYWORD:
550         return parse_keyword(ctxt);
551     default:
552         parse_error(ctxt, token, "expecting value");
553         return NULL;
554     }
555 }
556 
557 QObject *json_parser_parse(GQueue *tokens, va_list *ap)
558 {
559     return json_parser_parse_err(tokens, ap, NULL);
560 }
561 
562 QObject *json_parser_parse_err(GQueue *tokens, va_list *ap, Error **errp)
563 {
564     JSONParserContext *ctxt = parser_context_new(tokens);
565     QObject *result;
566 
567     if (!ctxt) {
568         return NULL;
569     }
570 
571     result = parse_value(ctxt, ap);
572 
573     error_propagate(errp, ctxt->err);
574 
575     parser_context_free(ctxt);
576 
577     return result;
578 }
579