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 }