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