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-report.h" 31 #include "qapi/qmp/types.h" 32 #include "qapi/error.h" 33 #include "qapi/qmp/qerror.h" 34 #include "qemu/option_int.h" 35 36 /* 37 * Extracts the name of an option from the parameter string (p points at the 38 * first byte of the option name) 39 * 40 * The option name is delimited by delim (usually , or =) or the string end 41 * and is copied into buf. If the option name is longer than buf_size, it is 42 * truncated. buf is always zero terminated. 43 * 44 * The return value is the position of the delimiter/zero byte after the option 45 * name in p. 46 */ 47 const char *get_opt_name(char *buf, int buf_size, const char *p, char delim) 48 { 49 char *q; 50 51 q = buf; 52 while (*p != '\0' && *p != delim) { 53 if (q && (q - buf) < buf_size - 1) 54 *q++ = *p; 55 p++; 56 } 57 if (q) 58 *q = '\0'; 59 60 return p; 61 } 62 63 /* 64 * Extracts the value of an option from the parameter string p (p points at the 65 * first byte of the option value) 66 * 67 * This function is comparable to get_opt_name with the difference that the 68 * delimiter is fixed to be comma which starts a new option. To specify an 69 * option value that contains commas, double each comma. 70 */ 71 const char *get_opt_value(char *buf, int buf_size, const char *p) 72 { 73 char *q; 74 75 q = buf; 76 while (*p != '\0') { 77 if (*p == ',') { 78 if (*(p + 1) != ',') 79 break; 80 p++; 81 } 82 if (q && (q - buf) < buf_size - 1) 83 *q++ = *p; 84 p++; 85 } 86 if (q) 87 *q = '\0'; 88 89 return p; 90 } 91 92 int get_next_param_value(char *buf, int buf_size, 93 const char *tag, const char **pstr) 94 { 95 const char *p; 96 char option[128]; 97 98 p = *pstr; 99 for(;;) { 100 p = get_opt_name(option, sizeof(option), p, '='); 101 if (*p != '=') 102 break; 103 p++; 104 if (!strcmp(tag, option)) { 105 *pstr = get_opt_value(buf, buf_size, p); 106 if (**pstr == ',') { 107 (*pstr)++; 108 } 109 return strlen(buf); 110 } else { 111 p = get_opt_value(NULL, 0, p); 112 } 113 if (*p != ',') 114 break; 115 p++; 116 } 117 return 0; 118 } 119 120 int get_param_value(char *buf, int buf_size, 121 const char *tag, const char *str) 122 { 123 return get_next_param_value(buf, buf_size, tag, &str); 124 } 125 126 int check_params(char *buf, int buf_size, 127 const char * const *params, const char *str) 128 { 129 const char *p; 130 int i; 131 132 p = str; 133 while (*p != '\0') { 134 p = get_opt_name(buf, buf_size, p, '='); 135 if (*p != '=') { 136 return -1; 137 } 138 p++; 139 for (i = 0; params[i] != NULL; i++) { 140 if (!strcmp(params[i], buf)) { 141 break; 142 } 143 } 144 if (params[i] == NULL) { 145 return -1; 146 } 147 p = get_opt_value(NULL, 0, p); 148 if (*p != ',') { 149 break; 150 } 151 p++; 152 } 153 return 0; 154 } 155 156 /* 157 * Searches an option list for an option with the given name 158 */ 159 QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list, 160 const char *name) 161 { 162 while (list && list->name) { 163 if (!strcmp(list->name, name)) { 164 return list; 165 } 166 list++; 167 } 168 169 return NULL; 170 } 171 172 static void parse_option_bool(const char *name, const char *value, bool *ret, 173 Error **errp) 174 { 175 if (value != NULL) { 176 if (!strcmp(value, "on")) { 177 *ret = 1; 178 } else if (!strcmp(value, "off")) { 179 *ret = 0; 180 } else { 181 error_set(errp,QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'"); 182 } 183 } else { 184 *ret = 1; 185 } 186 } 187 188 static void parse_option_number(const char *name, const char *value, 189 uint64_t *ret, Error **errp) 190 { 191 char *postfix; 192 uint64_t number; 193 194 if (value != NULL) { 195 number = strtoull(value, &postfix, 0); 196 if (*postfix != '\0') { 197 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number"); 198 return; 199 } 200 *ret = number; 201 } else { 202 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number"); 203 } 204 } 205 206 static void parse_option_size(const char *name, const char *value, 207 uint64_t *ret, Error **errp) 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 /* fall through */ 218 case 'G': 219 sizef *= 1024; 220 /* fall through */ 221 case 'M': 222 sizef *= 1024; 223 /* fall through */ 224 case 'K': 225 case 'k': 226 sizef *= 1024; 227 /* fall through */ 228 case 'b': 229 case '\0': 230 *ret = (uint64_t) sizef; 231 break; 232 default: 233 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size"); 234 error_printf_unless_qmp("You may use k, M, G or T suffixes for " 235 "kilobytes, megabytes, gigabytes and terabytes.\n"); 236 return; 237 } 238 } else { 239 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size"); 240 } 241 } 242 243 /* 244 * Sets the value of a parameter in a given option list. The parsing of the 245 * value depends on the type of option: 246 * 247 * OPT_FLAG (uses value.n): 248 * If no value is given, the flag is set to 1. 249 * Otherwise the value must be "on" (set to 1) or "off" (set to 0) 250 * 251 * OPT_STRING (uses value.s): 252 * value is strdup()ed and assigned as option value 253 * 254 * OPT_SIZE (uses value.n): 255 * The value is converted to an integer. Suffixes for kilobytes etc. are 256 * allowed (powers of 1024). 257 * 258 * Returns 0 on succes, -1 in error cases 259 */ 260 int set_option_parameter(QEMUOptionParameter *list, const char *name, 261 const char *value) 262 { 263 bool flag; 264 Error *local_err = NULL; 265 266 // Find a matching parameter 267 list = get_option_parameter(list, name); 268 if (list == NULL) { 269 fprintf(stderr, "Unknown option '%s'\n", name); 270 return -1; 271 } 272 273 // Process parameter 274 switch (list->type) { 275 case OPT_FLAG: 276 parse_option_bool(name, value, &flag, &local_err); 277 if (!error_is_set(&local_err)) { 278 list->value.n = flag; 279 } 280 break; 281 282 case OPT_STRING: 283 if (value != NULL) { 284 list->value.s = g_strdup(value); 285 } else { 286 fprintf(stderr, "Option '%s' needs a parameter\n", name); 287 return -1; 288 } 289 break; 290 291 case OPT_SIZE: 292 parse_option_size(name, value, &list->value.n, &local_err); 293 break; 294 295 default: 296 fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name); 297 return -1; 298 } 299 300 if (error_is_set(&local_err)) { 301 qerror_report_err(local_err); 302 error_free(local_err); 303 return -1; 304 } 305 306 return 0; 307 } 308 309 /* 310 * Sets the given parameter to an integer instead of a string. 311 * This function cannot be used to set string options. 312 * 313 * Returns 0 on success, -1 in error cases 314 */ 315 int set_option_parameter_int(QEMUOptionParameter *list, const char *name, 316 uint64_t value) 317 { 318 // Find a matching parameter 319 list = get_option_parameter(list, name); 320 if (list == NULL) { 321 fprintf(stderr, "Unknown option '%s'\n", name); 322 return -1; 323 } 324 325 // Process parameter 326 switch (list->type) { 327 case OPT_FLAG: 328 case OPT_NUMBER: 329 case OPT_SIZE: 330 list->value.n = value; 331 break; 332 333 default: 334 return -1; 335 } 336 337 return 0; 338 } 339 340 /* 341 * Frees a option list. If it contains strings, the strings are freed as well. 342 */ 343 void free_option_parameters(QEMUOptionParameter *list) 344 { 345 QEMUOptionParameter *cur = list; 346 347 while (cur && cur->name) { 348 if (cur->type == OPT_STRING) { 349 g_free(cur->value.s); 350 } 351 cur++; 352 } 353 354 g_free(list); 355 } 356 357 /* 358 * Count valid options in list 359 */ 360 static size_t count_option_parameters(QEMUOptionParameter *list) 361 { 362 size_t num_options = 0; 363 364 while (list && list->name) { 365 num_options++; 366 list++; 367 } 368 369 return num_options; 370 } 371 372 /* 373 * Append an option list (list) to an option list (dest). 374 * 375 * If dest is NULL, a new copy of list is created. 376 * 377 * Returns a pointer to the first element of dest (or the newly allocated copy) 378 */ 379 QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, 380 QEMUOptionParameter *list) 381 { 382 size_t num_options, num_dest_options; 383 384 num_options = count_option_parameters(dest); 385 num_dest_options = num_options; 386 387 num_options += count_option_parameters(list); 388 389 dest = g_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter)); 390 dest[num_dest_options].name = NULL; 391 392 while (list && list->name) { 393 if (get_option_parameter(dest, list->name) == NULL) { 394 dest[num_dest_options++] = *list; 395 dest[num_dest_options].name = NULL; 396 } 397 list++; 398 } 399 400 return dest; 401 } 402 403 /* 404 * Parses a parameter string (param) into an option list (dest). 405 * 406 * list is the template option list. If dest is NULL, a new copy of list is 407 * created. If list is NULL, this function fails. 408 * 409 * A parameter string consists of one or more parameters, separated by commas. 410 * Each parameter consists of its name and possibly of a value. In the latter 411 * case, the value is delimited by an = character. To specify a value which 412 * contains commas, double each comma so it won't be recognized as the end of 413 * the parameter. 414 * 415 * For more details of the parsing see above. 416 * 417 * Returns a pointer to the first element of dest (or the newly allocated copy) 418 * or NULL in error cases 419 */ 420 QEMUOptionParameter *parse_option_parameters(const char *param, 421 QEMUOptionParameter *list, QEMUOptionParameter *dest) 422 { 423 QEMUOptionParameter *allocated = NULL; 424 char name[256]; 425 char value[256]; 426 char *param_delim, *value_delim; 427 char next_delim; 428 429 if (list == NULL) { 430 return NULL; 431 } 432 433 if (dest == NULL) { 434 dest = allocated = append_option_parameters(NULL, list); 435 } 436 437 while (*param) { 438 439 // Find parameter name and value in the string 440 param_delim = strchr(param, ','); 441 value_delim = strchr(param, '='); 442 443 if (value_delim && (value_delim < param_delim || !param_delim)) { 444 next_delim = '='; 445 } else { 446 next_delim = ','; 447 value_delim = NULL; 448 } 449 450 param = get_opt_name(name, sizeof(name), param, next_delim); 451 if (value_delim) { 452 param = get_opt_value(value, sizeof(value), param + 1); 453 } 454 if (*param != '\0') { 455 param++; 456 } 457 458 // Set the parameter 459 if (set_option_parameter(dest, name, value_delim ? value : NULL)) { 460 goto fail; 461 } 462 } 463 464 return dest; 465 466 fail: 467 // Only free the list if it was newly allocated 468 free_option_parameters(allocated); 469 return NULL; 470 } 471 472 /* 473 * Prints all options of a list that have a value to stdout 474 */ 475 void print_option_parameters(QEMUOptionParameter *list) 476 { 477 while (list && list->name) { 478 switch (list->type) { 479 case OPT_STRING: 480 if (list->value.s != NULL) { 481 printf("%s='%s' ", list->name, list->value.s); 482 } 483 break; 484 case OPT_FLAG: 485 printf("%s=%s ", list->name, list->value.n ? "on" : "off"); 486 break; 487 case OPT_SIZE: 488 case OPT_NUMBER: 489 printf("%s=%" PRId64 " ", list->name, list->value.n); 490 break; 491 default: 492 printf("%s=(unknown type) ", list->name); 493 break; 494 } 495 list++; 496 } 497 } 498 499 /* 500 * Prints an overview of all available options 501 */ 502 void print_option_help(QEMUOptionParameter *list) 503 { 504 printf("Supported options:\n"); 505 while (list && list->name) { 506 printf("%-16s %s\n", list->name, 507 list->help ? list->help : "No description available"); 508 list++; 509 } 510 } 511 512 /* ------------------------------------------------------------------ */ 513 514 static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) 515 { 516 QemuOpt *opt; 517 518 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 519 if (strcmp(opt->name, name) != 0) 520 continue; 521 return opt; 522 } 523 return NULL; 524 } 525 526 const char *qemu_opt_get(QemuOpts *opts, const char *name) 527 { 528 QemuOpt *opt = qemu_opt_find(opts, name); 529 return opt ? opt->str : NULL; 530 } 531 532 bool qemu_opt_has_help_opt(QemuOpts *opts) 533 { 534 QemuOpt *opt; 535 536 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 537 if (is_help_option(opt->name)) { 538 return true; 539 } 540 } 541 return false; 542 } 543 544 bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval) 545 { 546 QemuOpt *opt = qemu_opt_find(opts, name); 547 548 if (opt == NULL) 549 return defval; 550 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL); 551 return opt->value.boolean; 552 } 553 554 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval) 555 { 556 QemuOpt *opt = qemu_opt_find(opts, name); 557 558 if (opt == NULL) 559 return defval; 560 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER); 561 return opt->value.uint; 562 } 563 564 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval) 565 { 566 QemuOpt *opt = qemu_opt_find(opts, name); 567 568 if (opt == NULL) 569 return defval; 570 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE); 571 return opt->value.uint; 572 } 573 574 static void qemu_opt_parse(QemuOpt *opt, Error **errp) 575 { 576 if (opt->desc == NULL) 577 return; 578 579 switch (opt->desc->type) { 580 case QEMU_OPT_STRING: 581 /* nothing */ 582 return; 583 case QEMU_OPT_BOOL: 584 parse_option_bool(opt->name, opt->str, &opt->value.boolean, errp); 585 break; 586 case QEMU_OPT_NUMBER: 587 parse_option_number(opt->name, opt->str, &opt->value.uint, errp); 588 break; 589 case QEMU_OPT_SIZE: 590 parse_option_size(opt->name, opt->str, &opt->value.uint, errp); 591 break; 592 default: 593 abort(); 594 } 595 } 596 597 static void qemu_opt_del(QemuOpt *opt) 598 { 599 QTAILQ_REMOVE(&opt->opts->head, opt, next); 600 g_free((/* !const */ char*)opt->name); 601 g_free((/* !const */ char*)opt->str); 602 g_free(opt); 603 } 604 605 static bool opts_accepts_any(const QemuOpts *opts) 606 { 607 return opts->list->desc[0].name == NULL; 608 } 609 610 static const QemuOptDesc *find_desc_by_name(const QemuOptDesc *desc, 611 const char *name) 612 { 613 int i; 614 615 for (i = 0; desc[i].name != NULL; i++) { 616 if (strcmp(desc[i].name, name) == 0) { 617 return &desc[i]; 618 } 619 } 620 621 return NULL; 622 } 623 624 static void opt_set(QemuOpts *opts, const char *name, const char *value, 625 bool prepend, Error **errp) 626 { 627 QemuOpt *opt; 628 const QemuOptDesc *desc; 629 Error *local_err = NULL; 630 631 desc = find_desc_by_name(opts->list->desc, name); 632 if (!desc && !opts_accepts_any(opts)) { 633 error_set(errp, QERR_INVALID_PARAMETER, name); 634 return; 635 } 636 637 opt = g_malloc0(sizeof(*opt)); 638 opt->name = g_strdup(name); 639 opt->opts = opts; 640 if (prepend) { 641 QTAILQ_INSERT_HEAD(&opts->head, opt, next); 642 } else { 643 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 644 } 645 opt->desc = desc; 646 if (value) { 647 opt->str = g_strdup(value); 648 } 649 qemu_opt_parse(opt, &local_err); 650 if (error_is_set(&local_err)) { 651 error_propagate(errp, local_err); 652 qemu_opt_del(opt); 653 } 654 } 655 656 int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) 657 { 658 Error *local_err = NULL; 659 660 opt_set(opts, name, value, false, &local_err); 661 if (error_is_set(&local_err)) { 662 qerror_report_err(local_err); 663 error_free(local_err); 664 return -1; 665 } 666 667 return 0; 668 } 669 670 void qemu_opt_set_err(QemuOpts *opts, const char *name, const char *value, 671 Error **errp) 672 { 673 opt_set(opts, name, value, false, errp); 674 } 675 676 int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val) 677 { 678 QemuOpt *opt; 679 const QemuOptDesc *desc = opts->list->desc; 680 681 opt = g_malloc0(sizeof(*opt)); 682 opt->desc = find_desc_by_name(desc, name); 683 if (!opt->desc && !opts_accepts_any(opts)) { 684 qerror_report(QERR_INVALID_PARAMETER, name); 685 g_free(opt); 686 return -1; 687 } 688 689 opt->name = g_strdup(name); 690 opt->opts = opts; 691 opt->value.boolean = !!val; 692 opt->str = g_strdup(val ? "on" : "off"); 693 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 694 695 return 0; 696 } 697 698 int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val) 699 { 700 QemuOpt *opt; 701 const QemuOptDesc *desc = opts->list->desc; 702 703 opt = g_malloc0(sizeof(*opt)); 704 opt->desc = find_desc_by_name(desc, name); 705 if (!opt->desc && !opts_accepts_any(opts)) { 706 qerror_report(QERR_INVALID_PARAMETER, name); 707 g_free(opt); 708 return -1; 709 } 710 711 opt->name = g_strdup(name); 712 opt->opts = opts; 713 opt->value.uint = val; 714 opt->str = g_strdup_printf("%" PRId64, val); 715 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 716 717 return 0; 718 } 719 720 int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, 721 int abort_on_failure) 722 { 723 QemuOpt *opt; 724 int rc = 0; 725 726 QTAILQ_FOREACH(opt, &opts->head, next) { 727 rc = func(opt->name, opt->str, opaque); 728 if (abort_on_failure && rc != 0) 729 break; 730 } 731 return rc; 732 } 733 734 QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id) 735 { 736 QemuOpts *opts; 737 738 QTAILQ_FOREACH(opts, &list->head, next) { 739 if (!opts->id) { 740 if (!id) { 741 return opts; 742 } 743 continue; 744 } 745 if (strcmp(opts->id, id) != 0) { 746 continue; 747 } 748 return opts; 749 } 750 return NULL; 751 } 752 753 static int id_wellformed(const char *id) 754 { 755 int i; 756 757 if (!qemu_isalpha(id[0])) { 758 return 0; 759 } 760 for (i = 1; id[i]; i++) { 761 if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) { 762 return 0; 763 } 764 } 765 return 1; 766 } 767 768 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, 769 int fail_if_exists, Error **errp) 770 { 771 QemuOpts *opts = NULL; 772 773 if (id) { 774 if (!id_wellformed(id)) { 775 error_set(errp,QERR_INVALID_PARAMETER_VALUE, "id", "an identifier"); 776 error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n"); 777 return NULL; 778 } 779 opts = qemu_opts_find(list, id); 780 if (opts != NULL) { 781 if (fail_if_exists && !list->merge_lists) { 782 error_set(errp, QERR_DUPLICATE_ID, id, list->name); 783 return NULL; 784 } else { 785 return opts; 786 } 787 } 788 } else if (list->merge_lists) { 789 opts = qemu_opts_find(list, NULL); 790 if (opts) { 791 return opts; 792 } 793 } 794 opts = g_malloc0(sizeof(*opts)); 795 if (id) { 796 opts->id = g_strdup(id); 797 } 798 opts->list = list; 799 loc_save(&opts->loc); 800 QTAILQ_INIT(&opts->head); 801 QTAILQ_INSERT_TAIL(&list->head, opts, next); 802 return opts; 803 } 804 805 QemuOpts *qemu_opts_create_nofail(QemuOptsList *list) 806 { 807 QemuOpts *opts; 808 Error *errp = NULL; 809 opts = qemu_opts_create(list, NULL, 0, &errp); 810 assert_no_error(errp); 811 return opts; 812 } 813 814 void qemu_opts_reset(QemuOptsList *list) 815 { 816 QemuOpts *opts, *next_opts; 817 818 QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) { 819 qemu_opts_del(opts); 820 } 821 } 822 823 void qemu_opts_loc_restore(QemuOpts *opts) 824 { 825 loc_restore(&opts->loc); 826 } 827 828 int qemu_opts_set(QemuOptsList *list, const char *id, 829 const char *name, const char *value) 830 { 831 QemuOpts *opts; 832 Error *local_err = NULL; 833 834 opts = qemu_opts_create(list, id, 1, &local_err); 835 if (error_is_set(&local_err)) { 836 qerror_report_err(local_err); 837 error_free(local_err); 838 return -1; 839 } 840 return qemu_opt_set(opts, name, value); 841 } 842 843 const char *qemu_opts_id(QemuOpts *opts) 844 { 845 return opts->id; 846 } 847 848 void qemu_opts_del(QemuOpts *opts) 849 { 850 QemuOpt *opt; 851 852 for (;;) { 853 opt = QTAILQ_FIRST(&opts->head); 854 if (opt == NULL) 855 break; 856 qemu_opt_del(opt); 857 } 858 QTAILQ_REMOVE(&opts->list->head, opts, next); 859 g_free(opts->id); 860 g_free(opts); 861 } 862 863 int qemu_opts_print(QemuOpts *opts, void *dummy) 864 { 865 QemuOpt *opt; 866 867 fprintf(stderr, "%s: %s:", opts->list->name, 868 opts->id ? opts->id : "<noid>"); 869 QTAILQ_FOREACH(opt, &opts->head, next) { 870 fprintf(stderr, " %s=\"%s\"", opt->name, opt->str); 871 } 872 fprintf(stderr, "\n"); 873 return 0; 874 } 875 876 static int opts_do_parse(QemuOpts *opts, const char *params, 877 const char *firstname, bool prepend) 878 { 879 char option[128], value[1024]; 880 const char *p,*pe,*pc; 881 Error *local_err = NULL; 882 883 for (p = params; *p != '\0'; p++) { 884 pe = strchr(p, '='); 885 pc = strchr(p, ','); 886 if (!pe || (pc && pc < pe)) { 887 /* found "foo,more" */ 888 if (p == params && firstname) { 889 /* implicitly named first option */ 890 pstrcpy(option, sizeof(option), firstname); 891 p = get_opt_value(value, sizeof(value), p); 892 } else { 893 /* option without value, probably a flag */ 894 p = get_opt_name(option, sizeof(option), p, ','); 895 if (strncmp(option, "no", 2) == 0) { 896 memmove(option, option+2, strlen(option+2)+1); 897 pstrcpy(value, sizeof(value), "off"); 898 } else { 899 pstrcpy(value, sizeof(value), "on"); 900 } 901 } 902 } else { 903 /* found "foo=bar,more" */ 904 p = get_opt_name(option, sizeof(option), p, '='); 905 if (*p != '=') { 906 break; 907 } 908 p++; 909 p = get_opt_value(value, sizeof(value), p); 910 } 911 if (strcmp(option, "id") != 0) { 912 /* store and parse */ 913 opt_set(opts, option, value, prepend, &local_err); 914 if (error_is_set(&local_err)) { 915 qerror_report_err(local_err); 916 error_free(local_err); 917 return -1; 918 } 919 } 920 if (*p != ',') { 921 break; 922 } 923 } 924 return 0; 925 } 926 927 int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname) 928 { 929 return opts_do_parse(opts, params, firstname, false); 930 } 931 932 static QemuOpts *opts_parse(QemuOptsList *list, const char *params, 933 int permit_abbrev, bool defaults) 934 { 935 const char *firstname; 936 char value[1024], *id = NULL; 937 const char *p; 938 QemuOpts *opts; 939 Error *local_err = NULL; 940 941 assert(!permit_abbrev || list->implied_opt_name); 942 firstname = permit_abbrev ? list->implied_opt_name : NULL; 943 944 if (strncmp(params, "id=", 3) == 0) { 945 get_opt_value(value, sizeof(value), params+3); 946 id = value; 947 } else if ((p = strstr(params, ",id=")) != NULL) { 948 get_opt_value(value, sizeof(value), p+4); 949 id = value; 950 } 951 if (defaults) { 952 if (!id && !QTAILQ_EMPTY(&list->head)) { 953 opts = qemu_opts_find(list, NULL); 954 } else { 955 opts = qemu_opts_create(list, id, 0, &local_err); 956 } 957 } else { 958 opts = qemu_opts_create(list, id, 1, &local_err); 959 } 960 if (opts == NULL) { 961 if (error_is_set(&local_err)) { 962 qerror_report_err(local_err); 963 error_free(local_err); 964 } 965 return NULL; 966 } 967 968 if (opts_do_parse(opts, params, firstname, defaults) != 0) { 969 qemu_opts_del(opts); 970 return NULL; 971 } 972 973 return opts; 974 } 975 976 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, 977 int permit_abbrev) 978 { 979 return opts_parse(list, params, permit_abbrev, false); 980 } 981 982 void qemu_opts_set_defaults(QemuOptsList *list, const char *params, 983 int permit_abbrev) 984 { 985 QemuOpts *opts; 986 987 opts = opts_parse(list, params, permit_abbrev, true); 988 assert(opts); 989 } 990 991 typedef struct OptsFromQDictState { 992 QemuOpts *opts; 993 Error **errp; 994 } OptsFromQDictState; 995 996 static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque) 997 { 998 OptsFromQDictState *state = opaque; 999 char buf[32]; 1000 const char *value; 1001 int n; 1002 1003 if (!strcmp(key, "id") || error_is_set(state->errp)) { 1004 return; 1005 } 1006 1007 switch (qobject_type(obj)) { 1008 case QTYPE_QSTRING: 1009 value = qstring_get_str(qobject_to_qstring(obj)); 1010 break; 1011 case QTYPE_QINT: 1012 n = snprintf(buf, sizeof(buf), "%" PRId64, 1013 qint_get_int(qobject_to_qint(obj))); 1014 assert(n < sizeof(buf)); 1015 value = buf; 1016 break; 1017 case QTYPE_QFLOAT: 1018 n = snprintf(buf, sizeof(buf), "%.17g", 1019 qfloat_get_double(qobject_to_qfloat(obj))); 1020 assert(n < sizeof(buf)); 1021 value = buf; 1022 break; 1023 case QTYPE_QBOOL: 1024 pstrcpy(buf, sizeof(buf), 1025 qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off"); 1026 value = buf; 1027 break; 1028 default: 1029 return; 1030 } 1031 1032 qemu_opt_set_err(state->opts, key, value, state->errp); 1033 } 1034 1035 /* 1036 * Create QemuOpts from a QDict. 1037 * Use value of key "id" as ID if it exists and is a QString. 1038 * Only QStrings, QInts, QFloats and QBools are copied. Entries with 1039 * other types are silently ignored. 1040 */ 1041 QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict, 1042 Error **errp) 1043 { 1044 OptsFromQDictState state; 1045 Error *local_err = NULL; 1046 QemuOpts *opts; 1047 1048 opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1, 1049 &local_err); 1050 if (error_is_set(&local_err)) { 1051 error_propagate(errp, local_err); 1052 return NULL; 1053 } 1054 1055 assert(opts != NULL); 1056 1057 state.errp = &local_err; 1058 state.opts = opts; 1059 qdict_iter(qdict, qemu_opts_from_qdict_1, &state); 1060 if (error_is_set(&local_err)) { 1061 error_propagate(errp, local_err); 1062 qemu_opts_del(opts); 1063 return NULL; 1064 } 1065 1066 return opts; 1067 } 1068 1069 /* 1070 * Convert from QemuOpts to QDict. 1071 * The QDict values are of type QString. 1072 * TODO We'll want to use types appropriate for opt->desc->type, but 1073 * this is enough for now. 1074 */ 1075 QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict) 1076 { 1077 QemuOpt *opt; 1078 QObject *val; 1079 1080 if (!qdict) { 1081 qdict = qdict_new(); 1082 } 1083 if (opts->id) { 1084 qdict_put(qdict, "id", qstring_from_str(opts->id)); 1085 } 1086 QTAILQ_FOREACH(opt, &opts->head, next) { 1087 val = QOBJECT(qstring_from_str(opt->str)); 1088 qdict_put_obj(qdict, opt->name, val); 1089 } 1090 return qdict; 1091 } 1092 1093 /* Validate parsed opts against descriptions where no 1094 * descriptions were provided in the QemuOptsList. 1095 */ 1096 void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp) 1097 { 1098 QemuOpt *opt; 1099 Error *local_err = NULL; 1100 1101 assert(opts_accepts_any(opts)); 1102 1103 QTAILQ_FOREACH(opt, &opts->head, next) { 1104 opt->desc = find_desc_by_name(desc, opt->name); 1105 if (!opt->desc) { 1106 error_set(errp, QERR_INVALID_PARAMETER, opt->name); 1107 return; 1108 } 1109 1110 qemu_opt_parse(opt, &local_err); 1111 if (error_is_set(&local_err)) { 1112 error_propagate(errp, local_err); 1113 return; 1114 } 1115 } 1116 } 1117 1118 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, 1119 int abort_on_failure) 1120 { 1121 Location loc; 1122 QemuOpts *opts; 1123 int rc = 0; 1124 1125 loc_push_none(&loc); 1126 QTAILQ_FOREACH(opts, &list->head, next) { 1127 loc_restore(&opts->loc); 1128 rc |= func(opts, opaque); 1129 if (abort_on_failure && rc != 0) 1130 break; 1131 } 1132 loc_pop(&loc); 1133 return rc; 1134 } 1135