qapi/qobject-input-visitor.c

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