Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-03-16' into staging
[qemu.git] / 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 "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 }