xref: /qemu/qapi/string-input-visitor.c (revision a81df1b6) 
1 /*
2  * String parsing visitor
3  *
4  * Copyright Red Hat, Inc. 2012-2016
5  *
6  * Author: Paolo Bonzini <pbonzini@redhat.com>
7  *         David Hildenbrand <david@redhat.com>
8  *
9  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10  * See the COPYING.LIB file in the top-level directory.
11  */
12 
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qapi/string-input-visitor.h"
16 #include "qapi/visitor-impl.h"
17 #include "qapi/qmp/qerror.h"
18 #include "qapi/qmp/qnull.h"
19 #include "qemu/option.h"
20 #include "qemu/cutils.h"
21 
22 typedef enum ListMode {
23     /* no list parsing active / no list expected */
24     LM_NONE,
25     /* we have an unparsed string remaining */
26     LM_UNPARSED,
27     /* we have an unfinished int64 range */
28     LM_INT64_RANGE,
29     /* we have an unfinished uint64 range */
30     LM_UINT64_RANGE,
31     /* we have parsed the string completely and no range is remaining */
32     LM_END,
33 } ListMode;
34 
35 /* protect against DOS attacks, limit the amount of elements per range */
36 #define RANGE_MAX_ELEMENTS 65536
37 
38 typedef union RangeElement {
39     int64_t i64;
40     uint64_t u64;
41 } RangeElement;
42 
43 struct StringInputVisitor
44 {
45     Visitor visitor;
46 
47     /* List parsing state */
48     ListMode lm;
49     RangeElement rangeNext;
50     RangeElement rangeEnd;
51     const char *unparsed_string;
52     void *list;
53 
54     /* The original string to parse */
55     const char *string;
56 };
57 
58 static StringInputVisitor *to_siv(Visitor *v)
59 {
60     return container_of(v, StringInputVisitor, visitor);
61 }
62 
63 static bool start_list(Visitor *v, const char *name, GenericList **list,
64                        size_t size, Error **errp)
65 {
66     StringInputVisitor *siv = to_siv(v);
67 
68     assert(siv->lm == LM_NONE);
69     siv->list = list;
70     siv->unparsed_string = siv->string;
71 
72     if (!siv->string[0]) {
73         if (list) {
74             *list = NULL;
75         }
76         siv->lm = LM_END;
77     } else {
78         if (list) {
79             *list = g_malloc0(size);
80         }
81         siv->lm = LM_UNPARSED;
82     }
83     return true;
84 }
85 
86 static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
87 {
88     StringInputVisitor *siv = to_siv(v);
89 
90     switch (siv->lm) {
91     case LM_END:
92         return NULL;
93     case LM_INT64_RANGE:
94     case LM_UINT64_RANGE:
95     case LM_UNPARSED:
96         /* we have an unparsed string or something left in a range */
97         break;
98     default:
99         abort();
100     }
101 
102     tail->next = g_malloc0(size);
103     return tail->next;
104 }
105 
106 static bool check_list(Visitor *v, Error **errp)
107 {
108     const StringInputVisitor *siv = to_siv(v);
109 
110     switch (siv->lm) {
111     case LM_INT64_RANGE:
112     case LM_UINT64_RANGE:
113     case LM_UNPARSED:
114         error_setg(errp, "Fewer list elements expected");
115         return false;
116     case LM_END:
117         return true;
118     default:
119         abort();
120     }
121 }
122 
123 static void end_list(Visitor *v, void **obj)
124 {
125     StringInputVisitor *siv = to_siv(v);
126 
127     assert(siv->lm != LM_NONE);
128     assert(siv->list == obj);
129     siv->list = NULL;
130     siv->unparsed_string = NULL;
131     siv->lm = LM_NONE;
132 }
133 
134 static int try_parse_int64_list_entry(StringInputVisitor *siv, int64_t *obj)
135 {
136     const char *endptr;
137     int64_t start, end;
138 
139     /* parse a simple int64 or range */
140     if (qemu_strtoi64(siv->unparsed_string, &endptr, 0, &start)) {
141         return -EINVAL;
142     }
143     end = start;
144 
145     switch (endptr[0]) {
146     case '\0':
147         siv->unparsed_string = endptr;
148         break;
149     case ',':
150         siv->unparsed_string = endptr + 1;
151         break;
152     case '-':
153         /* parse the end of the range */
154         if (qemu_strtoi64(endptr + 1, &endptr, 0, &end)) {
155             return -EINVAL;
156         }
157         if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
158             return -EINVAL;
159         }
160         switch (endptr[0]) {
161         case '\0':
162             siv->unparsed_string = endptr;
163             break;
164         case ',':
165             siv->unparsed_string = endptr + 1;
166             break;
167         default:
168             return -EINVAL;
169         }
170         break;
171     default:
172         return -EINVAL;
173     }
174 
175     /* we have a proper range (with maybe only one element) */
176     siv->lm = LM_INT64_RANGE;
177     siv->rangeNext.i64 = start;
178     siv->rangeEnd.i64 = end;
179     return 0;
180 }
181 
182 static bool parse_type_int64(Visitor *v, const char *name, int64_t *obj,
183                              Error **errp)
184 {
185     StringInputVisitor *siv = to_siv(v);
186     int64_t val;
187 
188     switch (siv->lm) {
189     case LM_NONE:
190         /* just parse a simple int64, bail out if not completely consumed */
191         if (qemu_strtoi64(siv->string, NULL, 0, &val)) {
192             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
193                        name ? name : "null", "int64");
194             return false;
195         }
196         *obj = val;
197         return true;
198     case LM_UNPARSED:
199         if (try_parse_int64_list_entry(siv, obj)) {
200             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
201                        "list of int64 values or ranges");
202             return false;
203         }
204         assert(siv->lm == LM_INT64_RANGE);
205         /* fall through */
206     case LM_INT64_RANGE:
207         /* return the next element in the range */
208         assert(siv->rangeNext.i64 <= siv->rangeEnd.i64);
209         *obj = siv->rangeNext.i64++;
210 
211         if (siv->rangeNext.i64 > siv->rangeEnd.i64 || *obj == INT64_MAX) {
212             /* end of range, check if there is more to parse */
213             siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
214         }
215         return true;
216     case LM_END:
217         error_setg(errp, "Fewer list elements expected");
218         return false;
219     default:
220         abort();
221     }
222 }
223 
224 static int try_parse_uint64_list_entry(StringInputVisitor *siv, uint64_t *obj)
225 {
226     const char *endptr;
227     uint64_t start, end;
228 
229     /* parse a simple uint64 or range */
230     if (qemu_strtou64(siv->unparsed_string, &endptr, 0, &start)) {
231         return -EINVAL;
232     }
233     end = start;
234 
235     switch (endptr[0]) {
236     case '\0':
237         siv->unparsed_string = endptr;
238         break;
239     case ',':
240         siv->unparsed_string = endptr + 1;
241         break;
242     case '-':
243         /* parse the end of the range */
244         if (qemu_strtou64(endptr + 1, &endptr, 0, &end)) {
245             return -EINVAL;
246         }
247         if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
248             return -EINVAL;
249         }
250         switch (endptr[0]) {
251         case '\0':
252             siv->unparsed_string = endptr;
253             break;
254         case ',':
255             siv->unparsed_string = endptr + 1;
256             break;
257         default:
258             return -EINVAL;
259         }
260         break;
261     default:
262         return -EINVAL;
263     }
264 
265     /* we have a proper range (with maybe only one element) */
266     siv->lm = LM_UINT64_RANGE;
267     siv->rangeNext.u64 = start;
268     siv->rangeEnd.u64 = end;
269     return 0;
270 }
271 
272 static bool parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
273                               Error **errp)
274 {
275     StringInputVisitor *siv = to_siv(v);
276     uint64_t val;
277 
278     switch (siv->lm) {
279     case LM_NONE:
280         /* just parse a simple uint64, bail out if not completely consumed */
281         if (qemu_strtou64(siv->string, NULL, 0, &val)) {
282             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
283                        "uint64");
284             return false;
285         }
286         *obj = val;
287         return true;
288     case LM_UNPARSED:
289         if (try_parse_uint64_list_entry(siv, obj)) {
290             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
291                        "list of uint64 values or ranges");
292             return false;
293         }
294         assert(siv->lm == LM_UINT64_RANGE);
295         /* fall through */
296     case LM_UINT64_RANGE:
297         /* return the next element in the range */
298         assert(siv->rangeNext.u64 <= siv->rangeEnd.u64);
299         *obj = siv->rangeNext.u64++;
300 
301         if (siv->rangeNext.u64 > siv->rangeEnd.u64 || *obj == UINT64_MAX) {
302             /* end of range, check if there is more to parse */
303             siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
304         }
305         return true;
306     case LM_END:
307         error_setg(errp, "Fewer list elements expected");
308         return false;
309     default:
310         abort();
311     }
312 }
313 
314 static bool parse_type_size(Visitor *v, const char *name, uint64_t *obj,
315                             Error **errp)
316 {
317     StringInputVisitor *siv = to_siv(v);
318     uint64_t val;
319 
320     assert(siv->lm == LM_NONE);
321     if (!parse_option_size(name, siv->string, &val, errp)) {
322         return false;
323     }
324 
325     *obj = val;
326     return true;
327 }
328 
329 static bool parse_type_bool(Visitor *v, const char *name, bool *obj,
330                             Error **errp)
331 {
332     StringInputVisitor *siv = to_siv(v);
333 
334     assert(siv->lm == LM_NONE);
335     if (!strcasecmp(siv->string, "on") ||
336         !strcasecmp(siv->string, "yes") ||
337         !strcasecmp(siv->string, "true")) {
338         *obj = true;
339         return true;
340     }
341     if (!strcasecmp(siv->string, "off") ||
342         !strcasecmp(siv->string, "no") ||
343         !strcasecmp(siv->string, "false")) {
344         *obj = false;
345         return true;
346     }
347 
348     error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
349                "boolean");
350     return false;
351 }
352 
353 static bool parse_type_str(Visitor *v, const char *name, char **obj,
354                            Error **errp)
355 {
356     StringInputVisitor *siv = to_siv(v);
357 
358     assert(siv->lm == LM_NONE);
359     *obj = g_strdup(siv->string);
360     return true;
361 }
362 
363 static bool parse_type_number(Visitor *v, const char *name, double *obj,
364                               Error **errp)
365 {
366     StringInputVisitor *siv = to_siv(v);
367     double val;
368 
369     assert(siv->lm == LM_NONE);
370     if (qemu_strtod_finite(siv->string, NULL, &val)) {
371         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
372                    "number");
373         return false;
374     }
375 
376     *obj = val;
377     return true;
378 }
379 
380 static bool parse_type_null(Visitor *v, const char *name, QNull **obj,
381                             Error **errp)
382 {
383     StringInputVisitor *siv = to_siv(v);
384 
385     assert(siv->lm == LM_NONE);
386     *obj = NULL;
387 
388     if (siv->string[0]) {
389         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
390                    "null");
391         return false;
392     }
393 
394     *obj = qnull();
395     return true;
396 }
397 
398 static void string_input_free(Visitor *v)
399 {
400     StringInputVisitor *siv = to_siv(v);
401 
402     g_free(siv);
403 }
404 
405 Visitor *string_input_visitor_new(const char *str)
406 {
407     StringInputVisitor *v;
408 
409     assert(str);
410     v = g_malloc0(sizeof(*v));
411 
412     v->visitor.type = VISITOR_INPUT;
413     v->visitor.type_int64 = parse_type_int64;
414     v->visitor.type_uint64 = parse_type_uint64;
415     v->visitor.type_size = parse_type_size;
416     v->visitor.type_bool = parse_type_bool;
417     v->visitor.type_str = parse_type_str;
418     v->visitor.type_number = parse_type_number;
419     v->visitor.type_null = parse_type_null;
420     v->visitor.start_list = start_list;
421     v->visitor.next_list = next_list;
422     v->visitor.check_list = check_list;
423     v->visitor.end_list = end_list;
424     v->visitor.free = string_input_free;
425 
426     v->string = str;
427     v->lm = LM_NONE;
428     return &v->visitor;
429 }
430