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