Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-03-16' into staging
[qemu.git] / qapi / string-input-visitor.c
1 /*
2 * String parsing visitor
3 *
4 * Copyright Red Hat, Inc. 2012-2016
5 *
6 * Author: Paolo Bonzini <pbonzini@redhat.com>
7 *
8 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
9 * See the COPYING.LIB file in the top-level directory.
10 *
11 */
12
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qemu-common.h"
16 #include "qapi/string-input-visitor.h"
17 #include "qapi/visitor-impl.h"
18 #include "qapi/qmp/qerror.h"
19 #include "qemu/option.h"
20 #include "qemu/queue.h"
21 #include "qemu/range.h"
22
23
24 struct StringInputVisitor
25 {
26 Visitor visitor;
27
28 GList *ranges;
29 GList *cur_range;
30 int64_t cur;
31
32 const char *string;
33 void *list; /* Only needed for sanity checking the caller */
34 };
35
36 static StringInputVisitor *to_siv(Visitor *v)
37 {
38 return container_of(v, StringInputVisitor, visitor);
39 }
40
41 static void free_range(void *range, void *dummy)
42 {
43 g_free(range);
44 }
45
46 static int parse_str(StringInputVisitor *siv, const char *name, Error **errp)
47 {
48 char *str = (char *) siv->string;
49 long long start, end;
50 Range *cur;
51 char *endptr;
52
53 if (siv->ranges) {
54 return 0;
55 }
56
57 do {
58 errno = 0;
59 start = strtoll(str, &endptr, 0);
60 if (errno == 0 && endptr > str) {
61 if (*endptr == '\0') {
62 cur = g_malloc0(sizeof(*cur));
63 range_set_bounds(cur, start, start);
64 siv->ranges = range_list_insert(siv->ranges, cur);
65 cur = NULL;
66 str = NULL;
67 } else if (*endptr == '-') {
68 str = endptr + 1;
69 errno = 0;
70 end = strtoll(str, &endptr, 0);
71 if (errno == 0 && endptr > str && start <= end &&
72 (start > INT64_MAX - 65536 ||
73 end < start + 65536)) {
74 if (*endptr == '\0') {
75 cur = g_malloc0(sizeof(*cur));
76 range_set_bounds(cur, start, end);
77 siv->ranges = range_list_insert(siv->ranges, cur);
78 cur = NULL;
79 str = NULL;
80 } else if (*endptr == ',') {
81 str = endptr + 1;
82 cur = g_malloc0(sizeof(*cur));
83 range_set_bounds(cur, start, end);
84 siv->ranges = range_list_insert(siv->ranges, cur);
85 cur = NULL;
86 } else {
87 goto error;
88 }
89 } else {
90 goto error;
91 }
92 } else if (*endptr == ',') {
93 str = endptr + 1;
94 cur = g_malloc0(sizeof(*cur));
95 range_set_bounds(cur, start, start);
96 siv->ranges = range_list_insert(siv->ranges, cur);
97 cur = NULL;
98 } else {
99 goto error;
100 }
101 } else {
102 goto error;
103 }
104 } while (str);
105
106 return 0;
107 error:
108 g_list_foreach(siv->ranges, free_range, NULL);
109 g_list_free(siv->ranges);
110 siv->ranges = NULL;
111 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
112 "an int64 value or range");
113 return -1;
114 }
115
116 static void
117 start_list(Visitor *v, const char *name, GenericList **list, size_t size,
118 Error **errp)
119 {
120 StringInputVisitor *siv = to_siv(v);
121
122 /* We don't support visits without a list */
123 assert(list);
124 siv->list = list;
125
126 if (parse_str(siv, name, errp) < 0) {
127 *list = NULL;
128 return;
129 }
130
131 siv->cur_range = g_list_first(siv->ranges);
132 if (siv->cur_range) {
133 Range *r = siv->cur_range->data;
134 if (r) {
135 siv->cur = range_lob(r);
136 }
137 *list = g_malloc0(size);
138 } else {
139 *list = NULL;
140 }
141 }
142
143 static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
144 {
145 StringInputVisitor *siv = to_siv(v);
146 Range *r;
147
148 if (!siv->ranges || !siv->cur_range) {
149 return NULL;
150 }
151
152 r = siv->cur_range->data;
153 if (!r) {
154 return NULL;
155 }
156
157 if (!range_contains(r, siv->cur)) {
158 siv->cur_range = g_list_next(siv->cur_range);
159 if (!siv->cur_range) {
160 return NULL;
161 }
162 r = siv->cur_range->data;
163 if (!r) {
164 return NULL;
165 }
166 siv->cur = range_lob(r);
167 }
168
169 tail->next = g_malloc0(size);
170 return tail->next;
171 }
172
173 static void check_list(Visitor *v, Error **errp)
174 {
175 const StringInputVisitor *siv = to_siv(v);
176 Range *r;
177 GList *cur_range;
178
179 if (!siv->ranges || !siv->cur_range) {
180 return;
181 }
182
183 r = siv->cur_range->data;
184 if (!r) {
185 return;
186 }
187
188 if (!range_contains(r, siv->cur)) {
189 cur_range = g_list_next(siv->cur_range);
190 if (!cur_range) {
191 return;
192 }
193 r = cur_range->data;
194 if (!r) {
195 return;
196 }
197 }
198
199 error_setg(errp, "Range contains too many values");
200 }
201
202 static void end_list(Visitor *v, void **obj)
203 {
204 StringInputVisitor *siv = to_siv(v);
205
206 assert(siv->list == obj);
207 }
208
209 static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
210 Error **errp)
211 {
212 StringInputVisitor *siv = to_siv(v);
213
214 if (parse_str(siv, name, errp) < 0) {
215 return;
216 }
217
218 if (!siv->ranges) {
219 goto error;
220 }
221
222 if (!siv->cur_range) {
223 Range *r;
224
225 siv->cur_range = g_list_first(siv->ranges);
226 if (!siv->cur_range) {
227 goto error;
228 }
229
230 r = siv->cur_range->data;
231 if (!r) {
232 goto error;
233 }
234
235 siv->cur = range_lob(r);
236 }
237
238 *obj = siv->cur;
239 siv->cur++;
240 return;
241
242 error:
243 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
244 "an int64 value or range");
245 }
246
247 static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
248 Error **errp)
249 {
250 /* FIXME: parse_type_int64 mishandles values over INT64_MAX */
251 int64_t i;
252 Error *err = NULL;
253 parse_type_int64(v, name, &i, &err);
254 if (err) {
255 error_propagate(errp, err);
256 } else {
257 *obj = i;
258 }
259 }
260
261 static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
262 Error **errp)
263 {
264 StringInputVisitor *siv = to_siv(v);
265 Error *err = NULL;
266 uint64_t val;
267
268 parse_option_size(name, siv->string, &val, &err);
269 if (err) {
270 error_propagate(errp, err);
271 return;
272 }
273
274 *obj = val;
275 }
276
277 static void parse_type_bool(Visitor *v, const char *name, bool *obj,
278 Error **errp)
279 {
280 StringInputVisitor *siv = to_siv(v);
281
282 if (!strcasecmp(siv->string, "on") ||
283 !strcasecmp(siv->string, "yes") ||
284 !strcasecmp(siv->string, "true")) {
285 *obj = true;
286 return;
287 }
288 if (!strcasecmp(siv->string, "off") ||
289 !strcasecmp(siv->string, "no") ||
290 !strcasecmp(siv->string, "false")) {
291 *obj = false;
292 return;
293 }
294
295 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
296 "boolean");
297 }
298
299 static void parse_type_str(Visitor *v, const char *name, char **obj,
300 Error **errp)
301 {
302 StringInputVisitor *siv = to_siv(v);
303
304 *obj = g_strdup(siv->string);
305 }
306
307 static void parse_type_number(Visitor *v, const char *name, double *obj,
308 Error **errp)
309 {
310 StringInputVisitor *siv = to_siv(v);
311 char *endp = (char *) siv->string;
312 double val;
313
314 errno = 0;
315 val = strtod(siv->string, &endp);
316 if (errno || endp == siv->string || *endp) {
317 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
318 "number");
319 return;
320 }
321
322 *obj = val;
323 }
324
325 static void string_input_free(Visitor *v)
326 {
327 StringInputVisitor *siv = to_siv(v);
328
329 g_list_foreach(siv->ranges, free_range, NULL);
330 g_list_free(siv->ranges);
331 g_free(siv);
332 }
333
334 Visitor *string_input_visitor_new(const char *str)
335 {
336 StringInputVisitor *v;
337
338 assert(str);
339 v = g_malloc0(sizeof(*v));
340
341 v->visitor.type = VISITOR_INPUT;
342 v->visitor.type_int64 = parse_type_int64;
343 v->visitor.type_uint64 = parse_type_uint64;
344 v->visitor.type_size = parse_type_size;
345 v->visitor.type_bool = parse_type_bool;
346 v->visitor.type_str = parse_type_str;
347 v->visitor.type_number = parse_type_number;
348 v->visitor.start_list = start_list;
349 v->visitor.next_list = next_list;
350 v->visitor.check_list = check_list;
351 v->visitor.end_list = end_list;
352 v->visitor.free = string_input_free;
353
354 v->string = str;
355 return &v->visitor;
356 }