xref: /qemu/qapi/qobject-input-visitor.c (revision ab9056ff) 
1 /*
2  * Input Visitor
3  *
4  * Copyright (C) 2012-2017 Red Hat, Inc.
5  * Copyright IBM, Corp. 2011
6  *
7  * Authors:
8  *  Anthony Liguori   <aliguori@us.ibm.com>
9  *
10  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
11  * See the COPYING.LIB file in the top-level directory.
12  *
13  */
14 
15 #include "qemu/osdep.h"
16 #include <math.h>
17 #include "qapi/error.h"
18 #include "qapi/qobject-input-visitor.h"
19 #include "qapi/visitor-impl.h"
20 #include "qemu/queue.h"
21 #include "qapi/qmp/qjson.h"
22 #include "qapi/qmp/qbool.h"
23 #include "qapi/qmp/qdict.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qapi/qmp/qlist.h"
26 #include "qapi/qmp/qnull.h"
27 #include "qapi/qmp/qnum.h"
28 #include "qapi/qmp/qstring.h"
29 #include "qemu/cutils.h"
30 #include "qemu/option.h"
31 
32 typedef struct StackObject {
33     const char *name;            /* Name of @obj in its parent, if any */
34     QObject *obj;                /* QDict or QList being visited */
35     void *qapi; /* sanity check that caller uses same pointer */
36 
37     GHashTable *h;              /* If @obj is QDict: unvisited keys */
38     const QListEntry *entry;    /* If @obj is QList: unvisited tail */
39     unsigned index;             /* If @obj is QList: list index of @entry */
40 
41     QSLIST_ENTRY(StackObject) node; /* parent */
42 } StackObject;
43 
44 struct QObjectInputVisitor {
45     Visitor visitor;
46 
47     /* Root of visit at visitor creation. */
48     QObject *root;
49     bool keyval;                /* Assume @root made with keyval_parse() */
50 
51     /* Stack of objects being visited (all entries will be either
52      * QDict or QList). */
53     QSLIST_HEAD(, StackObject) stack;
54 
55     GString *errname;           /* Accumulator for full_name() */
56 };
57 
58 static QObjectInputVisitor *to_qiv(Visitor *v)
59 {
60     return container_of(v, QObjectInputVisitor, visitor);
61 }
62 
63 /*
64  * Find the full name of something @qiv is currently visiting.
65  * @qiv is visiting something named @name in the stack of containers
66  * @qiv->stack.
67  * If @n is zero, return its full name.
68  * If @n is positive, return the full name of the @n-th container
69  * counting from the top.  The stack of containers must have at least
70  * @n elements.
71  * The returned string is valid until the next full_name_nth(@v) or
72  * destruction of @v.
73  */
74 static const char *full_name_nth(QObjectInputVisitor *qiv, const char *name,
75                                  int n)
76 {
77     StackObject *so;
78     char buf[32];
79 
80     if (qiv->errname) {
81         g_string_truncate(qiv->errname, 0);
82     } else {
83         qiv->errname = g_string_new("");
84     }
85 
86     QSLIST_FOREACH(so , &qiv->stack, node) {
87         if (n) {
88             n--;
89         } else if (qobject_type(so->obj) == QTYPE_QDICT) {
90             g_string_prepend(qiv->errname, name ?: "<anonymous>");
91             g_string_prepend_c(qiv->errname, '.');
92         } else {
93             snprintf(buf, sizeof(buf),
94                      qiv->keyval ? ".%u" : "[%u]",
95                      so->index);
96             g_string_prepend(qiv->errname, buf);
97         }
98         name = so->name;
99     }
100     assert(!n);
101 
102     if (name) {
103         g_string_prepend(qiv->errname, name);
104     } else if (qiv->errname->str[0] == '.') {
105         g_string_erase(qiv->errname, 0, 1);
106     } else if (!qiv->errname->str[0]) {
107         return "<anonymous>";
108     }
109 
110     return qiv->errname->str;
111 }
112 
113 static const char *full_name(QObjectInputVisitor *qiv, const char *name)
114 {
115     return full_name_nth(qiv, name, 0);
116 }
117 
118 static QObject *qobject_input_try_get_object(QObjectInputVisitor *qiv,
119                                              const char *name,
120                                              bool consume)
121 {
122     StackObject *tos;
123     QObject *qobj;
124     QObject *ret;
125 
126     if (QSLIST_EMPTY(&qiv->stack)) {
127         /* Starting at root, name is ignored. */
128         assert(qiv->root);
129         return qiv->root;
130     }
131 
132     /* We are in a container; find the next element. */
133     tos = QSLIST_FIRST(&qiv->stack);
134     qobj = tos->obj;
135     assert(qobj);
136 
137     if (qobject_type(qobj) == QTYPE_QDICT) {
138         assert(name);
139         ret = qdict_get(qobject_to(QDict, qobj), name);
140         if (tos->h && consume && ret) {
141             bool removed = g_hash_table_remove(tos->h, name);
142             assert(removed);
143         }
144     } else {
145         assert(qobject_type(qobj) == QTYPE_QLIST);
146         assert(!name);
147         if (tos->entry) {
148             ret = qlist_entry_obj(tos->entry);
149             if (consume) {
150                 tos->entry = qlist_next(tos->entry);
151             }
152         } else {
153             ret = NULL;
154         }
155         if (consume) {
156             tos->index++;
157         }
158     }
159 
160     return ret;
161 }
162 
163 static QObject *qobject_input_get_object(QObjectInputVisitor *qiv,
164                                          const char *name,
165                                          bool consume, Error **errp)
166 {
167     QObject *obj = qobject_input_try_get_object(qiv, name, consume);
168 
169     if (!obj) {
170         error_setg(errp, QERR_MISSING_PARAMETER, full_name(qiv, name));
171     }
172     return obj;
173 }
174 
175 static const char *qobject_input_get_keyval(QObjectInputVisitor *qiv,
176                                             const char *name,
177                                             Error **errp)
178 {
179     QObject *qobj;
180     QString *qstr;
181 
182     qobj = qobject_input_get_object(qiv, name, true, errp);
183     if (!qobj) {
184         return NULL;
185     }
186 
187     qstr = qobject_to(QString, qobj);
188     if (!qstr) {
189         switch (qobject_type(qobj)) {
190         case QTYPE_QDICT:
191         case QTYPE_QLIST:
192             error_setg(errp, "Parameters '%s.*' are unexpected",
193                        full_name(qiv, name));
194             return NULL;
195         default:
196             /* Non-string scalar (should this be an assertion?) */
197             error_setg(errp, "Internal error: parameter %s invalid",
198                        full_name(qiv, name));
199             return NULL;
200         }
201     }
202 
203     return qstring_get_str(qstr);
204 }
205 
206 static void qdict_add_key(const char *key, QObject *obj, void *opaque)
207 {
208     GHashTable *h = opaque;
209     g_hash_table_insert(h, (gpointer) key, NULL);
210 }
211 
212 static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv,
213                                             const char *name,
214                                             QObject *obj, void *qapi)
215 {
216     GHashTable *h;
217     StackObject *tos = g_new0(StackObject, 1);
218 
219     assert(obj);
220     tos->name = name;
221     tos->obj = obj;
222     tos->qapi = qapi;
223 
224     if (qobject_type(obj) == QTYPE_QDICT) {
225         h = g_hash_table_new(g_str_hash, g_str_equal);
226         qdict_iter(qobject_to(QDict, obj), qdict_add_key, h);
227         tos->h = h;
228     } else {
229         assert(qobject_type(obj) == QTYPE_QLIST);
230         tos->entry = qlist_first(qobject_to(QList, obj));
231         tos->index = -1;
232     }
233 
234     QSLIST_INSERT_HEAD(&qiv->stack, tos, node);
235     return tos->entry;
236 }
237 
238 
239 static void qobject_input_check_struct(Visitor *v, Error **errp)
240 {
241     QObjectInputVisitor *qiv = to_qiv(v);
242     StackObject *tos = QSLIST_FIRST(&qiv->stack);
243     GHashTableIter iter;
244     const char *key;
245 
246     assert(tos && !tos->entry);
247 
248     g_hash_table_iter_init(&iter, tos->h);
249     if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
250         error_setg(errp, "Parameter '%s' is unexpected",
251                    full_name(qiv, key));
252     }
253 }
254 
255 static void qobject_input_stack_object_free(StackObject *tos)
256 {
257     if (tos->h) {
258         g_hash_table_unref(tos->h);
259     }
260 
261     g_free(tos);
262 }
263 
264 static void qobject_input_pop(Visitor *v, void **obj)
265 {
266     QObjectInputVisitor *qiv = to_qiv(v);
267     StackObject *tos = QSLIST_FIRST(&qiv->stack);
268 
269     assert(tos && tos->qapi == obj);
270     QSLIST_REMOVE_HEAD(&qiv->stack, node);
271     qobject_input_stack_object_free(tos);
272 }
273 
274 static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
275                                        size_t size, Error **errp)
276 {
277     QObjectInputVisitor *qiv = to_qiv(v);
278     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
279 
280     if (obj) {
281         *obj = NULL;
282     }
283     if (!qobj) {
284         return;
285     }
286     if (qobject_type(qobj) != QTYPE_QDICT) {
287         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
288                    full_name(qiv, name), "object");
289         return;
290     }
291 
292     qobject_input_push(qiv, name, qobj, obj);
293 
294     if (obj) {
295         *obj = g_malloc0(size);
296     }
297 }
298 
299 static void qobject_input_end_struct(Visitor *v, void **obj)
300 {
301     QObjectInputVisitor *qiv = to_qiv(v);
302     StackObject *tos = QSLIST_FIRST(&qiv->stack);
303 
304     assert(qobject_type(tos->obj) == QTYPE_QDICT && tos->h);
305     qobject_input_pop(v, obj);
306 }
307 
308 
309 static void qobject_input_start_list(Visitor *v, const char *name,
310                                      GenericList **list, size_t size,
311                                      Error **errp)
312 {
313     QObjectInputVisitor *qiv = to_qiv(v);
314     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
315     const QListEntry *entry;
316 
317     if (list) {
318         *list = NULL;
319     }
320     if (!qobj) {
321         return;
322     }
323     if (qobject_type(qobj) != QTYPE_QLIST) {
324         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
325                    full_name(qiv, name), "array");
326         return;
327     }
328 
329     entry = qobject_input_push(qiv, name, qobj, list);
330     if (entry && list) {
331         *list = g_malloc0(size);
332     }
333 }
334 
335 static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail,
336                                             size_t size)
337 {
338     QObjectInputVisitor *qiv = to_qiv(v);
339     StackObject *tos = QSLIST_FIRST(&qiv->stack);
340 
341     assert(tos && qobject_to(QList, tos->obj));
342 
343     if (!tos->entry) {
344         return NULL;
345     }
346     tail->next = g_malloc0(size);
347     return tail->next;
348 }
349 
350 static void qobject_input_check_list(Visitor *v, Error **errp)
351 {
352     QObjectInputVisitor *qiv = to_qiv(v);
353     StackObject *tos = QSLIST_FIRST(&qiv->stack);
354 
355     assert(tos && qobject_to(QList, tos->obj));
356 
357     if (tos->entry) {
358         error_setg(errp, "Only %u list elements expected in %s",
359                    tos->index + 1, full_name_nth(qiv, NULL, 1));
360     }
361 }
362 
363 static void qobject_input_end_list(Visitor *v, void **obj)
364 {
365     QObjectInputVisitor *qiv = to_qiv(v);
366     StackObject *tos = QSLIST_FIRST(&qiv->stack);
367 
368     assert(qobject_type(tos->obj) == QTYPE_QLIST && !tos->h);
369     qobject_input_pop(v, obj);
370 }
371 
372 static void qobject_input_start_alternate(Visitor *v, const char *name,
373                                           GenericAlternate **obj, size_t size,
374                                           Error **errp)
375 {
376     QObjectInputVisitor *qiv = to_qiv(v);
377     QObject *qobj = qobject_input_get_object(qiv, name, false, errp);
378 
379     if (!qobj) {
380         *obj = NULL;
381         return;
382     }
383     *obj = g_malloc0(size);
384     (*obj)->type = qobject_type(qobj);
385 }
386 
387 static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj,
388                                      Error **errp)
389 {
390     QObjectInputVisitor *qiv = to_qiv(v);
391     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
392     QNum *qnum;
393 
394     if (!qobj) {
395         return;
396     }
397     qnum = qobject_to(QNum, qobj);
398     if (!qnum || !qnum_get_try_int(qnum, obj)) {
399         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
400                    full_name(qiv, name), "integer");
401     }
402 }
403 
404 static void qobject_input_type_int64_keyval(Visitor *v, const char *name,
405                                             int64_t *obj, Error **errp)
406 {
407     QObjectInputVisitor *qiv = to_qiv(v);
408     const char *str = qobject_input_get_keyval(qiv, name, errp);
409 
410     if (!str) {
411         return;
412     }
413 
414     if (qemu_strtoi64(str, NULL, 0, obj) < 0) {
415         /* TODO report -ERANGE more nicely */
416         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
417                    full_name(qiv, name), "integer");
418     }
419 }
420 
421 static void qobject_input_type_uint64(Visitor *v, const char *name,
422                                       uint64_t *obj, Error **errp)
423 {
424     QObjectInputVisitor *qiv = to_qiv(v);
425     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
426     QNum *qnum;
427     int64_t val;
428 
429     if (!qobj) {
430         return;
431     }
432     qnum = qobject_to(QNum, qobj);
433     if (!qnum) {
434         goto err;
435     }
436 
437     if (qnum_get_try_uint(qnum, obj)) {
438         return;
439     }
440 
441     /* Need to accept negative values for backward compatibility */
442     if (qnum_get_try_int(qnum, &val)) {
443         *obj = val;
444         return;
445     }
446 
447 err:
448     error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
449                full_name(qiv, name), "uint64");
450 }
451 
452 static void qobject_input_type_uint64_keyval(Visitor *v, const char *name,
453                                              uint64_t *obj, Error **errp)
454 {
455     QObjectInputVisitor *qiv = to_qiv(v);
456     const char *str = qobject_input_get_keyval(qiv, name, errp);
457 
458     if (!str) {
459         return;
460     }
461 
462     if (qemu_strtou64(str, NULL, 0, obj) < 0) {
463         /* TODO report -ERANGE more nicely */
464         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
465                    full_name(qiv, name), "integer");
466     }
467 }
468 
469 static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj,
470                                     Error **errp)
471 {
472     QObjectInputVisitor *qiv = to_qiv(v);
473     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
474     QBool *qbool;
475 
476     if (!qobj) {
477         return;
478     }
479     qbool = qobject_to(QBool, qobj);
480     if (!qbool) {
481         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
482                    full_name(qiv, name), "boolean");
483         return;
484     }
485 
486     *obj = qbool_get_bool(qbool);
487 }
488 
489 static void qobject_input_type_bool_keyval(Visitor *v, const char *name,
490                                            bool *obj, Error **errp)
491 {
492     QObjectInputVisitor *qiv = to_qiv(v);
493     const char *str = qobject_input_get_keyval(qiv, name, errp);
494 
495     if (!str) {
496         return;
497     }
498 
499     if (!strcmp(str, "on")) {
500         *obj = true;
501     } else if (!strcmp(str, "off")) {
502         *obj = false;
503     } else {
504         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
505                    full_name(qiv, name), "'on' or 'off'");
506     }
507 }
508 
509 static void qobject_input_type_str(Visitor *v, const char *name, char **obj,
510                                    Error **errp)
511 {
512     QObjectInputVisitor *qiv = to_qiv(v);
513     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
514     QString *qstr;
515 
516     *obj = NULL;
517     if (!qobj) {
518         return;
519     }
520     qstr = qobject_to(QString, qobj);
521     if (!qstr) {
522         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
523                    full_name(qiv, name), "string");
524         return;
525     }
526 
527     *obj = g_strdup(qstring_get_str(qstr));
528 }
529 
530 static void qobject_input_type_str_keyval(Visitor *v, const char *name,
531                                           char **obj, Error **errp)
532 {
533     QObjectInputVisitor *qiv = to_qiv(v);
534     const char *str = qobject_input_get_keyval(qiv, name, errp);
535 
536     *obj = g_strdup(str);
537 }
538 
539 static void qobject_input_type_number(Visitor *v, const char *name, double *obj,
540                                       Error **errp)
541 {
542     QObjectInputVisitor *qiv = to_qiv(v);
543     QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
544     QNum *qnum;
545 
546     if (!qobj) {
547         return;
548     }
549     qnum = qobject_to(QNum, qobj);
550     if (!qnum) {
551         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
552                    full_name(qiv, name), "number");
553         return;
554     }
555 
556     *obj = qnum_get_double(qnum);
557 }
558 
559 static void qobject_input_type_number_keyval(Visitor *v, const char *name,
560                                              double *obj, Error **errp)
561 {
562     QObjectInputVisitor *qiv = to_qiv(v);
563     const char *str = qobject_input_get_keyval(qiv, name, errp);
564     double val;
565 
566     if (!str) {
567         return;
568     }
569 
570     if (qemu_strtod_finite(str, NULL, &val)) {
571         /* TODO report -ERANGE more nicely */
572         error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
573                    full_name(qiv, name), "number");
574         return;
575     }
576 
577     *obj = val;
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             return NULL;
729         }
730         args = qobject_to(QDict, obj);
731         assert(args);
732         v = qobject_input_visitor_new(QOBJECT(args));
733     } else {
734         args = keyval_parse(str, implied_key, errp);
735         if (!args) {
736             return NULL;
737         }
738         v = qobject_input_visitor_new_keyval(QOBJECT(args));
739     }
740     qobject_unref(args);
741 
742     return v;
743 }
744