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