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