virtio-9p: Add string manipulation support.
[qemu.git] / qemu-option.c
blob076dddfc026c02bc3eb40b826c9b0222f0d872a4
1 /*
2 * Commandline option parsing functions
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009 Kevin Wolf <kwolf@redhat.com>
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
26 #include <stdio.h>
27 #include <string.h>
29 #include "qemu-common.h"
30 #include "qemu-error.h"
31 #include "qemu-objects.h"
32 #include "qemu-option.h"
33 #include "qerror.h"
36 * Extracts the name of an option from the parameter string (p points at the
37 * first byte of the option name)
39 * The option name is delimited by delim (usually , or =) or the string end
40 * and is copied into buf. If the option name is longer than buf_size, it is
41 * truncated. buf is always zero terminated.
43 * The return value is the position of the delimiter/zero byte after the option
44 * name in p.
46 const char *get_opt_name(char *buf, int buf_size, const char *p, char delim)
48 char *q;
50 q = buf;
51 while (*p != '\0' && *p != delim) {
52 if (q && (q - buf) < buf_size - 1)
53 *q++ = *p;
54 p++;
56 if (q)
57 *q = '\0';
59 return p;
63 * Extracts the value of an option from the parameter string p (p points at the
64 * first byte of the option value)
66 * This function is comparable to get_opt_name with the difference that the
67 * delimiter is fixed to be comma which starts a new option. To specify an
68 * option value that contains commas, double each comma.
70 const char *get_opt_value(char *buf, int buf_size, const char *p)
72 char *q;
74 q = buf;
75 while (*p != '\0') {
76 if (*p == ',') {
77 if (*(p + 1) != ',')
78 break;
79 p++;
81 if (q && (q - buf) < buf_size - 1)
82 *q++ = *p;
83 p++;
85 if (q)
86 *q = '\0';
88 return p;
91 int get_next_param_value(char *buf, int buf_size,
92 const char *tag, const char **pstr)
94 const char *p;
95 char option[128];
97 p = *pstr;
98 for(;;) {
99 p = get_opt_name(option, sizeof(option), p, '=');
100 if (*p != '=')
101 break;
102 p++;
103 if (!strcmp(tag, option)) {
104 *pstr = get_opt_value(buf, buf_size, p);
105 if (**pstr == ',') {
106 (*pstr)++;
108 return strlen(buf);
109 } else {
110 p = get_opt_value(NULL, 0, p);
112 if (*p != ',')
113 break;
114 p++;
116 return 0;
119 int get_param_value(char *buf, int buf_size,
120 const char *tag, const char *str)
122 return get_next_param_value(buf, buf_size, tag, &str);
125 int check_params(char *buf, int buf_size,
126 const char * const *params, const char *str)
128 const char *p;
129 int i;
131 p = str;
132 while (*p != '\0') {
133 p = get_opt_name(buf, buf_size, p, '=');
134 if (*p != '=') {
135 return -1;
137 p++;
138 for (i = 0; params[i] != NULL; i++) {
139 if (!strcmp(params[i], buf)) {
140 break;
143 if (params[i] == NULL) {
144 return -1;
146 p = get_opt_value(NULL, 0, p);
147 if (*p != ',') {
148 break;
150 p++;
152 return 0;
156 * Searches an option list for an option with the given name
158 QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list,
159 const char *name)
161 while (list && list->name) {
162 if (!strcmp(list->name, name)) {
163 return list;
165 list++;
168 return NULL;
171 static int parse_option_bool(const char *name, const char *value, int *ret)
173 if (value != NULL) {
174 if (!strcmp(value, "on")) {
175 *ret = 1;
176 } else if (!strcmp(value, "off")) {
177 *ret = 0;
178 } else {
179 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'");
180 return -1;
182 } else {
183 *ret = 1;
185 return 0;
188 static int parse_option_number(const char *name, const char *value, uint64_t *ret)
190 char *postfix;
191 uint64_t number;
193 if (value != NULL) {
194 number = strtoull(value, &postfix, 0);
195 if (*postfix != '\0') {
196 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number");
197 return -1;
199 *ret = number;
200 } else {
201 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number");
202 return -1;
204 return 0;
207 static int parse_option_size(const char *name, const char *value, uint64_t *ret)
209 char *postfix;
210 double sizef;
212 if (value != NULL) {
213 sizef = strtod(value, &postfix);
214 switch (*postfix) {
215 case 'T':
216 sizef *= 1024;
217 case 'G':
218 sizef *= 1024;
219 case 'M':
220 sizef *= 1024;
221 case 'K':
222 case 'k':
223 sizef *= 1024;
224 case 'b':
225 case '\0':
226 *ret = (uint64_t) sizef;
227 break;
228 default:
229 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size");
230 error_printf_unless_qmp("You may use k, M, G or T suffixes for "
231 "kilobytes, megabytes, gigabytes and terabytes.\n");
232 return -1;
234 } else {
235 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size");
236 return -1;
238 return 0;
242 * Sets the value of a parameter in a given option list. The parsing of the
243 * value depends on the type of option:
245 * OPT_FLAG (uses value.n):
246 * If no value is given, the flag is set to 1.
247 * Otherwise the value must be "on" (set to 1) or "off" (set to 0)
249 * OPT_STRING (uses value.s):
250 * value is strdup()ed and assigned as option value
252 * OPT_SIZE (uses value.n):
253 * The value is converted to an integer. Suffixes for kilobytes etc. are
254 * allowed (powers of 1024).
256 * Returns 0 on succes, -1 in error cases
258 int set_option_parameter(QEMUOptionParameter *list, const char *name,
259 const char *value)
261 int flag;
263 // Find a matching parameter
264 list = get_option_parameter(list, name);
265 if (list == NULL) {
266 fprintf(stderr, "Unknown option '%s'\n", name);
267 return -1;
270 // Process parameter
271 switch (list->type) {
272 case OPT_FLAG:
273 if (parse_option_bool(name, value, &flag) == -1)
274 return -1;
275 list->value.n = flag;
276 break;
278 case OPT_STRING:
279 if (value != NULL) {
280 list->value.s = qemu_strdup(value);
281 } else {
282 fprintf(stderr, "Option '%s' needs a parameter\n", name);
283 return -1;
285 break;
287 case OPT_SIZE:
288 if (parse_option_size(name, value, &list->value.n) == -1)
289 return -1;
290 break;
292 default:
293 fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name);
294 return -1;
297 return 0;
301 * Sets the given parameter to an integer instead of a string.
302 * This function cannot be used to set string options.
304 * Returns 0 on success, -1 in error cases
306 int set_option_parameter_int(QEMUOptionParameter *list, const char *name,
307 uint64_t value)
309 // Find a matching parameter
310 list = get_option_parameter(list, name);
311 if (list == NULL) {
312 fprintf(stderr, "Unknown option '%s'\n", name);
313 return -1;
316 // Process parameter
317 switch (list->type) {
318 case OPT_FLAG:
319 case OPT_NUMBER:
320 case OPT_SIZE:
321 list->value.n = value;
322 break;
324 default:
325 return -1;
328 return 0;
332 * Frees a option list. If it contains strings, the strings are freed as well.
334 void free_option_parameters(QEMUOptionParameter *list)
336 QEMUOptionParameter *cur = list;
338 while (cur && cur->name) {
339 if (cur->type == OPT_STRING) {
340 qemu_free(cur->value.s);
342 cur++;
345 qemu_free(list);
349 * Parses a parameter string (param) into an option list (dest).
351 * list is the templace is. If dest is NULL, a new copy of list is created for
352 * it. If list is NULL, this function fails.
354 * A parameter string consists of one or more parameters, separated by commas.
355 * Each parameter consists of its name and possibly of a value. In the latter
356 * case, the value is delimited by an = character. To specify a value which
357 * contains commas, double each comma so it won't be recognized as the end of
358 * the parameter.
360 * For more details of the parsing see above.
362 * Returns a pointer to the first element of dest (or the newly allocated copy)
363 * or NULL in error cases
365 QEMUOptionParameter *parse_option_parameters(const char *param,
366 QEMUOptionParameter *list, QEMUOptionParameter *dest)
368 QEMUOptionParameter *cur;
369 QEMUOptionParameter *allocated = NULL;
370 char name[256];
371 char value[256];
372 char *param_delim, *value_delim;
373 char next_delim;
374 size_t num_options;
376 if (list == NULL) {
377 return NULL;
380 if (dest == NULL) {
381 // Count valid options
382 num_options = 0;
383 cur = list;
384 while (cur->name) {
385 num_options++;
386 cur++;
389 // Create a copy of the option list to fill in values
390 dest = qemu_mallocz((num_options + 1) * sizeof(QEMUOptionParameter));
391 allocated = dest;
392 memcpy(dest, list, (num_options + 1) * sizeof(QEMUOptionParameter));
395 while (*param) {
397 // Find parameter name and value in the string
398 param_delim = strchr(param, ',');
399 value_delim = strchr(param, '=');
401 if (value_delim && (value_delim < param_delim || !param_delim)) {
402 next_delim = '=';
403 } else {
404 next_delim = ',';
405 value_delim = NULL;
408 param = get_opt_name(name, sizeof(name), param, next_delim);
409 if (value_delim) {
410 param = get_opt_value(value, sizeof(value), param + 1);
412 if (*param != '\0') {
413 param++;
416 // Set the parameter
417 if (set_option_parameter(dest, name, value_delim ? value : NULL)) {
418 goto fail;
422 return dest;
424 fail:
425 // Only free the list if it was newly allocated
426 free_option_parameters(allocated);
427 return NULL;
431 * Prints all options of a list that have a value to stdout
433 void print_option_parameters(QEMUOptionParameter *list)
435 while (list && list->name) {
436 switch (list->type) {
437 case OPT_STRING:
438 if (list->value.s != NULL) {
439 printf("%s='%s' ", list->name, list->value.s);
441 break;
442 case OPT_FLAG:
443 printf("%s=%s ", list->name, list->value.n ? "on" : "off");
444 break;
445 case OPT_SIZE:
446 case OPT_NUMBER:
447 printf("%s=%" PRId64 " ", list->name, list->value.n);
448 break;
449 default:
450 printf("%s=(unkown type) ", list->name);
451 break;
453 list++;
458 * Prints an overview of all available options
460 void print_option_help(QEMUOptionParameter *list)
462 printf("Supported options:\n");
463 while (list && list->name) {
464 printf("%-16s %s\n", list->name,
465 list->help ? list->help : "No description available");
466 list++;
470 /* ------------------------------------------------------------------ */
472 struct QemuOpt {
473 const char *name;
474 const char *str;
476 const QemuOptDesc *desc;
477 union {
478 int boolean;
479 uint64_t uint;
480 } value;
482 QemuOpts *opts;
483 QTAILQ_ENTRY(QemuOpt) next;
486 struct QemuOpts {
487 char *id;
488 QemuOptsList *list;
489 Location loc;
490 QTAILQ_HEAD(QemuOptHead, QemuOpt) head;
491 QTAILQ_ENTRY(QemuOpts) next;
494 static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
496 QemuOpt *opt;
498 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
499 if (strcmp(opt->name, name) != 0)
500 continue;
501 return opt;
503 return NULL;
506 const char *qemu_opt_get(QemuOpts *opts, const char *name)
508 QemuOpt *opt = qemu_opt_find(opts, name);
509 return opt ? opt->str : NULL;
512 int qemu_opt_get_bool(QemuOpts *opts, const char *name, int defval)
514 QemuOpt *opt = qemu_opt_find(opts, name);
516 if (opt == NULL)
517 return defval;
518 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL);
519 return opt->value.boolean;
522 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval)
524 QemuOpt *opt = qemu_opt_find(opts, name);
526 if (opt == NULL)
527 return defval;
528 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER);
529 return opt->value.uint;
532 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval)
534 QemuOpt *opt = qemu_opt_find(opts, name);
536 if (opt == NULL)
537 return defval;
538 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE);
539 return opt->value.uint;
542 static int qemu_opt_parse(QemuOpt *opt)
544 if (opt->desc == NULL)
545 return 0;
546 switch (opt->desc->type) {
547 case QEMU_OPT_STRING:
548 /* nothing */
549 return 0;
550 case QEMU_OPT_BOOL:
551 return parse_option_bool(opt->name, opt->str, &opt->value.boolean);
552 case QEMU_OPT_NUMBER:
553 return parse_option_number(opt->name, opt->str, &opt->value.uint);
554 case QEMU_OPT_SIZE:
555 return parse_option_size(opt->name, opt->str, &opt->value.uint);
556 default:
557 abort();
561 static void qemu_opt_del(QemuOpt *opt)
563 QTAILQ_REMOVE(&opt->opts->head, opt, next);
564 qemu_free((/* !const */ char*)opt->name);
565 qemu_free((/* !const */ char*)opt->str);
566 qemu_free(opt);
569 int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
571 QemuOpt *opt;
572 const QemuOptDesc *desc = opts->list->desc;
573 int i;
575 for (i = 0; desc[i].name != NULL; i++) {
576 if (strcmp(desc[i].name, name) == 0) {
577 break;
580 if (desc[i].name == NULL) {
581 if (i == 0) {
582 /* empty list -> allow any */;
583 } else {
584 qerror_report(QERR_INVALID_PARAMETER, name);
585 return -1;
589 opt = qemu_mallocz(sizeof(*opt));
590 opt->name = qemu_strdup(name);
591 opt->opts = opts;
592 QTAILQ_INSERT_TAIL(&opts->head, opt, next);
593 if (desc[i].name != NULL) {
594 opt->desc = desc+i;
596 if (value) {
597 opt->str = qemu_strdup(value);
599 if (qemu_opt_parse(opt) < 0) {
600 qemu_opt_del(opt);
601 return -1;
603 return 0;
606 int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
607 int abort_on_failure)
609 QemuOpt *opt;
610 int rc = 0;
612 QTAILQ_FOREACH(opt, &opts->head, next) {
613 rc = func(opt->name, opt->str, opaque);
614 if (abort_on_failure && rc != 0)
615 break;
617 return rc;
620 QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)
622 QemuOpts *opts;
624 QTAILQ_FOREACH(opts, &list->head, next) {
625 if (!opts->id) {
626 continue;
628 if (strcmp(opts->id, id) != 0) {
629 continue;
631 return opts;
633 return NULL;
636 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists)
638 QemuOpts *opts = NULL;
640 if (id) {
641 opts = qemu_opts_find(list, id);
642 if (opts != NULL) {
643 if (fail_if_exists) {
644 qerror_report(QERR_DUPLICATE_ID, id, list->name);
645 return NULL;
646 } else {
647 return opts;
651 opts = qemu_mallocz(sizeof(*opts));
652 if (id) {
653 opts->id = qemu_strdup(id);
655 opts->list = list;
656 loc_save(&opts->loc);
657 QTAILQ_INIT(&opts->head);
658 QTAILQ_INSERT_TAIL(&list->head, opts, next);
659 return opts;
662 int qemu_opts_set(QemuOptsList *list, const char *id,
663 const char *name, const char *value)
665 QemuOpts *opts;
667 opts = qemu_opts_create(list, id, 1);
668 if (opts == NULL) {
669 return -1;
671 return qemu_opt_set(opts, name, value);
674 const char *qemu_opts_id(QemuOpts *opts)
676 return opts->id;
679 void qemu_opts_del(QemuOpts *opts)
681 QemuOpt *opt;
683 for (;;) {
684 opt = QTAILQ_FIRST(&opts->head);
685 if (opt == NULL)
686 break;
687 qemu_opt_del(opt);
689 QTAILQ_REMOVE(&opts->list->head, opts, next);
690 qemu_free(opts->id);
691 qemu_free(opts);
694 int qemu_opts_print(QemuOpts *opts, void *dummy)
696 QemuOpt *opt;
698 fprintf(stderr, "%s: %s:", opts->list->name,
699 opts->id ? opts->id : "<noid>");
700 QTAILQ_FOREACH(opt, &opts->head, next) {
701 fprintf(stderr, " %s=\"%s\"", opt->name, opt->str);
703 fprintf(stderr, "\n");
704 return 0;
707 int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname)
709 char option[128], value[1024];
710 const char *p,*pe,*pc;
712 for (p = params; *p != '\0'; p++) {
713 pe = strchr(p, '=');
714 pc = strchr(p, ',');
715 if (!pe || (pc && pc < pe)) {
716 /* found "foo,more" */
717 if (p == params && firstname) {
718 /* implicitly named first option */
719 pstrcpy(option, sizeof(option), firstname);
720 p = get_opt_value(value, sizeof(value), p);
721 } else {
722 /* option without value, probably a flag */
723 p = get_opt_name(option, sizeof(option), p, ',');
724 if (strncmp(option, "no", 2) == 0) {
725 memmove(option, option+2, strlen(option+2)+1);
726 pstrcpy(value, sizeof(value), "off");
727 } else {
728 pstrcpy(value, sizeof(value), "on");
731 } else {
732 /* found "foo=bar,more" */
733 p = get_opt_name(option, sizeof(option), p, '=');
734 if (*p != '=') {
735 break;
737 p++;
738 p = get_opt_value(value, sizeof(value), p);
740 if (strcmp(option, "id") != 0) {
741 /* store and parse */
742 if (qemu_opt_set(opts, option, value) == -1) {
743 return -1;
746 if (*p != ',') {
747 break;
750 return 0;
753 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
754 int permit_abbrev)
756 const char *firstname;
757 char value[1024], *id = NULL;
758 const char *p;
759 QemuOpts *opts;
761 assert(!permit_abbrev || list->implied_opt_name);
762 firstname = permit_abbrev ? list->implied_opt_name : NULL;
764 if (strncmp(params, "id=", 3) == 0) {
765 get_opt_value(value, sizeof(value), params+3);
766 id = value;
767 } else if ((p = strstr(params, ",id=")) != NULL) {
768 get_opt_value(value, sizeof(value), p+4);
769 id = value;
771 opts = qemu_opts_create(list, id, 1);
772 if (opts == NULL)
773 return NULL;
775 if (qemu_opts_do_parse(opts, params, firstname) != 0) {
776 qemu_opts_del(opts);
777 return NULL;
780 return opts;
783 static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
785 char buf[32];
786 const char *value;
787 int n;
789 if (!strcmp(key, "id")) {
790 return;
793 switch (qobject_type(obj)) {
794 case QTYPE_QSTRING:
795 value = qstring_get_str(qobject_to_qstring(obj));
796 break;
797 case QTYPE_QINT:
798 n = snprintf(buf, sizeof(buf), "%" PRId64,
799 qint_get_int(qobject_to_qint(obj)));
800 assert(n < sizeof(buf));
801 value = buf;
802 break;
803 case QTYPE_QFLOAT:
804 n = snprintf(buf, sizeof(buf), "%.17g",
805 qfloat_get_double(qobject_to_qfloat(obj)));
806 assert(n < sizeof(buf));
807 value = buf;
808 break;
809 case QTYPE_QBOOL:
810 pstrcpy(buf, sizeof(buf),
811 qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off");
812 value = buf;
813 break;
814 default:
815 return;
817 qemu_opt_set(opaque, key, value);
821 * Create QemuOpts from a QDict.
822 * Use value of key "id" as ID if it exists and is a QString.
823 * Only QStrings, QInts, QFloats and QBools are copied. Entries with
824 * other types are silently ignored.
826 QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict)
828 QemuOpts *opts;
830 opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1);
831 if (opts == NULL)
832 return NULL;
834 qdict_iter(qdict, qemu_opts_from_qdict_1, opts);
835 return opts;
839 * Convert from QemuOpts to QDict.
840 * The QDict values are of type QString.
841 * TODO We'll want to use types appropriate for opt->desc->type, but
842 * this is enough for now.
844 QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
846 QemuOpt *opt;
847 QObject *val;
849 if (!qdict) {
850 qdict = qdict_new();
852 if (opts->id) {
853 qdict_put(qdict, "id", qstring_from_str(opts->id));
855 QTAILQ_FOREACH(opt, &opts->head, next) {
856 val = QOBJECT(qstring_from_str(opt->str));
857 qdict_put_obj(qdict, opt->name, val);
859 return qdict;
862 /* Validate parsed opts against descriptions where no
863 * descriptions were provided in the QemuOptsList.
865 int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc)
867 QemuOpt *opt;
869 assert(opts->list->desc[0].name == NULL);
871 QTAILQ_FOREACH(opt, &opts->head, next) {
872 int i;
874 for (i = 0; desc[i].name != NULL; i++) {
875 if (strcmp(desc[i].name, opt->name) == 0) {
876 break;
879 if (desc[i].name == NULL) {
880 qerror_report(QERR_INVALID_PARAMETER, opt->name);
881 return -1;
884 opt->desc = &desc[i];
886 if (qemu_opt_parse(opt) < 0) {
887 return -1;
891 return 0;
894 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
895 int abort_on_failure)
897 Location loc;
898 QemuOpts *opts;
899 int rc = 0;
901 loc_push_none(&loc);
902 QTAILQ_FOREACH(opts, &list->head, next) {
903 loc_restore(&opts->loc);
904 rc |= func(opts, opaque);
905 if (abort_on_failure && rc != 0)
906 break;
908 loc_pop(&loc);
909 return rc;