1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "qapi/qmp-input-visitor.h"
15#include "qapi/visitor-impl.h"
16#include "qemu/queue.h"
17#include "qemu-common.h"
18#include "qapi/qmp/types.h"
19#include "qapi/qmp/qerror.h"
20
21#define QIV_STACK_SIZE 1024
22
23typedef struct StackObject
24{
25 QObject *obj;
26 const QListEntry *entry;
27 GHashTable *h;
28} StackObject;
29
30struct QmpInputVisitor
31{
32 Visitor visitor;
33 StackObject stack[QIV_STACK_SIZE];
34 int nb_stack;
35 bool strict;
36};
37
38static QmpInputVisitor *to_qiv(Visitor *v)
39{
40 return container_of(v, QmpInputVisitor, visitor);
41}
42
43static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
44 const char *name)
45{
46 QObject *qobj = qiv->stack[qiv->nb_stack - 1].obj;
47
48 if (qobj) {
49 if (name && qobject_type(qobj) == QTYPE_QDICT) {
50 if (qiv->stack[qiv->nb_stack - 1].h) {
51 g_hash_table_remove(qiv->stack[qiv->nb_stack - 1].h, name);
52 }
53 return qdict_get(qobject_to_qdict(qobj), name);
54 } else if (qiv->stack[qiv->nb_stack - 1].entry) {
55 return qlist_entry_obj(qiv->stack[qiv->nb_stack - 1].entry);
56 }
57 }
58
59 return qobj;
60}
61
62static void qdict_add_key(const char *key, QObject *obj, void *opaque)
63{
64 GHashTable *h = opaque;
65 g_hash_table_insert(h, (gpointer) key, NULL);
66}
67
68static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
69{
70 GHashTable *h;
71
72 if (qiv->nb_stack >= QIV_STACK_SIZE) {
73 error_set(errp, QERR_BUFFER_OVERRUN);
74 return;
75 }
76
77 qiv->stack[qiv->nb_stack].obj = obj;
78 qiv->stack[qiv->nb_stack].entry = NULL;
79 qiv->stack[qiv->nb_stack].h = NULL;
80
81 if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
82 h = g_hash_table_new(g_str_hash, g_str_equal);
83 qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
84 qiv->stack[qiv->nb_stack].h = h;
85 }
86
87 qiv->nb_stack++;
88}
89
90
91static gboolean always_true(gpointer key, gpointer val, gpointer user_pkey)
92{
93 *(const char **)user_pkey = (const char *)key;
94 return TRUE;
95}
96
97static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
98{
99 assert(qiv->nb_stack > 0);
100
101 if (qiv->strict) {
102 GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
103 if (top_ht) {
104 if (g_hash_table_size(top_ht)) {
105 const char *key;
106 g_hash_table_find(top_ht, always_true, &key);
107 error_set(errp, QERR_QMP_EXTRA_MEMBER, key);
108 }
109 g_hash_table_unref(top_ht);
110 }
111 }
112
113 qiv->nb_stack--;
114}
115
116static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
117 const char *name, size_t size, Error **errp)
118{
119 QmpInputVisitor *qiv = to_qiv(v);
120 QObject *qobj = qmp_input_get_object(qiv, name);
121 Error *err = NULL;
122
123 if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
124 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
125 "QDict");
126 return;
127 }
128
129 qmp_input_push(qiv, qobj, &err);
130 if (err) {
131 error_propagate(errp, err);
132 return;
133 }
134
135 if (obj) {
136 *obj = g_malloc0(size);
137 }
138}
139
140static void qmp_input_end_struct(Visitor *v, Error **errp)
141{
142 QmpInputVisitor *qiv = to_qiv(v);
143
144 qmp_input_pop(qiv, errp);
145}
146
147static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
148{
149 QmpInputVisitor *qiv = to_qiv(v);
150 QObject *qobj = qmp_input_get_object(qiv, name);
151
152 if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
153 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
154 "list");
155 return;
156 }
157
158 qmp_input_push(qiv, qobj, errp);
159}
160
161static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
162 Error **errp)
163{
164 QmpInputVisitor *qiv = to_qiv(v);
165 GenericList *entry;
166 StackObject *so = &qiv->stack[qiv->nb_stack - 1];
167 bool first;
168
169 if (so->entry == NULL) {
170 so->entry = qlist_first(qobject_to_qlist(so->obj));
171 first = true;
172 } else {
173 so->entry = qlist_next(so->entry);
174 first = false;
175 }
176
177 if (so->entry == NULL) {
178 return NULL;
179 }
180
181 entry = g_malloc0(sizeof(*entry));
182 if (first) {
183 *list = entry;
184 } else {
185 (*list)->next = entry;
186 }
187
188 return entry;
189}
190
191static void qmp_input_end_list(Visitor *v, Error **errp)
192{
193 QmpInputVisitor *qiv = to_qiv(v);
194
195 qmp_input_pop(qiv, errp);
196}
197
198static void qmp_input_type_int(Visitor *v, int64_t *obj, const char *name,
199 Error **errp)
200{
201 QmpInputVisitor *qiv = to_qiv(v);
202 QObject *qobj = qmp_input_get_object(qiv, name);
203
204 if (!qobj || qobject_type(qobj) != QTYPE_QINT) {
205 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
206 "integer");
207 return;
208 }
209
210 *obj = qint_get_int(qobject_to_qint(qobj));
211}
212
213static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name,
214 Error **errp)
215{
216 QmpInputVisitor *qiv = to_qiv(v);
217 QObject *qobj = qmp_input_get_object(qiv, name);
218
219 if (!qobj || qobject_type(qobj) != QTYPE_QBOOL) {
220 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
221 "boolean");
222 return;
223 }
224
225 *obj = qbool_get_int(qobject_to_qbool(qobj));
226}
227
228static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
229 Error **errp)
230{
231 QmpInputVisitor *qiv = to_qiv(v);
232 QObject *qobj = qmp_input_get_object(qiv, name);
233
234 if (!qobj || qobject_type(qobj) != QTYPE_QSTRING) {
235 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
236 "string");
237 return;
238 }
239
240 *obj = g_strdup(qstring_get_str(qobject_to_qstring(qobj)));
241}
242
243static void qmp_input_type_number(Visitor *v, double *obj, const char *name,
244 Error **errp)
245{
246 QmpInputVisitor *qiv = to_qiv(v);
247 QObject *qobj = qmp_input_get_object(qiv, name);
248
249 if (!qobj || (qobject_type(qobj) != QTYPE_QFLOAT &&
250 qobject_type(qobj) != QTYPE_QINT)) {
251 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
252 "number");
253 return;
254 }
255
256 if (qobject_type(qobj) == QTYPE_QINT) {
257 *obj = qint_get_int(qobject_to_qint(qobj));
258 } else {
259 *obj = qfloat_get_double(qobject_to_qfloat(qobj));
260 }
261}
262
263static void qmp_input_start_optional(Visitor *v, bool *present,
264 const char *name, Error **errp)
265{
266 QmpInputVisitor *qiv = to_qiv(v);
267 QObject *qobj = qmp_input_get_object(qiv, name);
268
269 if (!qobj) {
270 *present = false;
271 return;
272 }
273
274 *present = true;
275}
276
277Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
278{
279 return &v->visitor;
280}
281
282void qmp_input_visitor_cleanup(QmpInputVisitor *v)
283{
284 qobject_decref(v->stack[0].obj);
285 g_free(v);
286}
287
288QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
289{
290 QmpInputVisitor *v;
291
292 v = g_malloc0(sizeof(*v));
293
294 v->visitor.start_struct = qmp_input_start_struct;
295 v->visitor.end_struct = qmp_input_end_struct;
296 v->visitor.start_list = qmp_input_start_list;
297 v->visitor.next_list = qmp_input_next_list;
298 v->visitor.end_list = qmp_input_end_list;
299 v->visitor.type_enum = input_type_enum;
300 v->visitor.type_int = qmp_input_type_int;
301 v->visitor.type_bool = qmp_input_type_bool;
302 v->visitor.type_str = qmp_input_type_str;
303 v->visitor.type_number = qmp_input_type_number;
304 v->visitor.start_optional = qmp_input_start_optional;
305
306 qmp_input_push(v, obj, NULL);
307 qobject_incref(obj);
308
309 return v;
310}
311
312QmpInputVisitor *qmp_input_visitor_new_strict(QObject *obj)
313{
314 QmpInputVisitor *v;
315
316 v = qmp_input_visitor_new(obj);
317 v->strict = true;
318
319 return v;
320}
321
