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