xref: /qemu/qapi/qobject-input-visitor.c (revision b355f08a) 
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 }
795