1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90#include "qemu/osdep.h"
91#include "qapi/error.h"
92#include "qapi/qmp/qdict.h"
93#include "qapi/qmp/qlist.h"
94#include "qapi/qmp/qstring.h"
95#include "qemu/cutils.h"
96#include "qemu/help_option.h"
97#include "qemu/option.h"
98
99
100
101
102
103
104
105
106
107
108
109
110
111static int key_to_index(const char *key, const char **end)
112{
113 int ret;
114 unsigned long index;
115
116 if (*key < '0' || *key > '9') {
117 return -EINVAL;
118 }
119 ret = qemu_strtoul(key, end, 10, &index);
120 if (ret) {
121 return ret == -ERANGE ? INT_MAX : ret;
122 }
123 return index <= INT_MAX ? index : INT_MAX;
124}
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143static QObject *keyval_parse_put(QDict *cur,
144 const char *key_in_cur, QString *value,
145 const char *key, const char *key_cursor,
146 Error **errp)
147{
148 QObject *old, *new;
149
150 old = qdict_get(cur, key_in_cur);
151 if (old) {
152 if (qobject_type(old) != (value ? QTYPE_QSTRING : QTYPE_QDICT)) {
153 error_setg(errp, "Parameters '%.*s.*' used inconsistently",
154 (int)(key_cursor - key), key);
155 qobject_unref(value);
156 return NULL;
157 }
158 if (!value) {
159 return old;
160 }
161 new = QOBJECT(value);
162 } else {
163 new = value ? QOBJECT(value) : QOBJECT(qdict_new());
164 }
165 qdict_put_obj(cur, key_in_cur, new);
166 return new;
167}
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182static const char *keyval_parse_one(QDict *qdict, const char *params,
183 const char *implied_key, bool *help,
184 Error **errp)
185{
186 const char *key, *key_end, *val_end, *s, *end;
187 size_t len;
188 char key_in_cur[128];
189 QDict *cur;
190 int ret;
191 QObject *next;
192 QString *val;
193
194 key = params;
195 val_end = NULL;
196 len = strcspn(params, "=,");
197 if (len && key[len] != '=') {
198 if (starts_with_help_option(key) == len) {
199 *help = true;
200 s = key + len;
201 if (*s == ',') {
202 s++;
203 }
204 return s;
205 }
206 if (implied_key) {
207
208 key = implied_key;
209 val_end = params + len;
210 len = strlen(implied_key);
211 }
212 }
213 key_end = key + len;
214
215
216
217
218
219 cur = qdict;
220 s = key;
221 for (;;) {
222
223 if (s != key && key_to_index(s, &end) >= 0) {
224 len = end - s;
225 } else {
226 ret = parse_qapi_name(s, false);
227 len = ret < 0 ? 0 : ret;
228 }
229 assert(s + len <= key_end);
230 if (!len || (s + len < key_end && s[len] != '.')) {
231 assert(key != implied_key);
232 error_setg(errp, "Invalid parameter '%.*s'",
233 (int)(key_end - key), key);
234 return NULL;
235 }
236 if (len >= sizeof(key_in_cur)) {
237 assert(key != implied_key);
238 error_setg(errp, "Parameter%s '%.*s' is too long",
239 s != key || s + len != key_end ? " fragment" : "",
240 (int)len, s);
241 return NULL;
242 }
243
244 if (s != key) {
245 next = keyval_parse_put(cur, key_in_cur, NULL,
246 key, s - 1, errp);
247 if (!next) {
248 return NULL;
249 }
250 cur = qobject_to(QDict, next);
251 assert(cur);
252 }
253
254 memcpy(key_in_cur, s, len);
255 key_in_cur[len] = 0;
256 s += len;
257
258 if (*s != '.') {
259 break;
260 }
261 s++;
262 }
263
264 if (key == implied_key) {
265 assert(!*s);
266 val = qstring_from_substr(params, 0, val_end - params);
267 s = val_end;
268 if (*s == ',') {
269 s++;
270 }
271 } else {
272 if (*s != '=') {
273 error_setg(errp, "Expected '=' after parameter '%.*s'",
274 (int)(s - key), key);
275 return NULL;
276 }
277 s++;
278
279 val = qstring_new();
280 for (;;) {
281 if (!*s) {
282 break;
283 } else if (*s == ',') {
284 s++;
285 if (*s != ',') {
286 break;
287 }
288 }
289 qstring_append_chr(val, *s++);
290 }
291 }
292
293 if (!keyval_parse_put(cur, key_in_cur, val, key, key_end, errp)) {
294 return NULL;
295 }
296 return s;
297}
298
299static char *reassemble_key(GSList *key)
300{
301 GString *s = g_string_new("");
302 GSList *p;
303
304 for (p = key; p; p = p->next) {
305 g_string_prepend_c(s, '.');
306 g_string_prepend(s, (char *)p->data);
307 }
308
309 return g_string_free(s, FALSE);
310}
311
312
313
314
315
316
317
318
319static QObject *keyval_listify(QDict *cur, GSList *key_of_cur, Error **errp)
320{
321 GSList key_node;
322 bool has_index, has_member;
323 const QDictEntry *ent;
324 QDict *qdict;
325 QObject *val;
326 char *key;
327 size_t nelt;
328 QObject **elt;
329 int index, max_index, i;
330 QList *list;
331
332 key_node.next = key_of_cur;
333
334
335
336
337
338 has_index = false;
339 has_member = false;
340 for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
341 if (key_to_index(ent->key, NULL) >= 0) {
342 has_index = true;
343 } else {
344 has_member = true;
345 }
346
347 qdict = qobject_to(QDict, ent->value);
348 if (!qdict) {
349 continue;
350 }
351
352 key_node.data = ent->key;
353 val = keyval_listify(qdict, &key_node, errp);
354 if (!val) {
355 return NULL;
356 }
357 if (val != ent->value) {
358 qdict_put_obj(cur, ent->key, val);
359 }
360 }
361
362 if (has_index && has_member) {
363 key = reassemble_key(key_of_cur);
364 error_setg(errp, "Parameters '%s*' used inconsistently", key);
365 g_free(key);
366 return NULL;
367 }
368 if (!has_index) {
369 return QOBJECT(cur);
370 }
371
372
373 nelt = qdict_size(cur) + 1;
374 elt = g_new0(QObject *, nelt);
375 max_index = -1;
376 for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
377 index = key_to_index(ent->key, NULL);
378 assert(index >= 0);
379 if (index > max_index) {
380 max_index = index;
381 }
382
383
384
385
386
387 if ((size_t)index >= nelt - 1) {
388 continue;
389 }
390
391 elt[index] = ent->value;
392 }
393
394
395
396
397
398
399
400 list = qlist_new();
401 assert(!elt[nelt-1]);
402 for (i = 0; i < MIN(nelt, max_index + 1); i++) {
403 if (!elt[i]) {
404 key = reassemble_key(key_of_cur);
405 error_setg(errp, "Parameter '%s%d' missing", key, i);
406 g_free(key);
407 g_free(elt);
408 qobject_unref(list);
409 return NULL;
410 }
411 qobject_ref(elt[i]);
412 qlist_append_obj(list, elt[i]);
413 }
414
415 g_free(elt);
416 return QOBJECT(list);
417}
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436QDict *keyval_parse(const char *params, const char *implied_key,
437 bool *p_help, Error **errp)
438{
439 QDict *qdict = qdict_new();
440 QObject *listified;
441 const char *s;
442 bool help = false;
443
444 s = params;
445 while (*s) {
446 s = keyval_parse_one(qdict, s, implied_key, &help, errp);
447 if (!s) {
448 qobject_unref(qdict);
449 return NULL;
450 }
451 implied_key = NULL;
452 }
453
454 if (p_help) {
455 *p_help = help;
456 } else if (help) {
457 error_setg(errp, "Help is not available for this option");
458 qobject_unref(qdict);
459 return NULL;
460 }
461
462 listified = keyval_listify(qdict, NULL, errp);
463 if (!listified) {
464 qobject_unref(qdict);
465 return NULL;
466 }
467 assert(listified == QOBJECT(qdict));
468 return qdict;
469}
470