]>
Commit | Line | Data |
---|---|---|
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/keyval.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 | ||
48 | /* Root of visit at visitor creation. */ | |
49 | QObject *root; | |
50 | bool keyval; /* Assume @root made with keyval_parse() */ | |
51 | ||
52 | /* Stack of objects being visited (all entries will be either | |
53 | * QDict or QList). */ | |
54 | QSLIST_HEAD(, StackObject) stack; | |
55 | ||
56 | GString *errname; /* Accumulator for full_name() */ | |
57 | }; | |
58 | ||
59 | static QObjectInputVisitor *to_qiv(Visitor *v) | |
60 | { | |
61 | return container_of(v, QObjectInputVisitor, visitor); | |
62 | } | |
63 | ||
64 | /* | |
65 | * Find the full name of something @qiv is currently visiting. | |
66 | * @qiv is visiting something named @name in the stack of containers | |
67 | * @qiv->stack. | |
68 | * If @n is zero, return its full name. | |
69 | * If @n is positive, return the full name of the @n-th container | |
70 | * counting from the top. The stack of containers must have at least | |
71 | * @n elements. | |
72 | * The returned string is valid until the next full_name_nth(@v) or | |
73 | * destruction of @v. | |
74 | */ | |
75 | static 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 | ||
114 | static const char *full_name(QObjectInputVisitor *qiv, const char *name) | |
115 | { | |
116 | return full_name_nth(qiv, name, 0); | |
117 | } | |
118 | ||
119 | static 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 | /* Starting at root, name is ignored. */ | |
129 | assert(qiv->root); | |
130 | return qiv->root; | |
131 | } | |
132 | ||
133 | /* We are in a container; find the next element. */ | |
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 | ||
164 | static 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 | ||
176 | static 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 | /* Non-string scalar (should this be an assertion?) */ | |
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 | ||
207 | static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv, | |
208 | const char *name, | |
209 | QObject *obj, void *qapi) | |
210 | { | |
211 | GHashTable *h; | |
212 | StackObject *tos = g_new0(StackObject, 1); | |
213 | QDict *qdict = qobject_to(QDict, obj); | |
214 | QList *qlist = qobject_to(QList, obj); | |
215 | const QDictEntry *entry; | |
216 | ||
217 | assert(obj); | |
218 | tos->name = name; | |
219 | tos->obj = obj; | |
220 | tos->qapi = qapi; | |
221 | ||
222 | if (qdict) { | |
223 | h = g_hash_table_new(g_str_hash, g_str_equal); | |
224 | for (entry = qdict_first(qdict); | |
225 | entry; | |
226 | entry = qdict_next(qdict, entry)) { | |
227 | g_hash_table_insert(h, (void *)qdict_entry_key(entry), NULL); | |
228 | } | |
229 | tos->h = h; | |
230 | } else { | |
231 | assert(qlist); | |
232 | tos->entry = qlist_first(qlist); | |
233 | tos->index = -1; | |
234 | } | |
235 | ||
236 | QSLIST_INSERT_HEAD(&qiv->stack, tos, node); | |
237 | return tos->entry; | |
238 | } | |
239 | ||
240 | ||
241 | static bool qobject_input_check_struct(Visitor *v, Error **errp) | |
242 | { | |
243 | QObjectInputVisitor *qiv = to_qiv(v); | |
244 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
245 | GHashTableIter iter; | |
246 | const char *key; | |
247 | ||
248 | assert(tos && !tos->entry); | |
249 | ||
250 | g_hash_table_iter_init(&iter, tos->h); | |
251 | if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) { | |
252 | error_setg(errp, "Parameter '%s' is unexpected", | |
253 | full_name(qiv, key)); | |
254 | return false; | |
255 | } | |
256 | return true; | |
257 | } | |
258 | ||
259 | static void qobject_input_stack_object_free(StackObject *tos) | |
260 | { | |
261 | if (tos->h) { | |
262 | g_hash_table_unref(tos->h); | |
263 | } | |
264 | ||
265 | g_free(tos); | |
266 | } | |
267 | ||
268 | static void qobject_input_pop(Visitor *v, void **obj) | |
269 | { | |
270 | QObjectInputVisitor *qiv = to_qiv(v); | |
271 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
272 | ||
273 | assert(tos && tos->qapi == obj); | |
274 | QSLIST_REMOVE_HEAD(&qiv->stack, node); | |
275 | qobject_input_stack_object_free(tos); | |
276 | } | |
277 | ||
278 | static bool qobject_input_start_struct(Visitor *v, const char *name, void **obj, | |
279 | size_t size, Error **errp) | |
280 | { | |
281 | QObjectInputVisitor *qiv = to_qiv(v); | |
282 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
283 | ||
284 | if (obj) { | |
285 | *obj = NULL; | |
286 | } | |
287 | if (!qobj) { | |
288 | return false; | |
289 | } | |
290 | if (qobject_type(qobj) != QTYPE_QDICT) { | |
291 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
292 | full_name(qiv, name), "object"); | |
293 | return false; | |
294 | } | |
295 | ||
296 | qobject_input_push(qiv, name, qobj, obj); | |
297 | ||
298 | if (obj) { | |
299 | *obj = g_malloc0(size); | |
300 | } | |
301 | return true; | |
302 | } | |
303 | ||
304 | static void qobject_input_end_struct(Visitor *v, void **obj) | |
305 | { | |
306 | QObjectInputVisitor *qiv = to_qiv(v); | |
307 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
308 | ||
309 | assert(qobject_type(tos->obj) == QTYPE_QDICT && tos->h); | |
310 | qobject_input_pop(v, obj); | |
311 | } | |
312 | ||
313 | ||
314 | static bool qobject_input_start_list(Visitor *v, const char *name, | |
315 | GenericList **list, size_t size, | |
316 | Error **errp) | |
317 | { | |
318 | QObjectInputVisitor *qiv = to_qiv(v); | |
319 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
320 | const QListEntry *entry; | |
321 | ||
322 | if (list) { | |
323 | *list = NULL; | |
324 | } | |
325 | if (!qobj) { | |
326 | return false; | |
327 | } | |
328 | if (qobject_type(qobj) != QTYPE_QLIST) { | |
329 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
330 | full_name(qiv, name), "array"); | |
331 | return false; | |
332 | } | |
333 | ||
334 | entry = qobject_input_push(qiv, name, qobj, list); | |
335 | if (entry && list) { | |
336 | *list = g_malloc0(size); | |
337 | } | |
338 | return true; | |
339 | } | |
340 | ||
341 | static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail, | |
342 | size_t size) | |
343 | { | |
344 | QObjectInputVisitor *qiv = to_qiv(v); | |
345 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
346 | ||
347 | assert(tos && qobject_to(QList, tos->obj)); | |
348 | ||
349 | if (!tos->entry) { | |
350 | return NULL; | |
351 | } | |
352 | tail->next = g_malloc0(size); | |
353 | return tail->next; | |
354 | } | |
355 | ||
356 | static bool qobject_input_check_list(Visitor *v, Error **errp) | |
357 | { | |
358 | QObjectInputVisitor *qiv = to_qiv(v); | |
359 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
360 | ||
361 | assert(tos && qobject_to(QList, tos->obj)); | |
362 | ||
363 | if (tos->entry) { | |
364 | error_setg(errp, "Only %u list elements expected in %s", | |
365 | tos->index + 1, full_name_nth(qiv, NULL, 1)); | |
366 | return false; | |
367 | } | |
368 | return true; | |
369 | } | |
370 | ||
371 | static void qobject_input_end_list(Visitor *v, void **obj) | |
372 | { | |
373 | QObjectInputVisitor *qiv = to_qiv(v); | |
374 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
375 | ||
376 | assert(qobject_type(tos->obj) == QTYPE_QLIST && !tos->h); | |
377 | qobject_input_pop(v, obj); | |
378 | } | |
379 | ||
380 | static bool qobject_input_start_alternate(Visitor *v, const char *name, | |
381 | GenericAlternate **obj, size_t size, | |
382 | Error **errp) | |
383 | { | |
384 | QObjectInputVisitor *qiv = to_qiv(v); | |
385 | QObject *qobj = qobject_input_get_object(qiv, name, false, errp); | |
386 | ||
387 | if (!qobj) { | |
388 | *obj = NULL; | |
389 | return false; | |
390 | } | |
391 | *obj = g_malloc0(size); | |
392 | (*obj)->type = qobject_type(qobj); | |
393 | return true; | |
394 | } | |
395 | ||
396 | static bool qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj, | |
397 | Error **errp) | |
398 | { | |
399 | QObjectInputVisitor *qiv = to_qiv(v); | |
400 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
401 | QNum *qnum; | |
402 | ||
403 | if (!qobj) { | |
404 | return false; | |
405 | } | |
406 | qnum = qobject_to(QNum, qobj); | |
407 | if (!qnum || !qnum_get_try_int(qnum, obj)) { | |
408 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
409 | full_name(qiv, name), "integer"); | |
410 | return false; | |
411 | } | |
412 | return true; | |
413 | } | |
414 | ||
415 | static bool qobject_input_type_int64_keyval(Visitor *v, const char *name, | |
416 | int64_t *obj, Error **errp) | |
417 | { | |
418 | QObjectInputVisitor *qiv = to_qiv(v); | |
419 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
420 | ||
421 | if (!str) { | |
422 | return false; | |
423 | } | |
424 | ||
425 | if (qemu_strtoi64(str, NULL, 0, obj) < 0) { | |
426 | /* TODO report -ERANGE more nicely */ | |
427 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, | |
428 | full_name(qiv, name), "integer"); | |
429 | return false; | |
430 | } | |
431 | return true; | |
432 | } | |
433 | ||
434 | static bool qobject_input_type_uint64(Visitor *v, const char *name, | |
435 | uint64_t *obj, Error **errp) | |
436 | { | |
437 | QObjectInputVisitor *qiv = to_qiv(v); | |
438 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
439 | QNum *qnum; | |
440 | int64_t val; | |
441 | ||
442 | if (!qobj) { | |
443 | return false; | |
444 | } | |
445 | qnum = qobject_to(QNum, qobj); | |
446 | if (!qnum) { | |
447 | goto err; | |
448 | } | |
449 | ||
450 | if (qnum_get_try_uint(qnum, obj)) { | |
451 | return true; | |
452 | } | |
453 | ||
454 | /* Need to accept negative values for backward compatibility */ | |
455 | if (qnum_get_try_int(qnum, &val)) { | |
456 | *obj = val; | |
457 | return true; | |
458 | } | |
459 | ||
460 | err: | |
461 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, | |
462 | full_name(qiv, name), "uint64"); | |
463 | return false; | |
464 | } | |
465 | ||
466 | static bool qobject_input_type_uint64_keyval(Visitor *v, const char *name, | |
467 | uint64_t *obj, Error **errp) | |
468 | { | |
469 | QObjectInputVisitor *qiv = to_qiv(v); | |
470 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
471 | ||
472 | if (!str) { | |
473 | return false; | |
474 | } | |
475 | ||
476 | if (qemu_strtou64(str, NULL, 0, obj) < 0) { | |
477 | /* TODO report -ERANGE more nicely */ | |
478 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, | |
479 | full_name(qiv, name), "integer"); | |
480 | return false; | |
481 | } | |
482 | return true; | |
483 | } | |
484 | ||
485 | static bool qobject_input_type_bool(Visitor *v, const char *name, bool *obj, | |
486 | Error **errp) | |
487 | { | |
488 | QObjectInputVisitor *qiv = to_qiv(v); | |
489 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
490 | QBool *qbool; | |
491 | ||
492 | if (!qobj) { | |
493 | return false; | |
494 | } | |
495 | qbool = qobject_to(QBool, qobj); | |
496 | if (!qbool) { | |
497 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
498 | full_name(qiv, name), "boolean"); | |
499 | return false; | |
500 | } | |
501 | ||
502 | *obj = qbool_get_bool(qbool); | |
503 | return true; | |
504 | } | |
505 | ||
506 | static bool qobject_input_type_bool_keyval(Visitor *v, const char *name, | |
507 | bool *obj, Error **errp) | |
508 | { | |
509 | QObjectInputVisitor *qiv = to_qiv(v); | |
510 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
511 | ||
512 | if (!str) { | |
513 | return false; | |
514 | } | |
515 | ||
516 | if (!qapi_bool_parse(name, str, obj, NULL)) { | |
517 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, | |
518 | full_name(qiv, name), "'on' or 'off'"); | |
519 | return false; | |
520 | } | |
521 | return true; | |
522 | } | |
523 | ||
524 | static bool qobject_input_type_str(Visitor *v, const char *name, char **obj, | |
525 | Error **errp) | |
526 | { | |
527 | QObjectInputVisitor *qiv = to_qiv(v); | |
528 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
529 | QString *qstr; | |
530 | ||
531 | *obj = NULL; | |
532 | if (!qobj) { | |
533 | return false; | |
534 | } | |
535 | qstr = qobject_to(QString, qobj); | |
536 | if (!qstr) { | |
537 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
538 | full_name(qiv, name), "string"); | |
539 | return false; | |
540 | } | |
541 | ||
542 | *obj = g_strdup(qstring_get_str(qstr)); | |
543 | return true; | |
544 | } | |
545 | ||
546 | static bool qobject_input_type_str_keyval(Visitor *v, const char *name, | |
547 | char **obj, Error **errp) | |
548 | { | |
549 | QObjectInputVisitor *qiv = to_qiv(v); | |
550 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
551 | ||
552 | *obj = g_strdup(str); | |
553 | return !!str; | |
554 | } | |
555 | ||
556 | static bool qobject_input_type_number(Visitor *v, const char *name, double *obj, | |
557 | Error **errp) | |
558 | { | |
559 | QObjectInputVisitor *qiv = to_qiv(v); | |
560 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
561 | QNum *qnum; | |
562 | ||
563 | if (!qobj) { | |
564 | return false; | |
565 | } | |
566 | qnum = qobject_to(QNum, qobj); | |
567 | if (!qnum) { | |
568 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
569 | full_name(qiv, name), "number"); | |
570 | return false; | |
571 | } | |
572 | ||
573 | *obj = qnum_get_double(qnum); | |
574 | return true; | |
575 | } | |
576 | ||
577 | static bool qobject_input_type_number_keyval(Visitor *v, const char *name, | |
578 | double *obj, Error **errp) | |
579 | { | |
580 | QObjectInputVisitor *qiv = to_qiv(v); | |
581 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
582 | double val; | |
583 | ||
584 | if (!str) { | |
585 | return false; | |
586 | } | |
587 | ||
588 | if (qemu_strtod_finite(str, NULL, &val)) { | |
589 | /* TODO report -ERANGE more nicely */ | |
590 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
591 | full_name(qiv, name), "number"); | |
592 | return false; | |
593 | } | |
594 | ||
595 | *obj = val; | |
596 | return true; | |
597 | } | |
598 | ||
599 | static bool qobject_input_type_any(Visitor *v, const char *name, QObject **obj, | |
600 | Error **errp) | |
601 | { | |
602 | QObjectInputVisitor *qiv = to_qiv(v); | |
603 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
604 | ||
605 | *obj = NULL; | |
606 | if (!qobj) { | |
607 | return false; | |
608 | } | |
609 | ||
610 | *obj = qobject_ref(qobj); | |
611 | return true; | |
612 | } | |
613 | ||
614 | static bool qobject_input_type_null(Visitor *v, const char *name, | |
615 | QNull **obj, Error **errp) | |
616 | { | |
617 | QObjectInputVisitor *qiv = to_qiv(v); | |
618 | QObject *qobj = qobject_input_get_object(qiv, name, true, errp); | |
619 | ||
620 | *obj = NULL; | |
621 | if (!qobj) { | |
622 | return false; | |
623 | } | |
624 | ||
625 | if (qobject_type(qobj) != QTYPE_QNULL) { | |
626 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, | |
627 | full_name(qiv, name), "null"); | |
628 | return false; | |
629 | } | |
630 | *obj = qnull(); | |
631 | return true; | |
632 | } | |
633 | ||
634 | static bool qobject_input_type_size_keyval(Visitor *v, const char *name, | |
635 | uint64_t *obj, Error **errp) | |
636 | { | |
637 | QObjectInputVisitor *qiv = to_qiv(v); | |
638 | const char *str = qobject_input_get_keyval(qiv, name, errp); | |
639 | ||
640 | if (!str) { | |
641 | return false; | |
642 | } | |
643 | ||
644 | if (qemu_strtosz(str, NULL, obj) < 0) { | |
645 | /* TODO report -ERANGE more nicely */ | |
646 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, | |
647 | full_name(qiv, name), "size"); | |
648 | return false; | |
649 | } | |
650 | return true; | |
651 | } | |
652 | ||
653 | static void qobject_input_optional(Visitor *v, const char *name, bool *present) | |
654 | { | |
655 | QObjectInputVisitor *qiv = to_qiv(v); | |
656 | QObject *qobj = qobject_input_try_get_object(qiv, name, false); | |
657 | ||
658 | if (!qobj) { | |
659 | *present = false; | |
660 | return; | |
661 | } | |
662 | ||
663 | *present = true; | |
664 | } | |
665 | ||
666 | static bool qobject_input_policy_reject(Visitor *v, const char *name, | |
667 | unsigned special_features, | |
668 | Error **errp) | |
669 | { | |
670 | return !compat_policy_input_ok(special_features, &v->compat_policy, | |
671 | ERROR_CLASS_GENERIC_ERROR, | |
672 | "parameter", name, errp); | |
673 | } | |
674 | ||
675 | static void qobject_input_free(Visitor *v) | |
676 | { | |
677 | QObjectInputVisitor *qiv = to_qiv(v); | |
678 | ||
679 | while (!QSLIST_EMPTY(&qiv->stack)) { | |
680 | StackObject *tos = QSLIST_FIRST(&qiv->stack); | |
681 | ||
682 | QSLIST_REMOVE_HEAD(&qiv->stack, node); | |
683 | qobject_input_stack_object_free(tos); | |
684 | } | |
685 | ||
686 | qobject_unref(qiv->root); | |
687 | if (qiv->errname) { | |
688 | g_string_free(qiv->errname, TRUE); | |
689 | } | |
690 | g_free(qiv); | |
691 | } | |
692 | ||
693 | static QObjectInputVisitor *qobject_input_visitor_base_new(QObject *obj) | |
694 | { | |
695 | QObjectInputVisitor *v = g_malloc0(sizeof(*v)); | |
696 | ||
697 | assert(obj); | |
698 | ||
699 | v->visitor.type = VISITOR_INPUT; | |
700 | v->visitor.start_struct = qobject_input_start_struct; | |
701 | v->visitor.check_struct = qobject_input_check_struct; | |
702 | v->visitor.end_struct = qobject_input_end_struct; | |
703 | v->visitor.start_list = qobject_input_start_list; | |
704 | v->visitor.next_list = qobject_input_next_list; | |
705 | v->visitor.check_list = qobject_input_check_list; | |
706 | v->visitor.end_list = qobject_input_end_list; | |
707 | v->visitor.start_alternate = qobject_input_start_alternate; | |
708 | v->visitor.optional = qobject_input_optional; | |
709 | v->visitor.policy_reject = qobject_input_policy_reject; | |
710 | v->visitor.free = qobject_input_free; | |
711 | ||
712 | v->root = qobject_ref(obj); | |
713 | ||
714 | return v; | |
715 | } | |
716 | ||
717 | Visitor *qobject_input_visitor_new(QObject *obj) | |
718 | { | |
719 | QObjectInputVisitor *v = qobject_input_visitor_base_new(obj); | |
720 | ||
721 | v->visitor.type_int64 = qobject_input_type_int64; | |
722 | v->visitor.type_uint64 = qobject_input_type_uint64; | |
723 | v->visitor.type_bool = qobject_input_type_bool; | |
724 | v->visitor.type_str = qobject_input_type_str; | |
725 | v->visitor.type_number = qobject_input_type_number; | |
726 | v->visitor.type_any = qobject_input_type_any; | |
727 | v->visitor.type_null = qobject_input_type_null; | |
728 | ||
729 | return &v->visitor; | |
730 | } | |
731 | ||
732 | Visitor *qobject_input_visitor_new_keyval(QObject *obj) | |
733 | { | |
734 | QObjectInputVisitor *v = qobject_input_visitor_base_new(obj); | |
735 | ||
736 | v->visitor.type_int64 = qobject_input_type_int64_keyval; | |
737 | v->visitor.type_uint64 = qobject_input_type_uint64_keyval; | |
738 | v->visitor.type_bool = qobject_input_type_bool_keyval; | |
739 | v->visitor.type_str = qobject_input_type_str_keyval; | |
740 | v->visitor.type_number = qobject_input_type_number_keyval; | |
741 | v->visitor.type_any = qobject_input_type_any; | |
742 | v->visitor.type_null = qobject_input_type_null; | |
743 | v->visitor.type_size = qobject_input_type_size_keyval; | |
744 | v->keyval = true; | |
745 | ||
746 | return &v->visitor; | |
747 | } | |
748 | ||
749 | Visitor *qobject_input_visitor_new_str(const char *str, | |
750 | const char *implied_key, | |
751 | Error **errp) | |
752 | { | |
753 | bool is_json = str[0] == '{'; | |
754 | QObject *obj; | |
755 | QDict *args; | |
756 | Visitor *v; | |
757 | ||
758 | if (is_json) { | |
759 | obj = qobject_from_json(str, errp); | |
760 | if (!obj) { | |
761 | return NULL; | |
762 | } | |
763 | args = qobject_to(QDict, obj); | |
764 | assert(args); | |
765 | v = qobject_input_visitor_new(QOBJECT(args)); | |
766 | } else { | |
767 | args = keyval_parse(str, implied_key, NULL, errp); | |
768 | if (!args) { | |
769 | return NULL; | |
770 | } | |
771 | v = qobject_input_visitor_new_keyval(QOBJECT(args)); | |
772 | } | |
773 | qobject_unref(args); | |
774 | ||
775 | return v; | |
776 | } |