1 /* 2 * Input Visitor 3 * 4 * Copyright (C) 2012-2017 Red Hat, Inc. 5 * Copyright IBM, Corp. 2011 6 * 7 * Authors: 8 * Anthony Liguori <aliguori@us.ibm.com> 9 * 10 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 11 * See the COPYING.LIB file in the top-level directory. 12 * 13 */ 14 15 #include "qemu/osdep.h" 16 #include <math.h> 17 #include "qapi/error.h" 18 #include "qapi/qobject-input-visitor.h" 19 #include "qapi/visitor-impl.h" 20 #include "qemu/queue.h" 21 #include "qemu-common.h" 22 #include "qapi/qmp/qjson.h" 23 #include "qapi/qmp/types.h" 24 #include "qapi/qmp/qerror.h" 25 #include "qemu/cutils.h" 26 #include "qemu/option.h" 27 28 typedef struct StackObject { 29 const char *name; /* Name of @obj in its parent, if any */ 30 QObject *obj; /* QDict or QList being visited */ 31 void *qapi; /* sanity check that caller uses same pointer */ 32 33 GHashTable *h; /* If @obj is QDict: unvisited keys */ 34 const QListEntry *entry; /* If @obj is QList: unvisited tail */ 35 unsigned index; /* If @obj is QList: list index of @entry */ 36 37 QSLIST_ENTRY(StackObject) node; /* parent */ 38 } StackObject; 39 40 struct QObjectInputVisitor { 41 Visitor visitor; 42 43 /* Root of visit at visitor creation. */ 44 QObject *root; 45 bool keyval; /* Assume @root made with keyval_parse() */ 46 47 /* Stack of objects being visited (all entries will be either 48 * QDict or QList). */ 49 QSLIST_HEAD(, StackObject) stack; 50 51 GString *errname; /* Accumulator for full_name() */ 52 }; 53 54 static QObjectInputVisitor *to_qiv(Visitor *v) 55 { 56 return container_of(v, QObjectInputVisitor, visitor); 57 } 58 59 /* 60 * Find the full name of something @qiv is currently visiting. 61 * @qiv is visiting something named @name in the stack of containers 62 * @qiv->stack. 63 * If @n is zero, return its full name. 64 * If @n is positive, return the full name of the @n-th container 65 * counting from the top. The stack of containers must have at least 66 * @n elements. 67 * The returned string is valid until the next full_name_nth(@v) or 68 * destruction of @v. 69 */ 70 static const char *full_name_nth(QObjectInputVisitor *qiv, const char *name, 71 int n) 72 { 73 StackObject *so; 74 char buf[32]; 75 76 if (qiv->errname) { 77 g_string_truncate(qiv->errname, 0); 78 } else { 79 qiv->errname = g_string_new(""); 80 } 81 82 QSLIST_FOREACH(so , &qiv->stack, node) { 83 if (n) { 84 n--; 85 } else if (qobject_type(so->obj) == QTYPE_QDICT) { 86 g_string_prepend(qiv->errname, name ?: "<anonymous>"); 87 g_string_prepend_c(qiv->errname, '.'); 88 } else { 89 snprintf(buf, sizeof(buf), 90 qiv->keyval ? ".%u" : "[%u]", 91 so->index); 92 g_string_prepend(qiv->errname, buf); 93 } 94 name = so->name; 95 } 96 assert(!n); 97 98 if (name) { 99 g_string_prepend(qiv->errname, name); 100 } else if (qiv->errname->str[0] == '.') { 101 g_string_erase(qiv->errname, 0, 1); 102 } else if (!qiv->errname->str[0]) { 103 return "<anonymous>"; 104 } 105 106 return qiv->errname->str; 107 } 108 109 static const char *full_name(QObjectInputVisitor *qiv, const char *name) 110 { 111 return full_name_nth(qiv, name, 0); 112 } 113 114 static QObject *qobject_input_try_get_object(QObjectInputVisitor *qiv, 115 const char *name, 116 bool consume) 117 { 118 StackObject *tos; 119 QObject *qobj; 120 QObject *ret; 121 122 if (QSLIST_EMPTY(&qiv->stack)) { 123 /* Starting at root, name is ignored. */ 124 assert(qiv->root); 125 return qiv->root; 126 } 127 128 /* We are in a container; find the next element. */ 129 tos = QSLIST_FIRST(&qiv->stack); 130 qobj = tos->obj; 131 assert(qobj); 132 133 if (qobject_type(qobj) == QTYPE_QDICT) { 134 assert(name); 135 ret = qdict_get(qobject_to_qdict(qobj), name); 136 if (tos->h && consume && ret) { 137 bool removed = g_hash_table_remove(tos->h, name); 138 assert(removed); 139 } 140 } else { 141 assert(qobject_type(qobj) == QTYPE_QLIST); 142 assert(!name); 143 if (tos->entry) { 144 ret = qlist_entry_obj(tos->entry); 145 if (consume) { 146 tos->entry = qlist_next(tos->entry); 147 } 148 } else { 149 ret = NULL; 150 } 151 if (consume) { 152 tos->index++; 153 } 154 } 155 156 return ret; 157 } 158 159 static QObject *qobject_input_get_object(QObjectInputVisitor *qiv, 160 const char *name, 161 bool consume, Error **errp) 162 { 163 QObject *obj = qobject_input_try_get_object(qiv, name, consume); 164 165 if (!obj) { 166 error_setg(errp, QERR_MISSING_PARAMETER, full_name(qiv, name)); 167 } 168 return obj; 169 } 170 171 static const char *qobject_input_get_keyval(QObjectInputVisitor *qiv, 172 const char *name, 173 Error **errp) 174 { 175 QObject *qobj; 176 QString *qstr; 177 178 qobj = qobject_input_get_object(qiv, name, true, errp); 179 if (!qobj) { 180 return NULL; 181 } 182 183 qstr = qobject_to_qstring(qobj); 184 if (!qstr) { 185 switch (qobject_type(qobj)) { 186 case QTYPE_QDICT: 187 case QTYPE_QLIST: 188 error_setg(errp, "Parameters '%s.*' are unexpected", 189 full_name(qiv, name)); 190 return NULL; 191 default: 192 /* Non-string scalar (should this be an assertion?) */ 193 error_setg(errp, "Internal error: parameter %s invalid", 194 full_name(qiv, name)); 195 return NULL; 196 } 197 } 198 199 return qstring_get_str(qstr); 200 } 201 202 static void qdict_add_key(const char *key, QObject *obj, void *opaque) 203 { 204 GHashTable *h = opaque; 205 g_hash_table_insert(h, (gpointer) key, NULL); 206 } 207 208 static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv, 209 const char *name, 210 QObject *obj, void *qapi) 211 { 212 GHashTable *h; 213 StackObject *tos = g_new0(StackObject, 1); 214 215 assert(obj); 216 tos->name = name; 217 tos->obj = obj; 218 tos->qapi = qapi; 219 220 if (qobject_type(obj) == QTYPE_QDICT) { 221 h = g_hash_table_new(g_str_hash, g_str_equal); 222 qdict_iter(qobject_to_qdict(obj), qdict_add_key, h); 223 tos->h = h; 224 } else { 225 assert(qobject_type(obj) == QTYPE_QLIST); 226 tos->entry = qlist_first(qobject_to_qlist(obj)); 227 tos->index = -1; 228 } 229 230 QSLIST_INSERT_HEAD(&qiv->stack, tos, node); 231 return tos->entry; 232 } 233 234 235 static void qobject_input_check_struct(Visitor *v, Error **errp) 236 { 237 QObjectInputVisitor *qiv = to_qiv(v); 238 StackObject *tos = QSLIST_FIRST(&qiv->stack); 239 GHashTableIter iter; 240 const char *key; 241 242 assert(tos && !tos->entry); 243 244 g_hash_table_iter_init(&iter, tos->h); 245 if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) { 246 error_setg(errp, "Parameter '%s' is unexpected", 247 full_name(qiv, key)); 248 } 249 } 250 251 static void qobject_input_stack_object_free(StackObject *tos) 252 { 253 if (tos->h) { 254 g_hash_table_unref(tos->h); 255 } 256 257 g_free(tos); 258 } 259 260 static void qobject_input_pop(Visitor *v, void **obj) 261 { 262 QObjectInputVisitor *qiv = to_qiv(v); 263 StackObject *tos = QSLIST_FIRST(&qiv->stack); 264 265 assert(tos && tos->qapi == obj); 266 QSLIST_REMOVE_HEAD(&qiv->stack, node); 267 qobject_input_stack_object_free(tos); 268 } 269 270 static void qobject_input_start_struct(Visitor *v, const char *name, void **obj, 271 size_t size, Error **errp) 272 { 273 QObjectInputVisitor *qiv = to_qiv(v); 274 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 275 276 if (obj) { 277 *obj = NULL; 278 } 279 if (!qobj) { 280 return; 281 } 282 if (qobject_type(qobj) != QTYPE_QDICT) { 283 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 284 full_name(qiv, name), "object"); 285 return; 286 } 287 288 qobject_input_push(qiv, name, qobj, obj); 289 290 if (obj) { 291 *obj = g_malloc0(size); 292 } 293 } 294 295 static void qobject_input_end_struct(Visitor *v, void **obj) 296 { 297 QObjectInputVisitor *qiv = to_qiv(v); 298 StackObject *tos = QSLIST_FIRST(&qiv->stack); 299 300 assert(qobject_type(tos->obj) == QTYPE_QDICT && tos->h); 301 qobject_input_pop(v, obj); 302 } 303 304 305 static void qobject_input_start_list(Visitor *v, const char *name, 306 GenericList **list, size_t size, 307 Error **errp) 308 { 309 QObjectInputVisitor *qiv = to_qiv(v); 310 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 311 const QListEntry *entry; 312 313 if (list) { 314 *list = NULL; 315 } 316 if (!qobj) { 317 return; 318 } 319 if (qobject_type(qobj) != QTYPE_QLIST) { 320 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 321 full_name(qiv, name), "array"); 322 return; 323 } 324 325 entry = qobject_input_push(qiv, name, qobj, list); 326 if (entry && list) { 327 *list = g_malloc0(size); 328 } 329 } 330 331 static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail, 332 size_t size) 333 { 334 QObjectInputVisitor *qiv = to_qiv(v); 335 StackObject *tos = QSLIST_FIRST(&qiv->stack); 336 337 assert(tos && tos->obj && qobject_type(tos->obj) == QTYPE_QLIST); 338 339 if (!tos->entry) { 340 return NULL; 341 } 342 tail->next = g_malloc0(size); 343 return tail->next; 344 } 345 346 static void qobject_input_check_list(Visitor *v, Error **errp) 347 { 348 QObjectInputVisitor *qiv = to_qiv(v); 349 StackObject *tos = QSLIST_FIRST(&qiv->stack); 350 351 assert(tos && tos->obj && qobject_type(tos->obj) == QTYPE_QLIST); 352 353 if (tos->entry) { 354 error_setg(errp, "Only %u list elements expected in %s", 355 tos->index + 1, full_name_nth(qiv, NULL, 1)); 356 } 357 } 358 359 static void qobject_input_end_list(Visitor *v, void **obj) 360 { 361 QObjectInputVisitor *qiv = to_qiv(v); 362 StackObject *tos = QSLIST_FIRST(&qiv->stack); 363 364 assert(qobject_type(tos->obj) == QTYPE_QLIST && !tos->h); 365 qobject_input_pop(v, obj); 366 } 367 368 static void qobject_input_start_alternate(Visitor *v, const char *name, 369 GenericAlternate **obj, size_t size, 370 Error **errp) 371 { 372 QObjectInputVisitor *qiv = to_qiv(v); 373 QObject *qobj = qobject_input_get_object(qiv, name, false, errp); 374 375 if (!qobj) { 376 *obj = NULL; 377 return; 378 } 379 *obj = g_malloc0(size); 380 (*obj)->type = qobject_type(qobj); 381 } 382 383 static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj, 384 Error **errp) 385 { 386 QObjectInputVisitor *qiv = to_qiv(v); 387 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 388 QNum *qnum; 389 390 if (!qobj) { 391 return; 392 } 393 qnum = qobject_to_qnum(qobj); 394 if (!qnum || !qnum_get_try_int(qnum, obj)) { 395 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 396 full_name(qiv, name), "integer"); 397 } 398 } 399 400 static void qobject_input_type_int64_keyval(Visitor *v, const char *name, 401 int64_t *obj, Error **errp) 402 { 403 QObjectInputVisitor *qiv = to_qiv(v); 404 const char *str = qobject_input_get_keyval(qiv, name, errp); 405 406 if (!str) { 407 return; 408 } 409 410 if (qemu_strtoi64(str, NULL, 0, obj) < 0) { 411 /* TODO report -ERANGE more nicely */ 412 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 413 full_name(qiv, name), "integer"); 414 } 415 } 416 417 static void qobject_input_type_uint64(Visitor *v, const char *name, 418 uint64_t *obj, Error **errp) 419 { 420 QObjectInputVisitor *qiv = to_qiv(v); 421 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 422 QNum *qnum; 423 int64_t val; 424 425 if (!qobj) { 426 return; 427 } 428 qnum = qobject_to_qnum(qobj); 429 if (!qnum) { 430 goto err; 431 } 432 433 if (qnum_get_try_uint(qnum, obj)) { 434 return; 435 } 436 437 /* Need to accept negative values for backward compatibility */ 438 if (qnum_get_try_int(qnum, &val)) { 439 *obj = val; 440 return; 441 } 442 443 err: 444 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 445 full_name(qiv, name), "uint64"); 446 } 447 448 static void qobject_input_type_uint64_keyval(Visitor *v, const char *name, 449 uint64_t *obj, Error **errp) 450 { 451 QObjectInputVisitor *qiv = to_qiv(v); 452 const char *str = qobject_input_get_keyval(qiv, name, errp); 453 454 if (!str) { 455 return; 456 } 457 458 if (qemu_strtou64(str, NULL, 0, obj) < 0) { 459 /* TODO report -ERANGE more nicely */ 460 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 461 full_name(qiv, name), "integer"); 462 } 463 } 464 465 static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj, 466 Error **errp) 467 { 468 QObjectInputVisitor *qiv = to_qiv(v); 469 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 470 QBool *qbool; 471 472 if (!qobj) { 473 return; 474 } 475 qbool = qobject_to_qbool(qobj); 476 if (!qbool) { 477 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 478 full_name(qiv, name), "boolean"); 479 return; 480 } 481 482 *obj = qbool_get_bool(qbool); 483 } 484 485 static void qobject_input_type_bool_keyval(Visitor *v, const char *name, 486 bool *obj, Error **errp) 487 { 488 QObjectInputVisitor *qiv = to_qiv(v); 489 const char *str = qobject_input_get_keyval(qiv, name, errp); 490 491 if (!str) { 492 return; 493 } 494 495 if (!strcmp(str, "on")) { 496 *obj = true; 497 } else if (!strcmp(str, "off")) { 498 *obj = false; 499 } else { 500 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 501 full_name(qiv, name), "'on' or 'off'"); 502 } 503 } 504 505 static void qobject_input_type_str(Visitor *v, const char *name, char **obj, 506 Error **errp) 507 { 508 QObjectInputVisitor *qiv = to_qiv(v); 509 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 510 QString *qstr; 511 512 *obj = NULL; 513 if (!qobj) { 514 return; 515 } 516 qstr = qobject_to_qstring(qobj); 517 if (!qstr) { 518 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 519 full_name(qiv, name), "string"); 520 return; 521 } 522 523 *obj = g_strdup(qstring_get_str(qstr)); 524 } 525 526 static void qobject_input_type_str_keyval(Visitor *v, const char *name, 527 char **obj, Error **errp) 528 { 529 QObjectInputVisitor *qiv = to_qiv(v); 530 const char *str = qobject_input_get_keyval(qiv, name, errp); 531 532 *obj = g_strdup(str); 533 } 534 535 static void qobject_input_type_number(Visitor *v, const char *name, double *obj, 536 Error **errp) 537 { 538 QObjectInputVisitor *qiv = to_qiv(v); 539 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 540 QNum *qnum; 541 542 if (!qobj) { 543 return; 544 } 545 qnum = qobject_to_qnum(qobj); 546 if (!qnum) { 547 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 548 full_name(qiv, name), "number"); 549 return; 550 } 551 552 *obj = qnum_get_double(qnum); 553 } 554 555 static void qobject_input_type_number_keyval(Visitor *v, const char *name, 556 double *obj, Error **errp) 557 { 558 QObjectInputVisitor *qiv = to_qiv(v); 559 const char *str = qobject_input_get_keyval(qiv, name, errp); 560 char *endp; 561 562 if (!str) { 563 return; 564 } 565 566 errno = 0; 567 *obj = strtod(str, &endp); 568 if (errno || endp == str || *endp || !isfinite(*obj)) { 569 /* TODO report -ERANGE more nicely */ 570 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 571 full_name(qiv, name), "number"); 572 } 573 } 574 575 static void qobject_input_type_any(Visitor *v, const char *name, QObject **obj, 576 Error **errp) 577 { 578 QObjectInputVisitor *qiv = to_qiv(v); 579 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 580 581 *obj = NULL; 582 if (!qobj) { 583 return; 584 } 585 586 qobject_incref(qobj); 587 *obj = qobj; 588 } 589 590 static void qobject_input_type_null(Visitor *v, const char *name, 591 QNull **obj, Error **errp) 592 { 593 QObjectInputVisitor *qiv = to_qiv(v); 594 QObject *qobj = qobject_input_get_object(qiv, name, true, errp); 595 596 *obj = NULL; 597 if (!qobj) { 598 return; 599 } 600 601 if (qobject_type(qobj) != QTYPE_QNULL) { 602 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, 603 full_name(qiv, name), "null"); 604 return; 605 } 606 *obj = qnull(); 607 } 608 609 static void qobject_input_type_size_keyval(Visitor *v, const char *name, 610 uint64_t *obj, Error **errp) 611 { 612 QObjectInputVisitor *qiv = to_qiv(v); 613 const char *str = qobject_input_get_keyval(qiv, name, errp); 614 615 if (!str) { 616 return; 617 } 618 619 if (qemu_strtosz(str, NULL, obj) < 0) { 620 /* TODO report -ERANGE more nicely */ 621 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 622 full_name(qiv, name), "size"); 623 } 624 } 625 626 static void qobject_input_optional(Visitor *v, const char *name, bool *present) 627 { 628 QObjectInputVisitor *qiv = to_qiv(v); 629 QObject *qobj = qobject_input_try_get_object(qiv, name, false); 630 631 if (!qobj) { 632 *present = false; 633 return; 634 } 635 636 *present = true; 637 } 638 639 static void qobject_input_free(Visitor *v) 640 { 641 QObjectInputVisitor *qiv = to_qiv(v); 642 643 while (!QSLIST_EMPTY(&qiv->stack)) { 644 StackObject *tos = QSLIST_FIRST(&qiv->stack); 645 646 QSLIST_REMOVE_HEAD(&qiv->stack, node); 647 qobject_input_stack_object_free(tos); 648 } 649 650 qobject_decref(qiv->root); 651 if (qiv->errname) { 652 g_string_free(qiv->errname, TRUE); 653 } 654 g_free(qiv); 655 } 656 657 static QObjectInputVisitor *qobject_input_visitor_base_new(QObject *obj) 658 { 659 QObjectInputVisitor *v = g_malloc0(sizeof(*v)); 660 661 assert(obj); 662 663 v->visitor.type = VISITOR_INPUT; 664 v->visitor.start_struct = qobject_input_start_struct; 665 v->visitor.check_struct = qobject_input_check_struct; 666 v->visitor.end_struct = qobject_input_end_struct; 667 v->visitor.start_list = qobject_input_start_list; 668 v->visitor.next_list = qobject_input_next_list; 669 v->visitor.check_list = qobject_input_check_list; 670 v->visitor.end_list = qobject_input_end_list; 671 v->visitor.start_alternate = qobject_input_start_alternate; 672 v->visitor.optional = qobject_input_optional; 673 v->visitor.free = qobject_input_free; 674 675 v->root = obj; 676 qobject_incref(obj); 677 678 return v; 679 } 680 681 Visitor *qobject_input_visitor_new(QObject *obj) 682 { 683 QObjectInputVisitor *v = qobject_input_visitor_base_new(obj); 684 685 v->visitor.type_int64 = qobject_input_type_int64; 686 v->visitor.type_uint64 = qobject_input_type_uint64; 687 v->visitor.type_bool = qobject_input_type_bool; 688 v->visitor.type_str = qobject_input_type_str; 689 v->visitor.type_number = qobject_input_type_number; 690 v->visitor.type_any = qobject_input_type_any; 691 v->visitor.type_null = qobject_input_type_null; 692 693 return &v->visitor; 694 } 695 696 Visitor *qobject_input_visitor_new_keyval(QObject *obj) 697 { 698 QObjectInputVisitor *v = qobject_input_visitor_base_new(obj); 699 700 v->visitor.type_int64 = qobject_input_type_int64_keyval; 701 v->visitor.type_uint64 = qobject_input_type_uint64_keyval; 702 v->visitor.type_bool = qobject_input_type_bool_keyval; 703 v->visitor.type_str = qobject_input_type_str_keyval; 704 v->visitor.type_number = qobject_input_type_number_keyval; 705 v->visitor.type_any = qobject_input_type_any; 706 v->visitor.type_null = qobject_input_type_null; 707 v->visitor.type_size = qobject_input_type_size_keyval; 708 v->keyval = true; 709 710 return &v->visitor; 711 } 712 713 Visitor *qobject_input_visitor_new_str(const char *str, 714 const char *implied_key, 715 Error **errp) 716 { 717 bool is_json = str[0] == '{'; 718 QObject *obj; 719 QDict *args; 720 Visitor *v; 721 722 if (is_json) { 723 obj = qobject_from_json(str, errp); 724 if (!obj) { 725 /* Work around qobject_from_json() lossage TODO fix that */ 726 if (errp && !*errp) { 727 error_setg(errp, "JSON parse error"); 728 return NULL; 729 } 730 return NULL; 731 } 732 args = qobject_to_qdict(obj); 733 assert(args); 734 v = qobject_input_visitor_new(QOBJECT(args)); 735 } else { 736 args = keyval_parse(str, implied_key, errp); 737 if (!args) { 738 return NULL; 739 } 740 v = qobject_input_visitor_new_keyval(QOBJECT(args)); 741 } 742 QDECREF(args); 743 744 return v; 745 } 746