1d454dbe0SMarkus Armbruster /*
2d454dbe0SMarkus Armbruster * Parsing KEY=VALUE,... strings
3d454dbe0SMarkus Armbruster *
4d454dbe0SMarkus Armbruster * Copyright (C) 2017 Red Hat Inc.
5d454dbe0SMarkus Armbruster *
6d454dbe0SMarkus Armbruster * Authors:
7d454dbe0SMarkus Armbruster * Markus Armbruster <armbru@redhat.com>,
8d454dbe0SMarkus Armbruster *
9d454dbe0SMarkus Armbruster * This work is licensed under the terms of the GNU GPL, version 2 or later.
10d454dbe0SMarkus Armbruster * See the COPYING file in the top-level directory.
11d454dbe0SMarkus Armbruster */
12d454dbe0SMarkus Armbruster
13d454dbe0SMarkus Armbruster /*
14d454dbe0SMarkus Armbruster * KEY=VALUE,... syntax:
15d454dbe0SMarkus Armbruster *
16d454dbe0SMarkus Armbruster * key-vals = [ key-val { ',' key-val } [ ',' ] ]
178bf12c4fSKevin Wolf * key-val = key '=' val | help
18d454dbe0SMarkus Armbruster * key = key-fragment { '.' key-fragment }
19bbe0342bSMarkus Armbruster * key-fragment = qapi-name | index
20bbe0342bSMarkus Armbruster * qapi-name = '__' / [a-z0-9.-]+ / '_' / [A-Za-z][A-Za-z0-9_-]* /
21bbe0342bSMarkus Armbruster * index = / [0-9]+ /
22fec33318SMarkus Armbruster * val = { / [^,]+ / | ',,' }
238bf12c4fSKevin Wolf * help = 'help' | '?'
24d454dbe0SMarkus Armbruster *
25d454dbe0SMarkus Armbruster * Semantics defined by reduction to JSON:
26d454dbe0SMarkus Armbruster *
27fae425d7SMarkus Armbruster * key-vals specifies a JSON object, i.e. a tree whose root is an
28fae425d7SMarkus Armbruster * object, inner nodes other than the root are objects or arrays,
29fae425d7SMarkus Armbruster * and leaves are strings.
30d454dbe0SMarkus Armbruster *
31fae425d7SMarkus Armbruster * Each key-val = key-fragment '.' ... '=' val specifies a path from
32fae425d7SMarkus Armbruster * root to a leaf (left of '='), and the leaf's value (right of
33fae425d7SMarkus Armbruster * '=').
34d454dbe0SMarkus Armbruster *
35fae425d7SMarkus Armbruster * A path from the root is defined recursively:
36fae425d7SMarkus Armbruster * L '.' key-fragment is a child of the node denoted by path L
37fae425d7SMarkus Armbruster * key-fragment is a child of the tree root
38fae425d7SMarkus Armbruster * If key-fragment is numeric, the parent is an array and the child
39fae425d7SMarkus Armbruster * is its key-fragment-th member, counting from zero.
40fae425d7SMarkus Armbruster * Else, the parent is an object, and the child is its member named
41fae425d7SMarkus Armbruster * key-fragment.
42d454dbe0SMarkus Armbruster *
43fae425d7SMarkus Armbruster * This constrains inner nodes to be either array or object. The
44fae425d7SMarkus Armbruster * constraints must be satisfiable. Counter-example: a.b=1,a=2 is
45fae425d7SMarkus Armbruster * not, because root.a must be an object to satisfy a.b=1 and a
46fae425d7SMarkus Armbruster * string to satisfy a=2.
47fae425d7SMarkus Armbruster *
48fae425d7SMarkus Armbruster * Array subscripts can occur in any order, but the set of
49fae425d7SMarkus Armbruster * subscripts must not have gaps. For instance, a.1=v is not okay,
50fae425d7SMarkus Armbruster * because root.a[0] is missing.
51fae425d7SMarkus Armbruster *
52fae425d7SMarkus Armbruster * If multiple key-val denote the same leaf, the last one determines
53fae425d7SMarkus Armbruster * the value.
54fae425d7SMarkus Armbruster *
55fae425d7SMarkus Armbruster * Key-fragments must be valid QAPI names or consist only of decimal
56fae425d7SMarkus Armbruster * digits.
57f7400483SMarkus Armbruster *
58d454dbe0SMarkus Armbruster * The length of any key-fragment must be between 1 and 127.
59d454dbe0SMarkus Armbruster *
608bf12c4fSKevin Wolf * If any key-val is help, the object is to be treated as a help
618bf12c4fSKevin Wolf * request.
628bf12c4fSKevin Wolf *
630b2c1beeSMarkus Armbruster * Design flaw: there is no way to denote an empty array or non-root
640b2c1beeSMarkus Armbruster * object. While interpreting "key absent" as empty seems natural
65d454dbe0SMarkus Armbruster * (removing a key-val from the input string removes the member when
66d454dbe0SMarkus Armbruster * there are more, so why not when it's the last), it doesn't work:
670b2c1beeSMarkus Armbruster * "key absent" already means "optional object/array absent", which
680b2c1beeSMarkus Armbruster * isn't the same as "empty object/array present".
69d454dbe0SMarkus Armbruster *
700ee9ae7cSMarkus Armbruster * Design flaw: scalar values can only be strings; there is no way to
710ee9ae7cSMarkus Armbruster * denote numbers, true, false or null. The special QObject input
720ee9ae7cSMarkus Armbruster * visitor returned by qobject_input_visitor_new_keyval() mostly hides
730ee9ae7cSMarkus Armbruster * this by automatically converting strings to the type the visitor
74c0644771SMarkus Armbruster * expects. Breaks down for type 'any', where the visitor's
75c0644771SMarkus Armbruster * expectation isn't clear. Code visiting 'any' needs to do the
76c0644771SMarkus Armbruster * conversion itself, but only when using this keyval visitor.
77c0644771SMarkus Armbruster * Awkward. Note that we carefully restrict alternate types to avoid
78c0644771SMarkus Armbruster * similar ambiguity.
790ee9ae7cSMarkus Armbruster *
80fec33318SMarkus Armbruster * Alternative syntax for use with an implied key:
81d454dbe0SMarkus Armbruster *
82fec33318SMarkus Armbruster * key-vals = [ key-val-1st { ',' key-val } [ ',' ] ]
83fec33318SMarkus Armbruster * key-val-1st = val-no-key | key-val
848bf12c4fSKevin Wolf * val-no-key = / [^=,]+ / - help
85d454dbe0SMarkus Armbruster *
86fec33318SMarkus Armbruster * where val-no-key is syntactic sugar for implied-key=val-no-key.
87fec33318SMarkus Armbruster *
88fec33318SMarkus Armbruster * Note that you can't use the sugared form when the value contains
89fec33318SMarkus Armbruster * '=' or ','.
90d454dbe0SMarkus Armbruster */
91d454dbe0SMarkus Armbruster
92d454dbe0SMarkus Armbruster #include "qemu/osdep.h"
93d454dbe0SMarkus Armbruster #include "qapi/error.h"
94452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h"
9547e6b297SMarkus Armbruster #include "qapi/qmp/qlist.h"
96d454dbe0SMarkus Armbruster #include "qapi/qmp/qstring.h"
970b2c1beeSMarkus Armbruster #include "qemu/cutils.h"
98*9ca9c893SMarc-André Lureau #include "qemu/keyval.h"
998bf12c4fSKevin Wolf #include "qemu/help_option.h"
100d454dbe0SMarkus Armbruster
101d454dbe0SMarkus Armbruster /*
1020b2c1beeSMarkus Armbruster * Convert @key to a list index.
103fae425d7SMarkus Armbruster * Convert all leading decimal digits to a (non-negative) number,
104fae425d7SMarkus Armbruster * capped at INT_MAX.
1050b2c1beeSMarkus Armbruster * If @end is non-null, assign a pointer to the first character after
1060b2c1beeSMarkus Armbruster * the number to *@end.
1070b2c1beeSMarkus Armbruster * Else, fail if any characters follow.
1080b2c1beeSMarkus Armbruster * On success, return the converted number.
1090b2c1beeSMarkus Armbruster * On failure, return a negative value.
1100b2c1beeSMarkus Armbruster * Note: since only digits are converted, no two keys can map to the
1110b2c1beeSMarkus Armbruster * same number, except by overflow to INT_MAX.
1120b2c1beeSMarkus Armbruster */
key_to_index(const char * key,const char ** end)1130b2c1beeSMarkus Armbruster static int key_to_index(const char *key, const char **end)
1140b2c1beeSMarkus Armbruster {
1150b2c1beeSMarkus Armbruster int ret;
1160b2c1beeSMarkus Armbruster unsigned long index;
1170b2c1beeSMarkus Armbruster
1180b2c1beeSMarkus Armbruster if (*key < '0' || *key > '9') {
1190b2c1beeSMarkus Armbruster return -EINVAL;
1200b2c1beeSMarkus Armbruster }
1210b2c1beeSMarkus Armbruster ret = qemu_strtoul(key, end, 10, &index);
1220b2c1beeSMarkus Armbruster if (ret) {
1230b2c1beeSMarkus Armbruster return ret == -ERANGE ? INT_MAX : ret;
1240b2c1beeSMarkus Armbruster }
1250b2c1beeSMarkus Armbruster return index <= INT_MAX ? index : INT_MAX;
1260b2c1beeSMarkus Armbruster }
1270b2c1beeSMarkus Armbruster
1280b2c1beeSMarkus Armbruster /*
129d454dbe0SMarkus Armbruster * Ensure @cur maps @key_in_cur the right way.
130d454dbe0SMarkus Armbruster * If @value is null, it needs to map to a QDict, else to this
131d454dbe0SMarkus Armbruster * QString.
132d454dbe0SMarkus Armbruster * If @cur doesn't have @key_in_cur, put an empty QDict or @value,
133d454dbe0SMarkus Armbruster * respectively.
134d454dbe0SMarkus Armbruster * Else, if it needs to map to a QDict, and already does, do nothing.
135d454dbe0SMarkus Armbruster * Else, if it needs to map to this QString, and already maps to a
136d454dbe0SMarkus Armbruster * QString, replace it by @value.
137d454dbe0SMarkus Armbruster * Else, fail because we have conflicting needs on how to map
138d454dbe0SMarkus Armbruster * @key_in_cur.
139d454dbe0SMarkus Armbruster * In any case, take over the reference to @value, i.e. if the caller
140cb3e7f08SMarc-André Lureau * wants to hold on to a reference, it needs to qobject_ref().
141d454dbe0SMarkus Armbruster * Use @key up to @key_cursor to identify the key in error messages.
142d454dbe0SMarkus Armbruster * On success, return the mapped value.
143d454dbe0SMarkus Armbruster * On failure, store an error through @errp and return NULL.
144d454dbe0SMarkus Armbruster */
keyval_parse_put(QDict * cur,const char * key_in_cur,QString * value,const char * key,const char * key_cursor,Error ** errp)145d454dbe0SMarkus Armbruster static QObject *keyval_parse_put(QDict *cur,
146d454dbe0SMarkus Armbruster const char *key_in_cur, QString *value,
147d454dbe0SMarkus Armbruster const char *key, const char *key_cursor,
148d454dbe0SMarkus Armbruster Error **errp)
149d454dbe0SMarkus Armbruster {
150d454dbe0SMarkus Armbruster QObject *old, *new;
151d454dbe0SMarkus Armbruster
152d454dbe0SMarkus Armbruster old = qdict_get(cur, key_in_cur);
153d454dbe0SMarkus Armbruster if (old) {
154d454dbe0SMarkus Armbruster if (qobject_type(old) != (value ? QTYPE_QSTRING : QTYPE_QDICT)) {
155d454dbe0SMarkus Armbruster error_setg(errp, "Parameters '%.*s.*' used inconsistently",
156d454dbe0SMarkus Armbruster (int)(key_cursor - key), key);
157cb3e7f08SMarc-André Lureau qobject_unref(value);
158d454dbe0SMarkus Armbruster return NULL;
159d454dbe0SMarkus Armbruster }
160d454dbe0SMarkus Armbruster if (!value) {
161d454dbe0SMarkus Armbruster return old; /* already QDict, do nothing */
162d454dbe0SMarkus Armbruster }
163d454dbe0SMarkus Armbruster new = QOBJECT(value); /* replacement */
164d454dbe0SMarkus Armbruster } else {
165d454dbe0SMarkus Armbruster new = value ? QOBJECT(value) : QOBJECT(qdict_new());
166d454dbe0SMarkus Armbruster }
167d454dbe0SMarkus Armbruster qdict_put_obj(cur, key_in_cur, new);
168d454dbe0SMarkus Armbruster return new;
169d454dbe0SMarkus Armbruster }
170d454dbe0SMarkus Armbruster
171d454dbe0SMarkus Armbruster /*
1728bf12c4fSKevin Wolf * Parse one parameter from @params.
1738bf12c4fSKevin Wolf *
1748bf12c4fSKevin Wolf * If we're looking at KEY=VALUE, store result in @qdict.
175d454dbe0SMarkus Armbruster * The first fragment of KEY applies to @qdict. Subsequent fragments
176d454dbe0SMarkus Armbruster * apply to nested QDicts, which are created on demand. @implied_key
177d454dbe0SMarkus Armbruster * is as in keyval_parse().
1788bf12c4fSKevin Wolf *
1798bf12c4fSKevin Wolf * If we're looking at "help" or "?", set *help to true.
1808bf12c4fSKevin Wolf *
1818bf12c4fSKevin Wolf * On success, return a pointer to the next parameter, or else to '\0'.
182d454dbe0SMarkus Armbruster * On failure, return NULL.
183d454dbe0SMarkus Armbruster */
keyval_parse_one(QDict * qdict,const char * params,const char * implied_key,bool * help,Error ** errp)184d454dbe0SMarkus Armbruster static const char *keyval_parse_one(QDict *qdict, const char *params,
1858bf12c4fSKevin Wolf const char *implied_key, bool *help,
186d454dbe0SMarkus Armbruster Error **errp)
187d454dbe0SMarkus Armbruster {
1887051ae6cSMarkus Armbruster const char *key, *key_end, *val_end, *s, *end;
189d454dbe0SMarkus Armbruster size_t len;
190d454dbe0SMarkus Armbruster char key_in_cur[128];
191d454dbe0SMarkus Armbruster QDict *cur;
192f7400483SMarkus Armbruster int ret;
193d454dbe0SMarkus Armbruster QObject *next;
1947ece4211SMarkus Armbruster GString *val;
195d454dbe0SMarkus Armbruster
196d454dbe0SMarkus Armbruster key = params;
1977051ae6cSMarkus Armbruster val_end = NULL;
198d454dbe0SMarkus Armbruster len = strcspn(params, "=,");
1998bf12c4fSKevin Wolf if (len && key[len] != '=') {
2008bf12c4fSKevin Wolf if (starts_with_help_option(key) == len) {
2018bf12c4fSKevin Wolf *help = true;
2028bf12c4fSKevin Wolf s = key + len;
2038bf12c4fSKevin Wolf if (*s == ',') {
2048bf12c4fSKevin Wolf s++;
2058bf12c4fSKevin Wolf }
2068bf12c4fSKevin Wolf return s;
2078bf12c4fSKevin Wolf }
2088bf12c4fSKevin Wolf if (implied_key) {
209d454dbe0SMarkus Armbruster /* Desugar implied key */
210d454dbe0SMarkus Armbruster key = implied_key;
2117051ae6cSMarkus Armbruster val_end = params + len;
212d454dbe0SMarkus Armbruster len = strlen(implied_key);
213d454dbe0SMarkus Armbruster }
2148bf12c4fSKevin Wolf }
215d454dbe0SMarkus Armbruster key_end = key + len;
216d454dbe0SMarkus Armbruster
217d454dbe0SMarkus Armbruster /*
218d454dbe0SMarkus Armbruster * Loop over key fragments: @s points to current fragment, it
219d454dbe0SMarkus Armbruster * applies to @cur. @key_in_cur[] holds the previous fragment.
220d454dbe0SMarkus Armbruster */
221d454dbe0SMarkus Armbruster cur = qdict;
222d454dbe0SMarkus Armbruster s = key;
223d454dbe0SMarkus Armbruster for (;;) {
2240b2c1beeSMarkus Armbruster /* Want a key index (unless it's first) or a QAPI name */
2250b2c1beeSMarkus Armbruster if (s != key && key_to_index(s, &end) >= 0) {
2260b2c1beeSMarkus Armbruster len = end - s;
2270b2c1beeSMarkus Armbruster } else {
228f7400483SMarkus Armbruster ret = parse_qapi_name(s, false);
229f7400483SMarkus Armbruster len = ret < 0 ? 0 : ret;
2300b2c1beeSMarkus Armbruster }
231f7400483SMarkus Armbruster assert(s + len <= key_end);
232f7400483SMarkus Armbruster if (!len || (s + len < key_end && s[len] != '.')) {
233d454dbe0SMarkus Armbruster assert(key != implied_key);
234d454dbe0SMarkus Armbruster error_setg(errp, "Invalid parameter '%.*s'",
235d454dbe0SMarkus Armbruster (int)(key_end - key), key);
236d454dbe0SMarkus Armbruster return NULL;
237d454dbe0SMarkus Armbruster }
238d454dbe0SMarkus Armbruster if (len >= sizeof(key_in_cur)) {
239d454dbe0SMarkus Armbruster assert(key != implied_key);
240d454dbe0SMarkus Armbruster error_setg(errp, "Parameter%s '%.*s' is too long",
241d454dbe0SMarkus Armbruster s != key || s + len != key_end ? " fragment" : "",
242d454dbe0SMarkus Armbruster (int)len, s);
243d454dbe0SMarkus Armbruster return NULL;
244d454dbe0SMarkus Armbruster }
245d454dbe0SMarkus Armbruster
246d454dbe0SMarkus Armbruster if (s != key) {
247d454dbe0SMarkus Armbruster next = keyval_parse_put(cur, key_in_cur, NULL,
248d454dbe0SMarkus Armbruster key, s - 1, errp);
249d454dbe0SMarkus Armbruster if (!next) {
250d454dbe0SMarkus Armbruster return NULL;
251d454dbe0SMarkus Armbruster }
2527dc847ebSMax Reitz cur = qobject_to(QDict, next);
253d454dbe0SMarkus Armbruster assert(cur);
254d454dbe0SMarkus Armbruster }
255d454dbe0SMarkus Armbruster
256d454dbe0SMarkus Armbruster memcpy(key_in_cur, s, len);
257d454dbe0SMarkus Armbruster key_in_cur[len] = 0;
258d454dbe0SMarkus Armbruster s += len;
259d454dbe0SMarkus Armbruster
260d454dbe0SMarkus Armbruster if (*s != '.') {
261d454dbe0SMarkus Armbruster break;
262d454dbe0SMarkus Armbruster }
263d454dbe0SMarkus Armbruster s++;
264d454dbe0SMarkus Armbruster }
265d454dbe0SMarkus Armbruster
266d454dbe0SMarkus Armbruster if (key == implied_key) {
267d454dbe0SMarkus Armbruster assert(!*s);
2687ece4211SMarkus Armbruster val = g_string_new_len(params, val_end - params);
2697051ae6cSMarkus Armbruster s = val_end;
2707051ae6cSMarkus Armbruster if (*s == ',') {
2717051ae6cSMarkus Armbruster s++;
2727051ae6cSMarkus Armbruster }
273d454dbe0SMarkus Armbruster } else {
274d454dbe0SMarkus Armbruster if (*s != '=') {
275d454dbe0SMarkus Armbruster error_setg(errp, "Expected '=' after parameter '%.*s'",
276d454dbe0SMarkus Armbruster (int)(s - key), key);
277d454dbe0SMarkus Armbruster return NULL;
278d454dbe0SMarkus Armbruster }
279d454dbe0SMarkus Armbruster s++;
280d454dbe0SMarkus Armbruster
2817ece4211SMarkus Armbruster val = g_string_new(NULL);
282d454dbe0SMarkus Armbruster for (;;) {
283d454dbe0SMarkus Armbruster if (!*s) {
284d454dbe0SMarkus Armbruster break;
285d454dbe0SMarkus Armbruster } else if (*s == ',') {
286d454dbe0SMarkus Armbruster s++;
287d454dbe0SMarkus Armbruster if (*s != ',') {
288d454dbe0SMarkus Armbruster break;
289d454dbe0SMarkus Armbruster }
290d454dbe0SMarkus Armbruster }
2917ece4211SMarkus Armbruster g_string_append_c(val, *s++);
292d454dbe0SMarkus Armbruster }
2937051ae6cSMarkus Armbruster }
294d454dbe0SMarkus Armbruster
2957ece4211SMarkus Armbruster if (!keyval_parse_put(cur, key_in_cur, qstring_from_gstring(val),
2967ece4211SMarkus Armbruster key, key_end, errp)) {
297d454dbe0SMarkus Armbruster return NULL;
298d454dbe0SMarkus Armbruster }
299d454dbe0SMarkus Armbruster return s;
300d454dbe0SMarkus Armbruster }
301d454dbe0SMarkus Armbruster
reassemble_key(GSList * key)3020b2c1beeSMarkus Armbruster static char *reassemble_key(GSList *key)
3030b2c1beeSMarkus Armbruster {
3040b2c1beeSMarkus Armbruster GString *s = g_string_new("");
3050b2c1beeSMarkus Armbruster GSList *p;
3060b2c1beeSMarkus Armbruster
3070b2c1beeSMarkus Armbruster for (p = key; p; p = p->next) {
3080b2c1beeSMarkus Armbruster g_string_prepend_c(s, '.');
3090b2c1beeSMarkus Armbruster g_string_prepend(s, (char *)p->data);
3100b2c1beeSMarkus Armbruster }
3110b2c1beeSMarkus Armbruster
3120b2c1beeSMarkus Armbruster return g_string_free(s, FALSE);
3130b2c1beeSMarkus Armbruster }
3140b2c1beeSMarkus Armbruster
3150b2c1beeSMarkus Armbruster /*
3169176e800SPaolo Bonzini * Recursive worker for keyval_merge.
3179176e800SPaolo Bonzini *
3189176e800SPaolo Bonzini * @str is the path that led to the * current dictionary (to be used for
3199176e800SPaolo Bonzini * error messages). It is modified internally but restored before the
3209176e800SPaolo Bonzini * function returns.
3219176e800SPaolo Bonzini */
keyval_do_merge(QDict * dest,const QDict * merged,GString * str,Error ** errp)3229176e800SPaolo Bonzini static void keyval_do_merge(QDict *dest, const QDict *merged, GString *str, Error **errp)
3239176e800SPaolo Bonzini {
3249176e800SPaolo Bonzini size_t save_len = str->len;
3259176e800SPaolo Bonzini const QDictEntry *ent;
3269176e800SPaolo Bonzini QObject *old_value;
3279176e800SPaolo Bonzini
3289176e800SPaolo Bonzini for (ent = qdict_first(merged); ent; ent = qdict_next(merged, ent)) {
3299176e800SPaolo Bonzini old_value = qdict_get(dest, ent->key);
3309176e800SPaolo Bonzini if (old_value) {
3319176e800SPaolo Bonzini if (qobject_type(old_value) != qobject_type(ent->value)) {
3329176e800SPaolo Bonzini error_setg(errp, "Parameter '%s%s' used inconsistently",
3339176e800SPaolo Bonzini str->str, ent->key);
3349176e800SPaolo Bonzini return;
3359176e800SPaolo Bonzini } else if (qobject_type(ent->value) == QTYPE_QDICT) {
3369176e800SPaolo Bonzini /* Merge sub-dictionaries. */
3379176e800SPaolo Bonzini g_string_append(str, ent->key);
3389176e800SPaolo Bonzini g_string_append_c(str, '.');
3399176e800SPaolo Bonzini keyval_do_merge(qobject_to(QDict, old_value),
3409176e800SPaolo Bonzini qobject_to(QDict, ent->value),
3419176e800SPaolo Bonzini str, errp);
3429176e800SPaolo Bonzini g_string_truncate(str, save_len);
3439176e800SPaolo Bonzini continue;
3449176e800SPaolo Bonzini } else if (qobject_type(ent->value) == QTYPE_QLIST) {
3459176e800SPaolo Bonzini /* Append to old list. */
3469176e800SPaolo Bonzini QList *old = qobject_to(QList, old_value);
3479176e800SPaolo Bonzini QList *new = qobject_to(QList, ent->value);
3489176e800SPaolo Bonzini const QListEntry *item;
3499176e800SPaolo Bonzini QLIST_FOREACH_ENTRY(new, item) {
3509176e800SPaolo Bonzini qobject_ref(item->value);
3519176e800SPaolo Bonzini qlist_append_obj(old, item->value);
3529176e800SPaolo Bonzini }
3539176e800SPaolo Bonzini continue;
3549176e800SPaolo Bonzini } else {
3559176e800SPaolo Bonzini assert(qobject_type(ent->value) == QTYPE_QSTRING);
3569176e800SPaolo Bonzini }
3579176e800SPaolo Bonzini }
3589176e800SPaolo Bonzini
3599176e800SPaolo Bonzini qobject_ref(ent->value);
3609176e800SPaolo Bonzini qdict_put_obj(dest, ent->key, ent->value);
3619176e800SPaolo Bonzini }
3629176e800SPaolo Bonzini }
3639176e800SPaolo Bonzini
3649176e800SPaolo Bonzini /* Merge the @merged dictionary into @dest.
3659176e800SPaolo Bonzini *
3669176e800SPaolo Bonzini * The dictionaries are expected to be returned by the keyval parser, and
3679176e800SPaolo Bonzini * therefore the only expected scalar type is the string. In case the same
3689176e800SPaolo Bonzini * path is present in both @dest and @merged, the semantics are as follows:
3699176e800SPaolo Bonzini *
3709176e800SPaolo Bonzini * - lists are concatenated
3719176e800SPaolo Bonzini *
3729176e800SPaolo Bonzini * - dictionaries are merged recursively
3739176e800SPaolo Bonzini *
3749176e800SPaolo Bonzini * - for scalar values, @merged wins
3759176e800SPaolo Bonzini *
3769176e800SPaolo Bonzini * In case an error is reported, @dest may already have been modified.
3779176e800SPaolo Bonzini *
3789176e800SPaolo Bonzini * This function can be used to implement semantics analogous to QemuOpts's
3799176e800SPaolo Bonzini * .merge_lists = true case, or to implement -set for options backed by QDicts.
3809176e800SPaolo Bonzini *
3819176e800SPaolo Bonzini * Note: while QemuOpts is commonly used so that repeated keys overwrite
3829176e800SPaolo Bonzini * ("last one wins"), it can also be used so that repeated keys build up
3839176e800SPaolo Bonzini * a list. keyval_merge() can only be used when the options' semantics are
3849176e800SPaolo Bonzini * the former, not the latter.
3859176e800SPaolo Bonzini */
keyval_merge(QDict * dest,const QDict * merged,Error ** errp)3869176e800SPaolo Bonzini void keyval_merge(QDict *dest, const QDict *merged, Error **errp)
3879176e800SPaolo Bonzini {
3889176e800SPaolo Bonzini GString *str;
3899176e800SPaolo Bonzini
3909176e800SPaolo Bonzini str = g_string_new("");
3919176e800SPaolo Bonzini keyval_do_merge(dest, merged, str, errp);
3929176e800SPaolo Bonzini g_string_free(str, TRUE);
3939176e800SPaolo Bonzini }
3949176e800SPaolo Bonzini
3959176e800SPaolo Bonzini /*
3960b2c1beeSMarkus Armbruster * Listify @cur recursively.
3970b2c1beeSMarkus Armbruster * Replace QDicts whose keys are all valid list indexes by QLists.
3980b2c1beeSMarkus Armbruster * @key_of_cur is the list of key fragments leading up to @cur.
3990b2c1beeSMarkus Armbruster * On success, return either @cur or its replacement.
4000b2c1beeSMarkus Armbruster * On failure, store an error through @errp and return NULL.
4010b2c1beeSMarkus Armbruster */
keyval_listify(QDict * cur,GSList * key_of_cur,Error ** errp)4020b2c1beeSMarkus Armbruster static QObject *keyval_listify(QDict *cur, GSList *key_of_cur, Error **errp)
4030b2c1beeSMarkus Armbruster {
4040b2c1beeSMarkus Armbruster GSList key_node;
4050b2c1beeSMarkus Armbruster bool has_index, has_member;
4060b2c1beeSMarkus Armbruster const QDictEntry *ent;
4070b2c1beeSMarkus Armbruster QDict *qdict;
4080b2c1beeSMarkus Armbruster QObject *val;
4090b2c1beeSMarkus Armbruster char *key;
4100b2c1beeSMarkus Armbruster size_t nelt;
4110b2c1beeSMarkus Armbruster QObject **elt;
4120b2c1beeSMarkus Armbruster int index, max_index, i;
4130b2c1beeSMarkus Armbruster QList *list;
4140b2c1beeSMarkus Armbruster
4150b2c1beeSMarkus Armbruster key_node.next = key_of_cur;
4160b2c1beeSMarkus Armbruster
4170b2c1beeSMarkus Armbruster /*
4180b2c1beeSMarkus Armbruster * Recursively listify @cur's members, and figure out whether @cur
4190b2c1beeSMarkus Armbruster * itself is to be listified.
4200b2c1beeSMarkus Armbruster */
4210b2c1beeSMarkus Armbruster has_index = false;
4220b2c1beeSMarkus Armbruster has_member = false;
4230b2c1beeSMarkus Armbruster for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
4240b2c1beeSMarkus Armbruster if (key_to_index(ent->key, NULL) >= 0) {
4250b2c1beeSMarkus Armbruster has_index = true;
4260b2c1beeSMarkus Armbruster } else {
4270b2c1beeSMarkus Armbruster has_member = true;
4280b2c1beeSMarkus Armbruster }
4290b2c1beeSMarkus Armbruster
4307dc847ebSMax Reitz qdict = qobject_to(QDict, ent->value);
4310b2c1beeSMarkus Armbruster if (!qdict) {
4320b2c1beeSMarkus Armbruster continue;
4330b2c1beeSMarkus Armbruster }
4340b2c1beeSMarkus Armbruster
4350b2c1beeSMarkus Armbruster key_node.data = ent->key;
4360b2c1beeSMarkus Armbruster val = keyval_listify(qdict, &key_node, errp);
4370b2c1beeSMarkus Armbruster if (!val) {
4380b2c1beeSMarkus Armbruster return NULL;
4390b2c1beeSMarkus Armbruster }
4400b2c1beeSMarkus Armbruster if (val != ent->value) {
4410b2c1beeSMarkus Armbruster qdict_put_obj(cur, ent->key, val);
4420b2c1beeSMarkus Armbruster }
4430b2c1beeSMarkus Armbruster }
4440b2c1beeSMarkus Armbruster
4450b2c1beeSMarkus Armbruster if (has_index && has_member) {
4460b2c1beeSMarkus Armbruster key = reassemble_key(key_of_cur);
4470b2c1beeSMarkus Armbruster error_setg(errp, "Parameters '%s*' used inconsistently", key);
4480b2c1beeSMarkus Armbruster g_free(key);
4490b2c1beeSMarkus Armbruster return NULL;
4500b2c1beeSMarkus Armbruster }
4510b2c1beeSMarkus Armbruster if (!has_index) {
4520b2c1beeSMarkus Armbruster return QOBJECT(cur);
4530b2c1beeSMarkus Armbruster }
4540b2c1beeSMarkus Armbruster
4550b2c1beeSMarkus Armbruster /* Copy @cur's values to @elt[] */
4560b2c1beeSMarkus Armbruster nelt = qdict_size(cur) + 1; /* one extra, for use as sentinel */
4570b2c1beeSMarkus Armbruster elt = g_new0(QObject *, nelt);
4580b2c1beeSMarkus Armbruster max_index = -1;
4590b2c1beeSMarkus Armbruster for (ent = qdict_first(cur); ent; ent = qdict_next(cur, ent)) {
4600b2c1beeSMarkus Armbruster index = key_to_index(ent->key, NULL);
4610b2c1beeSMarkus Armbruster assert(index >= 0);
4620b2c1beeSMarkus Armbruster if (index > max_index) {
4630b2c1beeSMarkus Armbruster max_index = index;
4640b2c1beeSMarkus Armbruster }
4650b2c1beeSMarkus Armbruster /*
4660b2c1beeSMarkus Armbruster * We iterate @nelt times. If we get one exceeding @nelt
4670b2c1beeSMarkus Armbruster * here, we will put less than @nelt values into @elt[],
4680b2c1beeSMarkus Armbruster * triggering the error in the next loop.
4690b2c1beeSMarkus Armbruster */
4700b2c1beeSMarkus Armbruster if ((size_t)index >= nelt - 1) {
4710b2c1beeSMarkus Armbruster continue;
4720b2c1beeSMarkus Armbruster }
4730b2c1beeSMarkus Armbruster /* Even though dict keys are distinct, indexes need not be */
4740b2c1beeSMarkus Armbruster elt[index] = ent->value;
4750b2c1beeSMarkus Armbruster }
4760b2c1beeSMarkus Armbruster
4770b2c1beeSMarkus Armbruster /*
478fae425d7SMarkus Armbruster * Make a list from @elt[], reporting the first missing element,
479fae425d7SMarkus Armbruster * if any.
4800b2c1beeSMarkus Armbruster * If we dropped an index >= nelt in the previous loop, this loop
4810b2c1beeSMarkus Armbruster * will run into the sentinel and report index @nelt missing.
4820b2c1beeSMarkus Armbruster */
4830b2c1beeSMarkus Armbruster list = qlist_new();
4840b2c1beeSMarkus Armbruster assert(!elt[nelt-1]); /* need the sentinel to be null */
4850b2c1beeSMarkus Armbruster for (i = 0; i < MIN(nelt, max_index + 1); i++) {
4860b2c1beeSMarkus Armbruster if (!elt[i]) {
4870b2c1beeSMarkus Armbruster key = reassemble_key(key_of_cur);
4880b2c1beeSMarkus Armbruster error_setg(errp, "Parameter '%s%d' missing", key, i);
4890b2c1beeSMarkus Armbruster g_free(key);
4900b2c1beeSMarkus Armbruster g_free(elt);
491cb3e7f08SMarc-André Lureau qobject_unref(list);
4920b2c1beeSMarkus Armbruster return NULL;
4930b2c1beeSMarkus Armbruster }
494cb3e7f08SMarc-André Lureau qobject_ref(elt[i]);
4950b2c1beeSMarkus Armbruster qlist_append_obj(list, elt[i]);
4960b2c1beeSMarkus Armbruster }
4970b2c1beeSMarkus Armbruster
4980b2c1beeSMarkus Armbruster g_free(elt);
4990b2c1beeSMarkus Armbruster return QOBJECT(list);
5000b2c1beeSMarkus Armbruster }
5010b2c1beeSMarkus Armbruster
502d454dbe0SMarkus Armbruster /*
503d454dbe0SMarkus Armbruster * Parse @params in QEMU's traditional KEY=VALUE,... syntax.
5048bf12c4fSKevin Wolf *
505d454dbe0SMarkus Armbruster * If @implied_key, the first KEY= can be omitted. @implied_key is
506d454dbe0SMarkus Armbruster * implied then, and VALUE can't be empty or contain ',' or '='.
5078bf12c4fSKevin Wolf *
5088bf12c4fSKevin Wolf * A parameter "help" or "?" without a value isn't added to the
5098bf12c4fSKevin Wolf * resulting dictionary, but instead is interpreted as help request.
5108bf12c4fSKevin Wolf * All other options are parsed and returned normally so that context
5118bf12c4fSKevin Wolf * specific help can be printed.
5128bf12c4fSKevin Wolf *
5138bf12c4fSKevin Wolf * If @p_help is not NULL, store whether help is requested there.
5148bf12c4fSKevin Wolf * If @p_help is NULL and help is requested, fail.
5158bf12c4fSKevin Wolf *
516c445909eSPaolo Bonzini * On success, return @dict, now filled with the parsed keys and values.
517c445909eSPaolo Bonzini *
518c445909eSPaolo Bonzini * On failure, store an error through @errp and return NULL. Any keys
519c445909eSPaolo Bonzini * and values parsed so far will be in @dict nevertheless.
520d454dbe0SMarkus Armbruster */
keyval_parse_into(QDict * qdict,const char * params,const char * implied_key,bool * p_help,Error ** errp)521c445909eSPaolo Bonzini QDict *keyval_parse_into(QDict *qdict, const char *params, const char *implied_key,
5228bf12c4fSKevin Wolf bool *p_help, Error **errp)
523d454dbe0SMarkus Armbruster {
5240b2c1beeSMarkus Armbruster QObject *listified;
525d454dbe0SMarkus Armbruster const char *s;
5268bf12c4fSKevin Wolf bool help = false;
527d454dbe0SMarkus Armbruster
528d454dbe0SMarkus Armbruster s = params;
529d454dbe0SMarkus Armbruster while (*s) {
5308bf12c4fSKevin Wolf s = keyval_parse_one(qdict, s, implied_key, &help, errp);
531d454dbe0SMarkus Armbruster if (!s) {
532d454dbe0SMarkus Armbruster return NULL;
533d454dbe0SMarkus Armbruster }
534d454dbe0SMarkus Armbruster implied_key = NULL;
535d454dbe0SMarkus Armbruster }
536d454dbe0SMarkus Armbruster
5378bf12c4fSKevin Wolf if (p_help) {
5388bf12c4fSKevin Wolf *p_help = help;
5398bf12c4fSKevin Wolf } else if (help) {
5408bf12c4fSKevin Wolf error_setg(errp, "Help is not available for this option");
5418bf12c4fSKevin Wolf return NULL;
5428bf12c4fSKevin Wolf }
5438bf12c4fSKevin Wolf
5440b2c1beeSMarkus Armbruster listified = keyval_listify(qdict, NULL, errp);
5450b2c1beeSMarkus Armbruster if (!listified) {
5460b2c1beeSMarkus Armbruster return NULL;
5470b2c1beeSMarkus Armbruster }
5480b2c1beeSMarkus Armbruster assert(listified == QOBJECT(qdict));
549d454dbe0SMarkus Armbruster return qdict;
550d454dbe0SMarkus Armbruster }
551c445909eSPaolo Bonzini
552c445909eSPaolo Bonzini /*
553c445909eSPaolo Bonzini * Parse @params in QEMU's traditional KEY=VALUE,... syntax.
554c445909eSPaolo Bonzini *
555c445909eSPaolo Bonzini * If @implied_key, the first KEY= can be omitted. @implied_key is
556c445909eSPaolo Bonzini * implied then, and VALUE can't be empty or contain ',' or '='.
557c445909eSPaolo Bonzini *
558c445909eSPaolo Bonzini * A parameter "help" or "?" without a value isn't added to the
559c445909eSPaolo Bonzini * resulting dictionary, but instead is interpreted as help request.
560c445909eSPaolo Bonzini * All other options are parsed and returned normally so that context
561c445909eSPaolo Bonzini * specific help can be printed.
562c445909eSPaolo Bonzini *
563c445909eSPaolo Bonzini * If @p_help is not NULL, store whether help is requested there.
564c445909eSPaolo Bonzini * If @p_help is NULL and help is requested, fail.
565c445909eSPaolo Bonzini *
566c445909eSPaolo Bonzini * On success, return a dictionary of the parsed keys and values.
567c445909eSPaolo Bonzini * On failure, store an error through @errp and return NULL.
568c445909eSPaolo Bonzini */
keyval_parse(const char * params,const char * implied_key,bool * p_help,Error ** errp)569c445909eSPaolo Bonzini QDict *keyval_parse(const char *params, const char *implied_key,
570c445909eSPaolo Bonzini bool *p_help, Error **errp)
571c445909eSPaolo Bonzini {
572c445909eSPaolo Bonzini QDict *qdict = qdict_new();
573c445909eSPaolo Bonzini QDict *ret = keyval_parse_into(qdict, params, implied_key, p_help, errp);
574c445909eSPaolo Bonzini
575c445909eSPaolo Bonzini if (!ret) {
576c445909eSPaolo Bonzini qobject_unref(qdict);
577c445909eSPaolo Bonzini }
578c445909eSPaolo Bonzini return ret;
579c445909eSPaolo Bonzini }
580