Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 978 lines (861 sloc) 24.734 kb
68396ea @rmustacc Initial commit of d32e8d0b8d9e0ef7cf7ab2e74548982972789dfc from qemu-kvm
rmustacc authored
1 /*
2 * Commandline option parsing functions
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009 Kevin Wolf <kwolf@redhat.com>
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
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.
24 */
25
26 #include <stdio.h>
27 #include <string.h>
28
29 #include "qemu-common.h"
30 #include "qemu-error.h"
31 #include "qemu-objects.h"
32 #include "qemu-option.h"
33 #include "qerror.h"
34
35 /*
36 * Extracts the name of an option from the parameter string (p points at the
37 * first byte of the option name)
38 *
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.
42 *
43 * The return value is the position of the delimiter/zero byte after the option
44 * name in p.
45 */
46 const char *get_opt_name(char *buf, int buf_size, const char *p, char delim)
47 {
48 char *q;
49
50 q = buf;
51 while (*p != '\0' && *p != delim) {
52 if (q && (q - buf) < buf_size - 1)
53 *q++ = *p;
54 p++;
55 }
56 if (q)
57 *q = '\0';
58
59 return p;
60 }
61
62 /*
63 * Extracts the value of an option from the parameter string p (p points at the
64 * first byte of the option value)
65 *
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.
69 */
70 const char *get_opt_value(char *buf, int buf_size, const char *p)
71 {
72 char *q;
73
74 q = buf;
75 while (*p != '\0') {
76 if (*p == ',') {
77 if (*(p + 1) != ',')
78 break;
79 p++;
80 }
81 if (q && (q - buf) < buf_size - 1)
82 *q++ = *p;
83 p++;
84 }
85 if (q)
86 *q = '\0';
87
88 return p;
89 }
90
91 int get_next_param_value(char *buf, int buf_size,
92 const char *tag, const char **pstr)
93 {
94 const char *p;
95 char option[128];
96
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)++;
107 }
108 return strlen(buf);
109 } else {
110 p = get_opt_value(NULL, 0, p);
111 }
112 if (*p != ',')
113 break;
114 p++;
115 }
116 return 0;
117 }
118
119 int get_param_value(char *buf, int buf_size,
120 const char *tag, const char *str)
121 {
122 return get_next_param_value(buf, buf_size, tag, &str);
123 }
124
125 int check_params(char *buf, int buf_size,
126 const char * const *params, const char *str)
127 {
128 const char *p;
129 int i;
130
131 p = str;
132 while (*p != '\0') {
133 p = get_opt_name(buf, buf_size, p, '=');
134 if (*p != '=') {
135 return -1;
136 }
137 p++;
138 for (i = 0; params[i] != NULL; i++) {
139 if (!strcmp(params[i], buf)) {
140 break;
141 }
142 }
143 if (params[i] == NULL) {
144 return -1;
145 }
146 p = get_opt_value(NULL, 0, p);
147 if (*p != ',') {
148 break;
149 }
150 p++;
151 }
152 return 0;
153 }
154
155 /*
156 * Searches an option list for an option with the given name
157 */
158 QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list,
159 const char *name)
160 {
161 while (list && list->name) {
162 if (!strcmp(list->name, name)) {
163 return list;
164 }
165 list++;
166 }
167
168 return NULL;
169 }
170
171 static int parse_option_bool(const char *name, const char *value, int *ret)
172 {
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;
181 }
182 } else {
183 *ret = 1;
184 }
185 return 0;
186 }
187
188 static int parse_option_number(const char *name, const char *value, uint64_t *ret)
189 {
190 char *postfix;
191 uint64_t number;
192
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;
198 }
199 *ret = number;
200 } else {
201 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number");
202 return -1;
203 }
204 return 0;
205 }
206
207 static int parse_option_size(const char *name, const char *value, uint64_t *ret)
208 {
209 char *postfix;
210 double sizef;
211
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;
233 }
234 } else {
235 qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size");
236 return -1;
237 }
238 return 0;
239 }
240
241 /*
242 * Sets the value of a parameter in a given option list. The parsing of the
243 * value depends on the type of option:
244 *
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)
248 *
249 * OPT_STRING (uses value.s):
250 * value is strdup()ed and assigned as option value
251 *
252 * OPT_SIZE (uses value.n):
253 * The value is converted to an integer. Suffixes for kilobytes etc. are
254 * allowed (powers of 1024).
255 *
256 * Returns 0 on succes, -1 in error cases
257 */
258 int set_option_parameter(QEMUOptionParameter *list, const char *name,
259 const char *value)
260 {
261 int flag;
262
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;
268 }
269
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;
277
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;
284 }
285 break;
286
287 case OPT_SIZE:
288 if (parse_option_size(name, value, &list->value.n) == -1)
289 return -1;
290 break;
291
292 default:
293 fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name);
294 return -1;
295 }
296
297 return 0;
298 }
299
300 /*
301 * Sets the given parameter to an integer instead of a string.
302 * This function cannot be used to set string options.
303 *
304 * Returns 0 on success, -1 in error cases
305 */
306 int set_option_parameter_int(QEMUOptionParameter *list, const char *name,
307 uint64_t value)
308 {
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;
314 }
315
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;
323
324 default:
325 return -1;
326 }
327
328 return 0;
329 }
330
331 /*
332 * Frees a option list. If it contains strings, the strings are freed as well.
333 */
334 void free_option_parameters(QEMUOptionParameter *list)
335 {
336 QEMUOptionParameter *cur = list;
337
338 while (cur && cur->name) {
339 if (cur->type == OPT_STRING) {
340 qemu_free(cur->value.s);
341 }
342 cur++;
343 }
344
345 qemu_free(list);
346 }
347
348 /*
349 * Count valid options in list
350 */
351 static size_t count_option_parameters(QEMUOptionParameter *list)
352 {
353 size_t num_options = 0;
354
355 while (list && list->name) {
356 num_options++;
357 list++;
358 }
359
360 return num_options;
361 }
362
363 /*
364 * Append an option list (list) to an option list (dest).
365 *
366 * If dest is NULL, a new copy of list is created.
367 *
368 * Returns a pointer to the first element of dest (or the newly allocated copy)
369 */
370 QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest,
371 QEMUOptionParameter *list)
372 {
373 size_t num_options, num_dest_options;
374
375 num_options = count_option_parameters(dest);
376 num_dest_options = num_options;
377
378 num_options += count_option_parameters(list);
379
380 dest = qemu_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter));
381 dest[num_dest_options].name = NULL;
382
383 while (list && list->name) {
384 if (get_option_parameter(dest, list->name) == NULL) {
385 dest[num_dest_options++] = *list;
386 dest[num_dest_options].name = NULL;
387 }
388 list++;
389 }
390
391 return dest;
392 }
393
394 /*
395 * Parses a parameter string (param) into an option list (dest).
396 *
397 * list is the template option list. If dest is NULL, a new copy of list is
398 * created. If list is NULL, this function fails.
399 *
400 * A parameter string consists of one or more parameters, separated by commas.
401 * Each parameter consists of its name and possibly of a value. In the latter
402 * case, the value is delimited by an = character. To specify a value which
403 * contains commas, double each comma so it won't be recognized as the end of
404 * the parameter.
405 *
406 * For more details of the parsing see above.
407 *
408 * Returns a pointer to the first element of dest (or the newly allocated copy)
409 * or NULL in error cases
410 */
411 QEMUOptionParameter *parse_option_parameters(const char *param,
412 QEMUOptionParameter *list, QEMUOptionParameter *dest)
413 {
414 QEMUOptionParameter *allocated = NULL;
415 char name[256];
416 char value[256];
417 char *param_delim, *value_delim;
418 char next_delim;
419
420 if (list == NULL) {
421 return NULL;
422 }
423
424 if (dest == NULL) {
425 dest = allocated = append_option_parameters(NULL, list);
426 }
427
428 while (*param) {
429
430 // Find parameter name and value in the string
431 param_delim = strchr(param, ',');
432 value_delim = strchr(param, '=');
433
434 if (value_delim && (value_delim < param_delim || !param_delim)) {
435 next_delim = '=';
436 } else {
437 next_delim = ',';
438 value_delim = NULL;
439 }
440
441 param = get_opt_name(name, sizeof(name), param, next_delim);
442 if (value_delim) {
443 param = get_opt_value(value, sizeof(value), param + 1);
444 }
445 if (*param != '\0') {
446 param++;
447 }
448
449 // Set the parameter
450 if (set_option_parameter(dest, name, value_delim ? value : NULL)) {
451 goto fail;
452 }
453 }
454
455 return dest;
456
457 fail:
458 // Only free the list if it was newly allocated
459 free_option_parameters(allocated);
460 return NULL;
461 }
462
463 /*
464 * Prints all options of a list that have a value to stdout
465 */
466 void print_option_parameters(QEMUOptionParameter *list)
467 {
468 while (list && list->name) {
469 switch (list->type) {
470 case OPT_STRING:
471 if (list->value.s != NULL) {
472 printf("%s='%s' ", list->name, list->value.s);
473 }
474 break;
475 case OPT_FLAG:
476 printf("%s=%s ", list->name, list->value.n ? "on" : "off");
477 break;
478 case OPT_SIZE:
479 case OPT_NUMBER:
480 printf("%s=%" PRId64 " ", list->name, list->value.n);
481 break;
482 default:
483 printf("%s=(unkown type) ", list->name);
484 break;
485 }
486 list++;
487 }
488 }
489
490 /*
491 * Prints an overview of all available options
492 */
493 void print_option_help(QEMUOptionParameter *list)
494 {
495 printf("Supported options:\n");
496 while (list && list->name) {
497 printf("%-16s %s\n", list->name,
498 list->help ? list->help : "No description available");
499 list++;
500 }
501 }
502
503 /* ------------------------------------------------------------------ */
504
505 struct QemuOpt {
506 const char *name;
507 const char *str;
508
509 const QemuOptDesc *desc;
510 union {
511 int boolean;
512 uint64_t uint;
513 } value;
514
515 QemuOpts *opts;
516 QTAILQ_ENTRY(QemuOpt) next;
517 };
518
519 struct QemuOpts {
520 char *id;
521 QemuOptsList *list;
522 Location loc;
523 QTAILQ_HEAD(QemuOptHead, QemuOpt) head;
524 QTAILQ_ENTRY(QemuOpts) next;
525 };
526
527 static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
528 {
529 QemuOpt *opt;
530
531 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
532 if (strcmp(opt->name, name) != 0)
533 continue;
534 return opt;
535 }
536 return NULL;
537 }
538
539 const char *qemu_opt_get(QemuOpts *opts, const char *name)
540 {
541 QemuOpt *opt = qemu_opt_find(opts, name);
542 return opt ? opt->str : NULL;
543 }
544
545 int qemu_opt_get_bool(QemuOpts *opts, const char *name, int defval)
546 {
547 QemuOpt *opt = qemu_opt_find(opts, name);
548
549 if (opt == NULL)
550 return defval;
551 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL);
552 return opt->value.boolean;
553 }
554
555 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval)
556 {
557 QemuOpt *opt = qemu_opt_find(opts, name);
558
559 if (opt == NULL)
560 return defval;
561 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER);
562 return opt->value.uint;
563 }
564
565 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval)
566 {
567 QemuOpt *opt = qemu_opt_find(opts, name);
568
569 if (opt == NULL)
570 return defval;
571 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE);
572 return opt->value.uint;
573 }
574
575 static int qemu_opt_parse(QemuOpt *opt)
576 {
577 if (opt->desc == NULL)
578 return 0;
579 switch (opt->desc->type) {
580 case QEMU_OPT_STRING:
581 /* nothing */
582 return 0;
583 case QEMU_OPT_BOOL:
584 return parse_option_bool(opt->name, opt->str, &opt->value.boolean);
585 case QEMU_OPT_NUMBER:
586 return parse_option_number(opt->name, opt->str, &opt->value.uint);
587 case QEMU_OPT_SIZE:
588 return parse_option_size(opt->name, opt->str, &opt->value.uint);
589 default:
590 abort();
591 }
592 }
593
594 static void qemu_opt_del(QemuOpt *opt)
595 {
596 QTAILQ_REMOVE(&opt->opts->head, opt, next);
597 qemu_free((/* !const */ char*)opt->name);
598 qemu_free((/* !const */ char*)opt->str);
599 qemu_free(opt);
600 }
601
602 int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
603 {
604 QemuOpt *opt;
605 const QemuOptDesc *desc = opts->list->desc;
606 int i;
607
608 for (i = 0; desc[i].name != NULL; i++) {
609 if (strcmp(desc[i].name, name) == 0) {
610 break;
611 }
612 }
613 if (desc[i].name == NULL) {
614 if (i == 0) {
615 /* empty list -> allow any */;
616 } else {
617 qerror_report(QERR_INVALID_PARAMETER, name);
618 return -1;
619 }
620 }
621
622 opt = qemu_mallocz(sizeof(*opt));
623 opt->name = qemu_strdup(name);
624 opt->opts = opts;
625 QTAILQ_INSERT_TAIL(&opts->head, opt, next);
626 if (desc[i].name != NULL) {
627 opt->desc = desc+i;
628 }
629 if (value) {
630 opt->str = qemu_strdup(value);
631 }
632 if (qemu_opt_parse(opt) < 0) {
633 qemu_opt_del(opt);
634 return -1;
635 }
636 return 0;
637 }
638
639 int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
640 int abort_on_failure)
641 {
642 QemuOpt *opt;
643 int rc = 0;
644
645 QTAILQ_FOREACH(opt, &opts->head, next) {
646 rc = func(opt->name, opt->str, opaque);
647 if (abort_on_failure && rc != 0)
648 break;
649 }
650 return rc;
651 }
652
653 QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)
654 {
655 QemuOpts *opts;
656
657 QTAILQ_FOREACH(opts, &list->head, next) {
658 if (!opts->id) {
659 continue;
660 }
661 if (strcmp(opts->id, id) != 0) {
662 continue;
663 }
664 return opts;
665 }
666 return NULL;
667 }
668
669 static int id_wellformed(const char *id)
670 {
671 int i;
672
673 if (!qemu_isalpha(id[0])) {
674 return 0;
675 }
676 for (i = 1; id[i]; i++) {
677 if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) {
678 return 0;
679 }
680 }
681 return 1;
682 }
683
684 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists)
685 {
686 QemuOpts *opts = NULL;
687
688 if (id) {
689 if (!id_wellformed(id)) {
690 qerror_report(QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
691 error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n");
692 return NULL;
693 }
694 opts = qemu_opts_find(list, id);
695 if (opts != NULL) {
696 if (fail_if_exists) {
697 qerror_report(QERR_DUPLICATE_ID, id, list->name);
698 return NULL;
699 } else {
700 return opts;
701 }
702 }
703 }
704 opts = qemu_mallocz(sizeof(*opts));
705 if (id) {
706 opts->id = qemu_strdup(id);
707 }
708 opts->list = list;
709 loc_save(&opts->loc);
710 QTAILQ_INIT(&opts->head);
711 QTAILQ_INSERT_TAIL(&list->head, opts, next);
712 return opts;
713 }
714
715 void qemu_opts_reset(QemuOptsList *list)
716 {
717 QemuOpts *opts, *next_opts;
718
719 QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) {
720 qemu_opts_del(opts);
721 }
722 }
723
724 void qemu_opts_loc_restore(QemuOpts *opts)
725 {
726 loc_restore(&opts->loc);
727 }
728
729 int qemu_opts_set(QemuOptsList *list, const char *id,
730 const char *name, const char *value)
731 {
732 QemuOpts *opts;
733
734 opts = qemu_opts_create(list, id, 1);
735 if (opts == NULL) {
736 return -1;
737 }
738 return qemu_opt_set(opts, name, value);
739 }
740
741 const char *qemu_opts_id(QemuOpts *opts)
742 {
743 return opts->id;
744 }
745
746 void qemu_opts_del(QemuOpts *opts)
747 {
748 QemuOpt *opt;
749
750 for (;;) {
751 opt = QTAILQ_FIRST(&opts->head);
752 if (opt == NULL)
753 break;
754 qemu_opt_del(opt);
755 }
756 QTAILQ_REMOVE(&opts->list->head, opts, next);
757 qemu_free(opts->id);
758 qemu_free(opts);
759 }
760
761 int qemu_opts_print(QemuOpts *opts, void *dummy)
762 {
763 QemuOpt *opt;
764
765 fprintf(stderr, "%s: %s:", opts->list->name,
766 opts->id ? opts->id : "<noid>");
767 QTAILQ_FOREACH(opt, &opts->head, next) {
768 fprintf(stderr, " %s=\"%s\"", opt->name, opt->str);
769 }
770 fprintf(stderr, "\n");
771 return 0;
772 }
773
774 int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname)
775 {
776 char option[128], value[1024];
777 const char *p,*pe,*pc;
778
779 for (p = params; *p != '\0'; p++) {
780 pe = strchr(p, '=');
781 pc = strchr(p, ',');
782 if (!pe || (pc && pc < pe)) {
783 /* found "foo,more" */
784 if (p == params && firstname) {
785 /* implicitly named first option */
786 pstrcpy(option, sizeof(option), firstname);
787 p = get_opt_value(value, sizeof(value), p);
788 } else {
789 /* option without value, probably a flag */
790 p = get_opt_name(option, sizeof(option), p, ',');
791 if (strncmp(option, "no", 2) == 0) {
792 memmove(option, option+2, strlen(option+2)+1);
793 pstrcpy(value, sizeof(value), "off");
794 } else {
795 pstrcpy(value, sizeof(value), "on");
796 }
797 }
798 } else {
799 /* found "foo=bar,more" */
800 p = get_opt_name(option, sizeof(option), p, '=');
801 if (*p != '=') {
802 break;
803 }
804 p++;
805 p = get_opt_value(value, sizeof(value), p);
806 }
807 if (strcmp(option, "id") != 0) {
808 /* store and parse */
809 if (qemu_opt_set(opts, option, value) == -1) {
810 return -1;
811 }
812 }
813 if (*p != ',') {
814 break;
815 }
816 }
817 return 0;
818 }
819
820 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
821 int permit_abbrev)
822 {
823 const char *firstname;
824 char value[1024], *id = NULL;
825 const char *p;
826 QemuOpts *opts;
827
828 assert(!permit_abbrev || list->implied_opt_name);
829 firstname = permit_abbrev ? list->implied_opt_name : NULL;
830
831 if (strncmp(params, "id=", 3) == 0) {
832 get_opt_value(value, sizeof(value), params+3);
833 id = value;
834 } else if ((p = strstr(params, ",id=")) != NULL) {
835 get_opt_value(value, sizeof(value), p+4);
836 id = value;
837 }
838 opts = qemu_opts_create(list, id, 1);
839 if (opts == NULL)
840 return NULL;
841
842 if (qemu_opts_do_parse(opts, params, firstname) != 0) {
843 qemu_opts_del(opts);
844 return NULL;
845 }
846
847 return opts;
848 }
849
850 static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
851 {
852 char buf[32];
853 const char *value;
854 int n;
855
856 if (!strcmp(key, "id")) {
857 return;
858 }
859
860 switch (qobject_type(obj)) {
861 case QTYPE_QSTRING:
862 value = qstring_get_str(qobject_to_qstring(obj));
863 break;
864 case QTYPE_QINT:
865 n = snprintf(buf, sizeof(buf), "%" PRId64,
866 qint_get_int(qobject_to_qint(obj)));
867 assert(n < sizeof(buf));
868 value = buf;
869 break;
870 case QTYPE_QFLOAT:
871 n = snprintf(buf, sizeof(buf), "%.17g",
872 qfloat_get_double(qobject_to_qfloat(obj)));
873 assert(n < sizeof(buf));
874 value = buf;
875 break;
876 case QTYPE_QBOOL:
877 pstrcpy(buf, sizeof(buf),
878 qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off");
879 value = buf;
880 break;
881 default:
882 return;
883 }
884 qemu_opt_set(opaque, key, value);
885 }
886
887 /*
888 * Create QemuOpts from a QDict.
889 * Use value of key "id" as ID if it exists and is a QString.
890 * Only QStrings, QInts, QFloats and QBools are copied. Entries with
891 * other types are silently ignored.
892 */
893 QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict)
894 {
895 QemuOpts *opts;
896
897 opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1);
898 if (opts == NULL)
899 return NULL;
900
901 qdict_iter(qdict, qemu_opts_from_qdict_1, opts);
902 return opts;
903 }
904
905 /*
906 * Convert from QemuOpts to QDict.
907 * The QDict values are of type QString.
908 * TODO We'll want to use types appropriate for opt->desc->type, but
909 * this is enough for now.
910 */
911 QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
912 {
913 QemuOpt *opt;
914 QObject *val;
915
916 if (!qdict) {
917 qdict = qdict_new();
918 }
919 if (opts->id) {
920 qdict_put(qdict, "id", qstring_from_str(opts->id));
921 }
922 QTAILQ_FOREACH(opt, &opts->head, next) {
923 val = QOBJECT(qstring_from_str(opt->str));
924 qdict_put_obj(qdict, opt->name, val);
925 }
926 return qdict;
927 }
928
929 /* Validate parsed opts against descriptions where no
930 * descriptions were provided in the QemuOptsList.
931 */
932 int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc)
933 {
934 QemuOpt *opt;
935
936 assert(opts->list->desc[0].name == NULL);
937
938 QTAILQ_FOREACH(opt, &opts->head, next) {
939 int i;
940
941 for (i = 0; desc[i].name != NULL; i++) {
942 if (strcmp(desc[i].name, opt->name) == 0) {
943 break;
944 }
945 }
946 if (desc[i].name == NULL) {
947 qerror_report(QERR_INVALID_PARAMETER, opt->name);
948 return -1;
949 }
950
951 opt->desc = &desc[i];
952
953 if (qemu_opt_parse(opt) < 0) {
954 return -1;
955 }
956 }
957
958 return 0;
959 }
960
961 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
962 int abort_on_failure)
963 {
964 Location loc;
965 QemuOpts *opts;
966 int rc = 0;
967
968 loc_push_none(&loc);
969 QTAILQ_FOREACH(opts, &list->head, next) {
970 loc_restore(&opts->loc);
971 rc |= func(opts, opaque);
972 if (abort_on_failure && rc != 0)
973 break;
974 }
975 loc_pop(&loc);
976 return rc;
977 }
Something went wrong with that request. Please try again.