virtio-scsi: work around bug in old BIOSes
[qemu.git] / 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_set(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_set(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_set(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_set(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_set(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_set(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 }