1 /* 2 * JSON Parser 3 * 4 * Copyright IBM, Corp. 2009 5 * 6 * Authors: 7 * Anthony Liguori <aliguori (at) 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/qerror.h" 26 27 typedef struct JSONParserContext 28 { 29 Error *err; 30 struct { 31 QObject **buf; 32 size_t pos; 33 size_t count; 34 } tokens; 35 } JSONParserContext; 36 37 #define BUG_ON(cond) assert(!(cond)) 38 39 /** 40 * TODO 41 * 42 * 0) make errors meaningful again 43 * 1) add geometry information to tokens 44 * 3) should we return a parsed size? 45 * 4) deal with premature EOI 46 */ 47 48 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap); 49 50 /** 51 * Token manipulators 52 * 53 * tokens are dictionaries that contain a type, a string value, and geometry information 54 * about a token identified by the lexer. These are routines that make working with 55 * these objects a bit easier. 56 */ 57 static const char *token_get_value(QObject *obj) 58 { 59 return qdict_get_str(qobject_to_qdict(obj), "token"); 60 } 61 62 static JSONTokenType token_get_type(QObject *obj) 63 { 64 return qdict_get_int(qobject_to_qdict(obj), "type"); 65 } 66 67 static int token_is_operator(QObject *obj, char op) 68 { 69 const char *val; 70 71 if (token_get_type(obj) != JSON_OPERATOR) { 72 return 0; 73 } 74 75 val = token_get_value(obj); 76 77 return (val[0] == op) && (val[1] == 0); 78 } 79 80 static int token_is_keyword(QObject *obj, const char *value) 81 { 82 if (token_get_type(obj) != JSON_KEYWORD) { 83 return 0; 84 } 85 86 return strcmp(token_get_value(obj), value) == 0; 87 } 88 89 static int token_is_escape(QObject *obj, const char *value) 90 { 91 if (token_get_type(obj) != JSON_ESCAPE) { 92 return 0; 93 } 94 95 return (strcmp(token_get_value(obj), value) == 0); 96 } 97 98 /** 99 * Error handler 100 */ 101 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt, 102 QObject *token, const char *msg, ...) 103 { 104 va_list ap; 105 char message[1024]; 106 va_start(ap, msg); 107 vsnprintf(message, sizeof(message), msg, ap); 108 va_end(ap); 109 if (ctxt->err) { 110 error_free(ctxt->err); 111 ctxt->err = NULL; 112 } 113 error_set(&ctxt->err, QERR_JSON_PARSE_ERROR, message); 114 } 115 116 /** 117 * String helpers 118 * 119 * These helpers are used to unescape strings. 120 */ 121 static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length) 122 { 123 if (wchar <= 0x007F) { 124 BUG_ON(buffer_length < 2); 125 126 buffer[0] = wchar & 0x7F; 127 buffer[1] = 0; 128 } else if (wchar <= 0x07FF) { 129 BUG_ON(buffer_length < 3); 130 131 buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F); 132 buffer[1] = 0x80 | (wchar & 0x3F); 133 buffer[2] = 0; 134 } else { 135 BUG_ON(buffer_length < 4); 136 137 buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F); 138 buffer[1] = 0x80 | ((wchar >> 6) & 0x3F); 139 buffer[2] = 0x80 | (wchar & 0x3F); 140 buffer[3] = 0; 141 } 142 } 143 144 static int hex2decimal(char ch) 145 { 146 if (ch >= '0' && ch <= '9') { 147 return (ch - '0'); 148 } else if (ch >= 'a' && ch <= 'f') { 149 return 10 + (ch - 'a'); 150 } else if (ch >= 'A' && ch <= 'F') { 151 return 10 + (ch - 'A'); 152 } 153 154 return -1; 155 } 156 157 /** 158 * parse_string(): Parse a json string and return a QObject 159 * 160 * string 161 * "" 162 * " chars " 163 * chars 164 * char 165 * char chars 166 * char 167 * any-Unicode-character- 168 * except-"-or-\-or- 169 * control-character 170 * \" 171 * \\ 172 * \/ 173 * \b 174 * \f 175 * \n 176 * \r 177 * \t 178 * \u four-hex-digits 179 */ 180 static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token) 181 { 182 const char *ptr = token_get_value(token); 183 QString *str; 184 int double_quote = 1; 185 186 if (*ptr == '"') { 187 double_quote = 1; 188 } else { 189 double_quote = 0; 190 } 191 ptr++; 192 193 str = qstring_new(); 194 while (*ptr && 195 ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) { 196 if (*ptr == '\\') { 197 ptr++; 198 199 switch (*ptr) { 200 case '"': 201 qstring_append(str, "\""); 202 ptr++; 203 break; 204 case '\'': 205 qstring_append(str, "'"); 206 ptr++; 207 break; 208 case '\\': 209 qstring_append(str, "\\"); 210 ptr++; 211 break; 212 case '/': 213 qstring_append(str, "/"); 214 ptr++; 215 break; 216 case 'b': 217 qstring_append(str, "\b"); 218 ptr++; 219 break; 220 case 'f': 221 qstring_append(str, "\f"); 222 ptr++; 223 break; 224 case 'n': 225 qstring_append(str, "\n"); 226 ptr++; 227 break; 228 case 'r': 229 qstring_append(str, "\r"); 230 ptr++; 231 break; 232 case 't': 233 qstring_append(str, "\t"); 234 ptr++; 235 break; 236 case 'u': { 237 uint16_t unicode_char = 0; 238 char utf8_char[4]; 239 int i = 0; 240 241 ptr++; 242 243 for (i = 0; i < 4; i++) { 244 if (qemu_isxdigit(*ptr)) { 245 unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4); 246 } else { 247 parse_error(ctxt, token, 248 "invalid hex escape sequence in string"); 249 goto out; 250 } 251 ptr++; 252 } 253 254 wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char)); 255 qstring_append(str, utf8_char); 256 } break; 257 default: 258 parse_error(ctxt, token, "invalid escape sequence in string"); 259 goto out; 260 } 261 } else { 262 char dummy[2]; 263 264 dummy[0] = *ptr++; 265 dummy[1] = 0; 266 267 qstring_append(str, dummy); 268 } 269 } 270 271 return str; 272 273 out: 274 QDECREF(str); 275 return NULL; 276 } 277 278 static QObject *parser_context_pop_token(JSONParserContext *ctxt) 279 { 280 QObject *token; 281 g_assert(ctxt->tokens.pos < ctxt->tokens.count); 282 token = ctxt->tokens.buf[ctxt->tokens.pos]; 283 ctxt->tokens.pos++; 284 return token; 285 } 286 287 /* Note: parser_context_{peek|pop}_token do not increment the 288 * token object's refcount. In both cases the references will continue 289 * to be tracked and cleaned up in parser_context_free(), so do not 290 * attempt to free the token object. 291 */ 292 static QObject *parser_context_peek_token(JSONParserContext *ctxt) 293 { 294 QObject *token; 295 g_assert(ctxt->tokens.pos < ctxt->tokens.count); 296 token = ctxt->tokens.buf[ctxt->tokens.pos]; 297 return token; 298 } 299 300 static JSONParserContext parser_context_save(JSONParserContext *ctxt) 301 { 302 JSONParserContext saved_ctxt = {0}; 303 saved_ctxt.tokens.pos = ctxt->tokens.pos; 304 saved_ctxt.tokens.count = ctxt->tokens.count; 305 saved_ctxt.tokens.buf = ctxt->tokens.buf; 306 return saved_ctxt; 307 } 308 309 static void parser_context_restore(JSONParserContext *ctxt, 310 JSONParserContext saved_ctxt) 311 { 312 ctxt->tokens.pos = saved_ctxt.tokens.pos; 313 ctxt->tokens.count = saved_ctxt.tokens.count; 314 ctxt->tokens.buf = saved_ctxt.tokens.buf; 315 } 316 317 static void tokens_append_from_iter(QObject *obj, void *opaque) 318 { 319 JSONParserContext *ctxt = opaque; 320 g_assert(ctxt->tokens.pos < ctxt->tokens.count); 321 ctxt->tokens.buf[ctxt->tokens.pos++] = obj; 322 qobject_incref(obj); 323 } 324 325 static JSONParserContext *parser_context_new(QList *tokens) 326 { 327 JSONParserContext *ctxt; 328 size_t count; 329 330 if (!tokens) { 331 return NULL; 332 } 333 334 count = qlist_size(tokens); 335 if (count == 0) { 336 return NULL; 337 } 338 339 ctxt = g_malloc0(sizeof(JSONParserContext)); 340 ctxt->tokens.pos = 0; 341 ctxt->tokens.count = count; 342 ctxt->tokens.buf = g_malloc(count * sizeof(QObject *)); 343 qlist_iter(tokens, tokens_append_from_iter, ctxt); 344 ctxt->tokens.pos = 0; 345 346 return ctxt; 347 } 348 349 /* to support error propagation, ctxt->err must be freed separately */ 350 static void parser_context_free(JSONParserContext *ctxt) 351 { 352 int i; 353 if (ctxt) { 354 for (i = 0; i < ctxt->tokens.count; i++) { 355 qobject_decref(ctxt->tokens.buf[i]); 356 } 357 g_free(ctxt->tokens.buf); 358 g_free(ctxt); 359 } 360 } 361 362 /** 363 * Parsing rules 364 */ 365 static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap) 366 { 367 QObject *key = NULL, *token = NULL, *value, *peek; 368 JSONParserContext saved_ctxt = parser_context_save(ctxt); 369 370 peek = parser_context_peek_token(ctxt); 371 if (peek == NULL) { 372 parse_error(ctxt, NULL, "premature EOI"); 373 goto out; 374 } 375 376 key = parse_value(ctxt, ap); 377 if (!key || qobject_type(key) != QTYPE_QSTRING) { 378 parse_error(ctxt, peek, "key is not a string in object"); 379 goto out; 380 } 381 382 token = parser_context_pop_token(ctxt); 383 if (token == NULL) { 384 parse_error(ctxt, NULL, "premature EOI"); 385 goto out; 386 } 387 388 if (!token_is_operator(token, ':')) { 389 parse_error(ctxt, token, "missing : in object pair"); 390 goto out; 391 } 392 393 value = parse_value(ctxt, ap); 394 if (value == NULL) { 395 parse_error(ctxt, token, "Missing value in dict"); 396 goto out; 397 } 398 399 qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value); 400 401 qobject_decref(key); 402 403 return 0; 404 405 out: 406 parser_context_restore(ctxt, saved_ctxt); 407 qobject_decref(key); 408 409 return -1; 410 } 411 412 static QObject *parse_object(JSONParserContext *ctxt, va_list *ap) 413 { 414 QDict *dict = NULL; 415 QObject *token, *peek; 416 JSONParserContext saved_ctxt = parser_context_save(ctxt); 417 418 token = parser_context_pop_token(ctxt); 419 if (token == NULL) { 420 goto out; 421 } 422 423 if (!token_is_operator(token, '{')) { 424 goto out; 425 } 426 token = NULL; 427 428 dict = qdict_new(); 429 430 peek = parser_context_peek_token(ctxt); 431 if (peek == NULL) { 432 parse_error(ctxt, NULL, "premature EOI"); 433 goto out; 434 } 435 436 if (!token_is_operator(peek, '}')) { 437 if (parse_pair(ctxt, dict, ap) == -1) { 438 goto out; 439 } 440 441 token = parser_context_pop_token(ctxt); 442 if (token == NULL) { 443 parse_error(ctxt, NULL, "premature EOI"); 444 goto out; 445 } 446 447 while (!token_is_operator(token, '}')) { 448 if (!token_is_operator(token, ',')) { 449 parse_error(ctxt, token, "expected separator in dict"); 450 goto out; 451 } 452 token = NULL; 453 454 if (parse_pair(ctxt, dict, ap) == -1) { 455 goto out; 456 } 457 458 token = parser_context_pop_token(ctxt); 459 if (token == NULL) { 460 parse_error(ctxt, NULL, "premature EOI"); 461 goto out; 462 } 463 } 464 token = NULL; 465 } else { 466 token = parser_context_pop_token(ctxt); 467 token = NULL; 468 } 469 470 return QOBJECT(dict); 471 472 out: 473 parser_context_restore(ctxt, saved_ctxt); 474 QDECREF(dict); 475 return NULL; 476 } 477 478 static QObject *parse_array(JSONParserContext *ctxt, va_list *ap) 479 { 480 QList *list = NULL; 481 QObject *token, *peek; 482 JSONParserContext saved_ctxt = parser_context_save(ctxt); 483 484 token = parser_context_pop_token(ctxt); 485 if (token == NULL) { 486 goto out; 487 } 488 489 if (!token_is_operator(token, '[')) { 490 token = NULL; 491 goto out; 492 } 493 token = NULL; 494 495 list = qlist_new(); 496 497 peek = parser_context_peek_token(ctxt); 498 if (peek == NULL) { 499 parse_error(ctxt, NULL, "premature EOI"); 500 goto out; 501 } 502 503 if (!token_is_operator(peek, ']')) { 504 QObject *obj; 505 506 obj = parse_value(ctxt, ap); 507 if (obj == NULL) { 508 parse_error(ctxt, token, "expecting value"); 509 goto out; 510 } 511 512 qlist_append_obj(list, obj); 513 514 token = parser_context_pop_token(ctxt); 515 if (token == NULL) { 516 parse_error(ctxt, NULL, "premature EOI"); 517 goto out; 518 } 519 520 while (!token_is_operator(token, ']')) { 521 if (!token_is_operator(token, ',')) { 522 parse_error(ctxt, token, "expected separator in list"); 523 goto out; 524 } 525 526 token = NULL; 527 528 obj = parse_value(ctxt, ap); 529 if (obj == NULL) { 530 parse_error(ctxt, token, "expecting value"); 531 goto out; 532 } 533 534 qlist_append_obj(list, obj); 535 536 token = parser_context_pop_token(ctxt); 537 if (token == NULL) { 538 parse_error(ctxt, NULL, "premature EOI"); 539 goto out; 540 } 541 } 542 543 token = NULL; 544 } else { 545 token = parser_context_pop_token(ctxt); 546 token = NULL; 547 } 548 549 return QOBJECT(list); 550 551 out: 552 parser_context_restore(ctxt, saved_ctxt); 553 QDECREF(list); 554 return NULL; 555 } 556 557 static QObject *parse_keyword(JSONParserContext *ctxt) 558 { 559 QObject *token, *ret; 560 JSONParserContext saved_ctxt = parser_context_save(ctxt); 561 562 token = parser_context_pop_token(ctxt); 563 if (token == NULL) { 564 goto out; 565 } 566 567 if (token_get_type(token) != JSON_KEYWORD) { 568 goto out; 569 } 570 571 if (token_is_keyword(token, "true")) { 572 ret = QOBJECT(qbool_from_int(true)); 573 } else if (token_is_keyword(token, "false")) { 574 ret = QOBJECT(qbool_from_int(false)); 575 } else { 576 parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token)); 577 goto out; 578 } 579 580 return ret; 581 582 out: 583 parser_context_restore(ctxt, saved_ctxt); 584 585 return NULL; 586 } 587 588 static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap) 589 { 590 QObject *token = NULL, *obj; 591 JSONParserContext saved_ctxt = parser_context_save(ctxt); 592 593 if (ap == NULL) { 594 goto out; 595 } 596 597 token = parser_context_pop_token(ctxt); 598 if (token == NULL) { 599 goto out; 600 } 601 602 if (token_is_escape(token, "%p")) { 603 obj = va_arg(*ap, QObject *); 604 } else if (token_is_escape(token, "%i")) { 605 obj = QOBJECT(qbool_from_int(va_arg(*ap, int))); 606 } else if (token_is_escape(token, "%d")) { 607 obj = QOBJECT(qint_from_int(va_arg(*ap, int))); 608 } else if (token_is_escape(token, "%ld")) { 609 obj = QOBJECT(qint_from_int(va_arg(*ap, long))); 610 } else if (token_is_escape(token, "%lld") || 611 token_is_escape(token, "%I64d")) { 612 obj = QOBJECT(qint_from_int(va_arg(*ap, long long))); 613 } else if (token_is_escape(token, "%s")) { 614 obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *))); 615 } else if (token_is_escape(token, "%f")) { 616 obj = QOBJECT(qfloat_from_double(va_arg(*ap, double))); 617 } else { 618 goto out; 619 } 620 621 return obj; 622 623 out: 624 parser_context_restore(ctxt, saved_ctxt); 625 626 return NULL; 627 } 628 629 static QObject *parse_literal(JSONParserContext *ctxt) 630 { 631 QObject *token, *obj; 632 JSONParserContext saved_ctxt = parser_context_save(ctxt); 633 634 token = parser_context_pop_token(ctxt); 635 if (token == NULL) { 636 goto out; 637 } 638 639 switch (token_get_type(token)) { 640 case JSON_STRING: 641 obj = QOBJECT(qstring_from_escaped_str(ctxt, token)); 642 break; 643 case JSON_INTEGER: { 644 /* A possibility exists that this is a whole-valued float where the 645 * fractional part was left out due to being 0 (.0). It's not a big 646 * deal to treat these as ints in the parser, so long as users of the 647 * resulting QObject know to expect a QInt in place of a QFloat in 648 * cases like these. 649 * 650 * However, in some cases these values will overflow/underflow a 651 * QInt/int64 container, thus we should assume these are to be handled 652 * as QFloats/doubles rather than silently changing their values. 653 * 654 * strtoll() indicates these instances by setting errno to ERANGE 655 */ 656 int64_t value; 657 658 errno = 0; /* strtoll doesn't set errno on success */ 659 value = strtoll(token_get_value(token), NULL, 10); 660 if (errno != ERANGE) { 661 obj = QOBJECT(qint_from_int(value)); 662 break; 663 } 664 /* fall through to JSON_FLOAT */ 665 } 666 case JSON_FLOAT: 667 /* FIXME dependent on locale */ 668 obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL))); 669 break; 670 default: 671 goto out; 672 } 673 674 return obj; 675 676 out: 677 parser_context_restore(ctxt, saved_ctxt); 678 679 return NULL; 680 } 681 682 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap) 683 { 684 QObject *obj; 685 686 obj = parse_object(ctxt, ap); 687 if (obj == NULL) { 688 obj = parse_array(ctxt, ap); 689 } 690 if (obj == NULL) { 691 obj = parse_escape(ctxt, ap); 692 } 693 if (obj == NULL) { 694 obj = parse_keyword(ctxt); 695 } 696 if (obj == NULL) { 697 obj = parse_literal(ctxt); 698 } 699 700 return obj; 701 } 702 703 QObject *json_parser_parse(QList *tokens, va_list *ap) 704 { 705 return json_parser_parse_err(tokens, ap, NULL); 706 } 707 708 QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp) 709 { 710 JSONParserContext *ctxt = parser_context_new(tokens); 711 QObject *result; 712 713 if (!ctxt) { 714 return NULL; 715 } 716 717 result = parse_value(ctxt, ap); 718 719 error_propagate(errp, ctxt->err); 720 721 parser_context_free(ctxt); 722 723 return result; 724 } 725
