xref: /qemu/qapi/string-input-visitor.c (revision 46f5ac20) 
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     if (!*str) {
58         return 0;
59     }
60 
61     do {
62         errno = 0;
63         start = strtoll(str, &endptr, 0);
64         if (errno == 0 && endptr > str) {
65             if (*endptr == '\0') {
66                 cur = g_malloc0(sizeof(*cur));
67                 range_set_bounds(cur, start, start);
68                 siv->ranges = range_list_insert(siv->ranges, cur);
69                 cur = NULL;
70                 str = NULL;
71             } else if (*endptr == '-') {
72                 str = endptr + 1;
73                 errno = 0;
74                 end = strtoll(str, &endptr, 0);
75                 if (errno == 0 && endptr > str && start <= end &&
76                     (start > INT64_MAX - 65536 ||
77                      end < start + 65536)) {
78                     if (*endptr == '\0') {
79                         cur = g_malloc0(sizeof(*cur));
80                         range_set_bounds(cur, start, end);
81                         siv->ranges = range_list_insert(siv->ranges, cur);
82                         cur = NULL;
83                         str = NULL;
84                     } else if (*endptr == ',') {
85                         str = endptr + 1;
86                         cur = g_malloc0(sizeof(*cur));
87                         range_set_bounds(cur, start, end);
88                         siv->ranges = range_list_insert(siv->ranges, cur);
89                         cur = NULL;
90                     } else {
91                         goto error;
92                     }
93                 } else {
94                     goto error;
95                 }
96             } else if (*endptr == ',') {
97                 str = endptr + 1;
98                 cur = g_malloc0(sizeof(*cur));
99                 range_set_bounds(cur, start, start);
100                 siv->ranges = range_list_insert(siv->ranges, cur);
101                 cur = NULL;
102             } else {
103                 goto error;
104             }
105         } else {
106             goto error;
107         }
108     } while (str);
109 
110     return 0;
111 error:
112     g_list_foreach(siv->ranges, free_range, NULL);
113     g_list_free(siv->ranges);
114     siv->ranges = NULL;
115     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
116                "an int64 value or range");
117     return -1;
118 }
119 
120 static void
121 start_list(Visitor *v, const char *name, GenericList **list, size_t size,
122            Error **errp)
123 {
124     StringInputVisitor *siv = to_siv(v);
125 
126     /* We don't support visits without a list */
127     assert(list);
128     siv->list = list;
129 
130     if (parse_str(siv, name, errp) < 0) {
131         *list = NULL;
132         return;
133     }
134 
135     siv->cur_range = g_list_first(siv->ranges);
136     if (siv->cur_range) {
137         Range *r = siv->cur_range->data;
138         if (r) {
139             siv->cur = range_lob(r);
140         }
141         *list = g_malloc0(size);
142     } else {
143         *list = NULL;
144     }
145 }
146 
147 static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
148 {
149     StringInputVisitor *siv = to_siv(v);
150     Range *r;
151 
152     if (!siv->ranges || !siv->cur_range) {
153         return NULL;
154     }
155 
156     r = siv->cur_range->data;
157     if (!r) {
158         return NULL;
159     }
160 
161     if (!range_contains(r, siv->cur)) {
162         siv->cur_range = g_list_next(siv->cur_range);
163         if (!siv->cur_range) {
164             return NULL;
165         }
166         r = siv->cur_range->data;
167         if (!r) {
168             return NULL;
169         }
170         siv->cur = range_lob(r);
171     }
172 
173     tail->next = g_malloc0(size);
174     return tail->next;
175 }
176 
177 static void check_list(Visitor *v, Error **errp)
178 {
179     const StringInputVisitor *siv = to_siv(v);
180     Range *r;
181     GList *cur_range;
182 
183     if (!siv->ranges || !siv->cur_range) {
184         return;
185     }
186 
187     r = siv->cur_range->data;
188     if (!r) {
189         return;
190     }
191 
192     if (!range_contains(r, siv->cur)) {
193         cur_range = g_list_next(siv->cur_range);
194         if (!cur_range) {
195             return;
196         }
197         r = cur_range->data;
198         if (!r) {
199             return;
200         }
201     }
202 
203     error_setg(errp, "Range contains too many values");
204 }
205 
206 static void end_list(Visitor *v, void **obj)
207 {
208     StringInputVisitor *siv = to_siv(v);
209 
210     assert(siv->list == obj);
211 }
212 
213 static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
214                              Error **errp)
215 {
216     StringInputVisitor *siv = to_siv(v);
217 
218     if (parse_str(siv, name, errp) < 0) {
219         return;
220     }
221 
222     if (!siv->ranges) {
223         goto error;
224     }
225 
226     if (!siv->cur_range) {
227         Range *r;
228 
229         siv->cur_range = g_list_first(siv->ranges);
230         if (!siv->cur_range) {
231             goto error;
232         }
233 
234         r = siv->cur_range->data;
235         if (!r) {
236             goto error;
237         }
238 
239         siv->cur = range_lob(r);
240     }
241 
242     *obj = siv->cur;
243     siv->cur++;
244     return;
245 
246 error:
247     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
248                "an int64 value or range");
249 }
250 
251 static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
252                               Error **errp)
253 {
254     /* FIXME: parse_type_int64 mishandles values over INT64_MAX */
255     int64_t i;
256     Error *err = NULL;
257     parse_type_int64(v, name, &i, &err);
258     if (err) {
259         error_propagate(errp, err);
260     } else {
261         *obj = i;
262     }
263 }
264 
265 static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
266                             Error **errp)
267 {
268     StringInputVisitor *siv = to_siv(v);
269     Error *err = NULL;
270     uint64_t val;
271 
272     parse_option_size(name, siv->string, &val, &err);
273     if (err) {
274         error_propagate(errp, err);
275         return;
276     }
277 
278     *obj = val;
279 }
280 
281 static void parse_type_bool(Visitor *v, const char *name, bool *obj,
282                             Error **errp)
283 {
284     StringInputVisitor *siv = to_siv(v);
285 
286     if (!strcasecmp(siv->string, "on") ||
287         !strcasecmp(siv->string, "yes") ||
288         !strcasecmp(siv->string, "true")) {
289         *obj = true;
290         return;
291     }
292     if (!strcasecmp(siv->string, "off") ||
293         !strcasecmp(siv->string, "no") ||
294         !strcasecmp(siv->string, "false")) {
295         *obj = false;
296         return;
297     }
298 
299     error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
300                "boolean");
301 }
302 
303 static void parse_type_str(Visitor *v, const char *name, char **obj,
304                            Error **errp)
305 {
306     StringInputVisitor *siv = to_siv(v);
307 
308     *obj = g_strdup(siv->string);
309 }
310 
311 static void parse_type_number(Visitor *v, const char *name, double *obj,
312                               Error **errp)
313 {
314     StringInputVisitor *siv = to_siv(v);
315     char *endp = (char *) siv->string;
316     double val;
317 
318     errno = 0;
319     val = strtod(siv->string, &endp);
320     if (errno || endp == siv->string || *endp) {
321         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
322                    "number");
323         return;
324     }
325 
326     *obj = val;
327 }
328 
329 static void string_input_free(Visitor *v)
330 {
331     StringInputVisitor *siv = to_siv(v);
332 
333     g_list_foreach(siv->ranges, free_range, NULL);
334     g_list_free(siv->ranges);
335     g_free(siv);
336 }
337 
338 Visitor *string_input_visitor_new(const char *str)
339 {
340     StringInputVisitor *v;
341 
342     assert(str);
343     v = g_malloc0(sizeof(*v));
344 
345     v->visitor.type = VISITOR_INPUT;
346     v->visitor.type_int64 = parse_type_int64;
347     v->visitor.type_uint64 = parse_type_uint64;
348     v->visitor.type_size = parse_type_size;
349     v->visitor.type_bool = parse_type_bool;
350     v->visitor.type_str = parse_type_str;
351     v->visitor.type_number = parse_type_number;
352     v->visitor.start_list = start_list;
353     v->visitor.next_list = next_list;
354     v->visitor.check_list = check_list;
355     v->visitor.end_list = end_list;
356     v->visitor.free = string_input_free;
357 
358     v->string = str;
359     return &v->visitor;
360 }
361