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 GString *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 = g_string_new_len(params, 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 = g_string_new(NULL);
280 for (;;) {
281 if (!*s) {
282 break;
283 } else if (*s == ',') {
284 s++;
285 if (*s != ',') {
286 break;
287 }
288 }
289 g_string_append_c(val, *s++);
290 }
291 }
292
293 if (!keyval_parse_put(cur, key_in_cur, qstring_from_gstring(val),
294 key, key_end, errp)) {
295 return NULL;
296 }
297 return s;
298}
299
300static char *reassemble_key(GSList *key)
301{
302 GString *s = g_string_new("");
303 GSList *p;
304
305 for (p = key; p; p = p->next) {
306 g_string_prepend_c(s, '.');
307 g_string_prepend(s, (char *)p->data);
308 }
309
310 return g_string_free(s, FALSE);
311}
312
313
314
315
316
317
318
319
320static void keyval_do_merge(QDict *dest, const QDict *merged, GString *str, Error **errp)
321{
322 size_t save_len = str->len;
323 const QDictEntry *ent;
324 QObject *old_value;
325
326 for (ent = qdict_first(merged); ent; ent = qdict_next(merged, ent)) {
327 old_value = qdict_get(dest, ent->key);
328 if (old_value) {
329 if (qobject_type(old_value) != qobject_type(ent->value)) {
330 error_setg(errp, "Parameter '%s%s' used inconsistently",
331 str->str, ent->key);
332 return;
333 } else if (qobject_type(ent->value) == QTYPE_QDICT) {
334
335 g_string_append(str, ent->key);
336 g_string_append_c(str, '.');
337 keyval_do_merge(qobject_to(QDict, old_value),
338 qobject_to(QDict, ent->value),
339 str, errp);
340 g_string_truncate(str, save_len);
341 continue;
342 } else if (qobject_type(ent->value) == QTYPE_QLIST) {
343
344 QList *old = qobject_to(QList, old_value);
345 QList *new = qobject_to(QList, ent->value);
346 const QListEntry *item;
347 QLIST_FOREACH_ENTRY(new, item) {
348 qobject_ref(item->value);
349 qlist_append_obj(old, item->value);
350 }
351 continue;
352 } else {
353 assert(qobject_type(ent->value) == QTYPE_QSTRING);
354 }
355 }
356
357 qobject_ref(ent->value);
358 qdict_put_obj(dest, ent->key, ent->value);
359 }
360}
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384void keyval_merge(QDict *dest, const QDict *merged, Error **errp)
385{
386 GString *str;
387
388 str = g_string_new("");
389 keyval_do_merge(dest, merged, str, errp);
390 g_string_free(str, TRUE);
391}
392
393
394
395
396
397
398
399
400static QObject *keyval_listify(QDict *cur, GSList *key_of_cur, Error **errp)
401{
402 GSList key_node;
403 bool has_index, has_member;
404 const QDictEntry *ent;
405 QDict *qdict;
406 QObject *val;
407 char *key;
408 size_t nelt;
409 QObject **elt;
410 int index, max_index, i;
411 QList *list;
412
413 key_node.next = key_of_cur;
414
415
416
417
418
419 has_index = false;
420 has_member = false;
421 for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
422 if (key_to_index(ent->key, NULL) >= 0) {
423 has_index = true;
424 } else {
425 has_member = true;
426 }
427
428 qdict = qobject_to(QDict, ent->value);
429 if (!qdict) {
430 continue;
431 }
432
433 key_node.data = ent->key;
434 val = keyval_listify(qdict, &key_node, errp);
435 if (!val) {
436 return NULL;
437 }
438 if (val != ent->value) {
439 qdict_put_obj(cur, ent->key, val);
440 }
441 }
442
443 if (has_index && has_member) {
444 key = reassemble_key(key_of_cur);
445 error_setg(errp, "Parameters '%s*' used inconsistently", key);
446 g_free(key);
447 return NULL;
448 }
449 if (!has_index) {
450 return QOBJECT(cur);
451 }
452
453
454 nelt = qdict_size(cur) + 1;
455 elt = g_new0(QObject *, nelt);
456 max_index = -1;
457 for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
458 index = key_to_index(ent->key, NULL);
459 assert(index >= 0);
460 if (index > max_index) {
461 max_index = index;
462 }
463
464
465
466
467
468 if ((size_t)index >= nelt - 1) {
469 continue;
470 }
471
472 elt[index] = ent->value;
473 }
474
475
476
477
478
479
480
481 list = qlist_new();
482 assert(!elt[nelt-1]);
483 for (i = 0; i < MIN(nelt, max_index + 1); i++) {
484 if (!elt[i]) {
485 key = reassemble_key(key_of_cur);
486 error_setg(errp, "Parameter '%s%d' missing", key, i);
487 g_free(key);
488 g_free(elt);
489 qobject_unref(list);
490 return NULL;
491 }
492 qobject_ref(elt[i]);
493 qlist_append_obj(list, elt[i]);
494 }
495
496 g_free(elt);
497 return QOBJECT(list);
498}
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519QDict *keyval_parse_into(QDict *qdict, const char *params, const char *implied_key,
520 bool *p_help, Error **errp)
521{
522 QObject *listified;
523 const char *s;
524 bool help = false;
525
526 s = params;
527 while (*s) {
528 s = keyval_parse_one(qdict, s, implied_key, &help, errp);
529 if (!s) {
530 return NULL;
531 }
532 implied_key = NULL;
533 }
534
535 if (p_help) {
536 *p_help = help;
537 } else if (help) {
538 error_setg(errp, "Help is not available for this option");
539 return NULL;
540 }
541
542 listified = keyval_listify(qdict, NULL, errp);
543 if (!listified) {
544 return NULL;
545 }
546 assert(listified == QOBJECT(qdict));
547 return qdict;
548}
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567QDict *keyval_parse(const char *params, const char *implied_key,
568 bool *p_help, Error **errp)
569{
570 QDict *qdict = qdict_new();
571 QDict *ret = keyval_parse_into(qdict, params, implied_key, p_help, errp);
572
573 if (!ret) {
574 qobject_unref(qdict);
575 }
576 return ret;
577}
578