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