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