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 "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 }