1 /*
2  * Core Definitions for QAPI/QMP Command Registry
3  *
4  * Copyright (C) 2012-2016 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/qobject-output-visitor.h"
17 #include "qapi/visitor-impl.h"
18 #include "qemu/queue.h"
19 #include "qapi/qmp/qbool.h"
20 #include "qapi/qmp/qdict.h"
21 #include "qapi/qmp/qlist.h"
22 #include "qapi/qmp/qnull.h"
23 #include "qapi/qmp/qnum.h"
24 #include "qapi/qmp/qstring.h"
25 
26 typedef struct QStackEntry {
27     QObject *value;
28     void *qapi; /* sanity check that caller uses same pointer */
29     QSLIST_ENTRY(QStackEntry) node;
30 } QStackEntry;
31 
32 struct QObjectOutputVisitor {
33     Visitor visitor;
34 
35     QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */
36     QObject *root; /* Root of the output visit */
37     QObject **result; /* User's storage location for result */
38 };
39 
40 #define qobject_output_add(qov, name, value) \
41     qobject_output_add_obj(qov, name, QOBJECT(value))
42 #define qobject_output_push(qov, value, qapi) \
43     qobject_output_push_obj(qov, QOBJECT(value), qapi)
44 
45 static QObjectOutputVisitor *to_qov(Visitor *v)
46 {
47     return container_of(v, QObjectOutputVisitor, visitor);
48 }
49 
50 /* Push @value onto the stack of current QObjects being built */
51 static void qobject_output_push_obj(QObjectOutputVisitor *qov, QObject *value,
52                                     void *qapi)
53 {
54     QStackEntry *e = g_malloc0(sizeof(*e));
55 
56     assert(qov->root);
57     assert(value);
58     e->value = value;
59     e->qapi = qapi;
60     QSLIST_INSERT_HEAD(&qov->stack, e, node);
61 }
62 
63 /* Pop a value off the stack of QObjects being built, and return it. */
64 static QObject *qobject_output_pop(QObjectOutputVisitor *qov, void *qapi)
65 {
66     QStackEntry *e = QSLIST_FIRST(&qov->stack);
67     QObject *value;
68 
69     assert(e);
70     assert(e->qapi == qapi);
71     QSLIST_REMOVE_HEAD(&qov->stack, node);
72     value = e->value;
73     assert(value);
74     g_free(e);
75     return value;
76 }
77 
78 /* Add @value to the current QObject being built.
79  * If the stack is visiting a dictionary or list, @value is now owned
80  * by that container. Otherwise, @value is now the root.  */
81 static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name,
82                                    QObject *value)
83 {
84     QStackEntry *e = QSLIST_FIRST(&qov->stack);
85     QObject *cur = e ? e->value : NULL;
86 
87     if (!cur) {
88         /* Don't allow reuse of visitor on more than one root */
89         assert(!qov->root);
90         qov->root = value;
91     } else {
92         switch (qobject_type(cur)) {
93         case QTYPE_QDICT:
94             assert(name);
95             qdict_put_obj(qobject_to(QDict, cur), name, value);
96             break;
97         case QTYPE_QLIST:
98             assert(!name);
99             qlist_append_obj(qobject_to(QList, cur), value);
100             break;
101         default:
102             g_assert_not_reached();
103         }
104     }
105 }
106 
107 static bool qobject_output_start_struct(Visitor *v, const char *name,
108                                         void **obj, size_t unused, Error **errp)
109 {
110     QObjectOutputVisitor *qov = to_qov(v);
111     QDict *dict = qdict_new();
112 
113     qobject_output_add(qov, name, dict);
114     qobject_output_push(qov, dict, obj);
115     return true;
116 }
117 
118 static void qobject_output_end_struct(Visitor *v, void **obj)
119 {
120     QObjectOutputVisitor *qov = to_qov(v);
121     QObject *value = qobject_output_pop(qov, obj);
122     assert(qobject_type(value) == QTYPE_QDICT);
123 }
124 
125 static bool qobject_output_start_list(Visitor *v, const char *name,
126                                       GenericList **listp, size_t size,
127                                       Error **errp)
128 {
129     QObjectOutputVisitor *qov = to_qov(v);
130     QList *list = qlist_new();
131 
132     qobject_output_add(qov, name, list);
133     qobject_output_push(qov, list, listp);
134     return true;
135 }
136 
137 static GenericList *qobject_output_next_list(Visitor *v, GenericList *tail,
138                                              size_t size)
139 {
140     return tail->next;
141 }
142 
143 static void qobject_output_end_list(Visitor *v, void **obj)
144 {
145     QObjectOutputVisitor *qov = to_qov(v);
146     QObject *value = qobject_output_pop(qov, obj);
147     assert(qobject_type(value) == QTYPE_QLIST);
148 }
149 
150 static bool qobject_output_type_int64(Visitor *v, const char *name,
151                                       int64_t *obj, Error **errp)
152 {
153     QObjectOutputVisitor *qov = to_qov(v);
154     qobject_output_add(qov, name, qnum_from_int(*obj));
155     return true;
156 }
157 
158 static bool qobject_output_type_uint64(Visitor *v, const char *name,
159                                        uint64_t *obj, Error **errp)
160 {
161     QObjectOutputVisitor *qov = to_qov(v);
162     qobject_output_add(qov, name, qnum_from_uint(*obj));
163     return true;
164 }
165 
166 static bool qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
167                                      Error **errp)
168 {
169     QObjectOutputVisitor *qov = to_qov(v);
170     qobject_output_add(qov, name, qbool_from_bool(*obj));
171     return true;
172 }
173 
174 static bool qobject_output_type_str(Visitor *v, const char *name, char **obj,
175                                     Error **errp)
176 {
177     QObjectOutputVisitor *qov = to_qov(v);
178     if (*obj) {
179         qobject_output_add(qov, name, qstring_from_str(*obj));
180     } else {
181         qobject_output_add(qov, name, qstring_from_str(""));
182     }
183     return true;
184 }
185 
186 static bool qobject_output_type_number(Visitor *v, const char *name,
187                                        double *obj, Error **errp)
188 {
189     QObjectOutputVisitor *qov = to_qov(v);
190     qobject_output_add(qov, name, qnum_from_double(*obj));
191     return true;
192 }
193 
194 static bool qobject_output_type_any(Visitor *v, const char *name,
195                                     QObject **obj, Error **errp)
196 {
197     QObjectOutputVisitor *qov = to_qov(v);
198 
199     qobject_output_add_obj(qov, name, qobject_ref(*obj));
200     return true;
201 }
202 
203 static bool qobject_output_type_null(Visitor *v, const char *name,
204                                      QNull **obj, Error **errp)
205 {
206     QObjectOutputVisitor *qov = to_qov(v);
207     qobject_output_add(qov, name, qnull());
208     return true;
209 }
210 
211 static bool qobject_output_deprecated(Visitor *v, const char *name)
212 {
213     return v->compat_policy.deprecated_output != COMPAT_POLICY_OUTPUT_HIDE;
214 }
215 
216 /* Finish building, and return the root object.
217  * The root object is never null. The caller becomes the object's
218  * owner, and should use qobject_unref() when done with it.  */
219 static void qobject_output_complete(Visitor *v, void *opaque)
220 {
221     QObjectOutputVisitor *qov = to_qov(v);
222 
223     /* A visit must have occurred, with each start paired with end.  */
224     assert(qov->root && QSLIST_EMPTY(&qov->stack));
225     assert(opaque == qov->result);
226 
227     *qov->result = qobject_ref(qov->root);
228     qov->result = NULL;
229 }
230 
231 static void qobject_output_free(Visitor *v)
232 {
233     QObjectOutputVisitor *qov = to_qov(v);
234     QStackEntry *e;
235 
236     while (!QSLIST_EMPTY(&qov->stack)) {
237         e = QSLIST_FIRST(&qov->stack);
238         QSLIST_REMOVE_HEAD(&qov->stack, node);
239         g_free(e);
240     }
241 
242     qobject_unref(qov->root);
243     g_free(qov);
244 }
245 
246 Visitor *qobject_output_visitor_new(QObject **result)
247 {
248     QObjectOutputVisitor *v;
249 
250     v = g_malloc0(sizeof(*v));
251 
252     v->visitor.type = VISITOR_OUTPUT;
253     v->visitor.start_struct = qobject_output_start_struct;
254     v->visitor.end_struct = qobject_output_end_struct;
255     v->visitor.start_list = qobject_output_start_list;
256     v->visitor.next_list = qobject_output_next_list;
257     v->visitor.end_list = qobject_output_end_list;
258     v->visitor.type_int64 = qobject_output_type_int64;
259     v->visitor.type_uint64 = qobject_output_type_uint64;
260     v->visitor.type_bool = qobject_output_type_bool;
261     v->visitor.type_str = qobject_output_type_str;
262     v->visitor.type_number = qobject_output_type_number;
263     v->visitor.type_any = qobject_output_type_any;
264     v->visitor.type_null = qobject_output_type_null;
265     v->visitor.deprecated = qobject_output_deprecated;
266     v->visitor.complete = qobject_output_complete;
267     v->visitor.free = qobject_output_free;
268 
269     *result = NULL;
270     v->result = result;
271 
272     return &v->visitor;
273 }
274