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