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