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 #if 0 /* conversion from qerror_report() to error_set() broke this: */ 235 error_printf_unless_qmp("You may use k, M, G or T suffixes for " 236 "kilobytes, megabytes, gigabytes and terabytes.\n"); 237 #endif 238 return; 239 } 240 } else { 241 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size"); 242 } 243 } 244 245 /* 246 * Sets the value of a parameter in a given option list. The parsing of the 247 * value depends on the type of option: 248 * 249 * OPT_FLAG (uses value.n): 250 * If no value is given, the flag is set to 1. 251 * Otherwise the value must be "on" (set to 1) or "off" (set to 0) 252 * 253 * OPT_STRING (uses value.s): 254 * value is strdup()ed and assigned as option value 255 * 256 * OPT_SIZE (uses value.n): 257 * The value is converted to an integer. Suffixes for kilobytes etc. are 258 * allowed (powers of 1024). 259 * 260 * Returns 0 on succes, -1 in error cases 261 */ 262 int set_option_parameter(QEMUOptionParameter *list, const char *name, 263 const char *value) 264 { 265 bool flag; 266 Error *local_err = NULL; 267 268 // Find a matching parameter 269 list = get_option_parameter(list, name); 270 if (list == NULL) { 271 fprintf(stderr, "Unknown option '%s'\n", name); 272 return -1; 273 } 274 275 // Process parameter 276 switch (list->type) { 277 case OPT_FLAG: 278 parse_option_bool(name, value, &flag, &local_err); 279 if (!error_is_set(&local_err)) { 280 list->value.n = flag; 281 } 282 break; 283 284 case OPT_STRING: 285 if (value != NULL) { 286 list->value.s = g_strdup(value); 287 } else { 288 fprintf(stderr, "Option '%s' needs a parameter\n", name); 289 return -1; 290 } 291 break; 292 293 case OPT_SIZE: 294 parse_option_size(name, value, &list->value.n, &local_err); 295 break; 296 297 default: 298 fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name); 299 return -1; 300 } 301 302 if (error_is_set(&local_err)) { 303 qerror_report_err(local_err); 304 error_free(local_err); 305 return -1; 306 } 307 308 return 0; 309 } 310 311 /* 312 * Sets the given parameter to an integer instead of a string. 313 * This function cannot be used to set string options. 314 * 315 * Returns 0 on success, -1 in error cases 316 */ 317 int set_option_parameter_int(QEMUOptionParameter *list, const char *name, 318 uint64_t value) 319 { 320 // Find a matching parameter 321 list = get_option_parameter(list, name); 322 if (list == NULL) { 323 fprintf(stderr, "Unknown option '%s'\n", name); 324 return -1; 325 } 326 327 // Process parameter 328 switch (list->type) { 329 case OPT_FLAG: 330 case OPT_NUMBER: 331 case OPT_SIZE: 332 list->value.n = value; 333 break; 334 335 default: 336 return -1; 337 } 338 339 return 0; 340 } 341 342 /* 343 * Frees a option list. If it contains strings, the strings are freed as well. 344 */ 345 void free_option_parameters(QEMUOptionParameter *list) 346 { 347 QEMUOptionParameter *cur = list; 348 349 while (cur && cur->name) { 350 if (cur->type == OPT_STRING) { 351 g_free(cur->value.s); 352 } 353 cur++; 354 } 355 356 g_free(list); 357 } 358 359 /* 360 * Count valid options in list 361 */ 362 static size_t count_option_parameters(QEMUOptionParameter *list) 363 { 364 size_t num_options = 0; 365 366 while (list && list->name) { 367 num_options++; 368 list++; 369 } 370 371 return num_options; 372 } 373 374 /* 375 * Append an option list (list) to an option list (dest). 376 * 377 * If dest is NULL, a new copy of list is created. 378 * 379 * Returns a pointer to the first element of dest (or the newly allocated copy) 380 */ 381 QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, 382 QEMUOptionParameter *list) 383 { 384 size_t num_options, num_dest_options; 385 386 num_options = count_option_parameters(dest); 387 num_dest_options = num_options; 388 389 num_options += count_option_parameters(list); 390 391 dest = g_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter)); 392 dest[num_dest_options].name = NULL; 393 394 while (list && list->name) { 395 if (get_option_parameter(dest, list->name) == NULL) { 396 dest[num_dest_options++] = *list; 397 dest[num_dest_options].name = NULL; 398 } 399 list++; 400 } 401 402 return dest; 403 } 404 405 /* 406 * Parses a parameter string (param) into an option list (dest). 407 * 408 * list is the template option list. If dest is NULL, a new copy of list is 409 * created. If list is NULL, this function fails. 410 * 411 * A parameter string consists of one or more parameters, separated by commas. 412 * Each parameter consists of its name and possibly of a value. In the latter 413 * case, the value is delimited by an = character. To specify a value which 414 * contains commas, double each comma so it won't be recognized as the end of 415 * the parameter. 416 * 417 * For more details of the parsing see above. 418 * 419 * Returns a pointer to the first element of dest (or the newly allocated copy) 420 * or NULL in error cases 421 */ 422 QEMUOptionParameter *parse_option_parameters(const char *param, 423 QEMUOptionParameter *list, QEMUOptionParameter *dest) 424 { 425 QEMUOptionParameter *allocated = NULL; 426 char name[256]; 427 char value[256]; 428 char *param_delim, *value_delim; 429 char next_delim; 430 431 if (list == NULL) { 432 return NULL; 433 } 434 435 if (dest == NULL) { 436 dest = allocated = append_option_parameters(NULL, list); 437 } 438 439 while (*param) { 440 441 // Find parameter name and value in the string 442 param_delim = strchr(param, ','); 443 value_delim = strchr(param, '='); 444 445 if (value_delim && (value_delim < param_delim || !param_delim)) { 446 next_delim = '='; 447 } else { 448 next_delim = ','; 449 value_delim = NULL; 450 } 451 452 param = get_opt_name(name, sizeof(name), param, next_delim); 453 if (value_delim) { 454 param = get_opt_value(value, sizeof(value), param + 1); 455 } 456 if (*param != '\0') { 457 param++; 458 } 459 460 // Set the parameter 461 if (set_option_parameter(dest, name, value_delim ? value : NULL)) { 462 goto fail; 463 } 464 } 465 466 return dest; 467 468 fail: 469 // Only free the list if it was newly allocated 470 free_option_parameters(allocated); 471 return NULL; 472 } 473 474 /* 475 * Prints all options of a list that have a value to stdout 476 */ 477 void print_option_parameters(QEMUOptionParameter *list) 478 { 479 while (list && list->name) { 480 switch (list->type) { 481 case OPT_STRING: 482 if (list->value.s != NULL) { 483 printf("%s='%s' ", list->name, list->value.s); 484 } 485 break; 486 case OPT_FLAG: 487 printf("%s=%s ", list->name, list->value.n ? "on" : "off"); 488 break; 489 case OPT_SIZE: 490 case OPT_NUMBER: 491 printf("%s=%" PRId64 " ", list->name, list->value.n); 492 break; 493 default: 494 printf("%s=(unknown type) ", list->name); 495 break; 496 } 497 list++; 498 } 499 } 500 501 /* 502 * Prints an overview of all available options 503 */ 504 void print_option_help(QEMUOptionParameter *list) 505 { 506 printf("Supported options:\n"); 507 while (list && list->name) { 508 printf("%-16s %s\n", list->name, 509 list->help ? list->help : "No description available"); 510 list++; 511 } 512 } 513 514 /* ------------------------------------------------------------------ */ 515 516 static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) 517 { 518 QemuOpt *opt; 519 520 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 521 if (strcmp(opt->name, name) != 0) 522 continue; 523 return opt; 524 } 525 return NULL; 526 } 527 528 const char *qemu_opt_get(QemuOpts *opts, const char *name) 529 { 530 QemuOpt *opt = qemu_opt_find(opts, name); 531 return opt ? opt->str : NULL; 532 } 533 534 bool qemu_opt_has_help_opt(QemuOpts *opts) 535 { 536 QemuOpt *opt; 537 538 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 539 if (is_help_option(opt->name)) { 540 return true; 541 } 542 } 543 return false; 544 } 545 546 bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval) 547 { 548 QemuOpt *opt = qemu_opt_find(opts, name); 549 550 if (opt == NULL) 551 return defval; 552 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL); 553 return opt->value.boolean; 554 } 555 556 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval) 557 { 558 QemuOpt *opt = qemu_opt_find(opts, name); 559 560 if (opt == NULL) 561 return defval; 562 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER); 563 return opt->value.uint; 564 } 565 566 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval) 567 { 568 QemuOpt *opt = qemu_opt_find(opts, name); 569 570 if (opt == NULL) 571 return defval; 572 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE); 573 return opt->value.uint; 574 } 575 576 static void qemu_opt_parse(QemuOpt *opt, Error **errp) 577 { 578 if (opt->desc == NULL) 579 return; 580 581 switch (opt->desc->type) { 582 case QEMU_OPT_STRING: 583 /* nothing */ 584 return; 585 case QEMU_OPT_BOOL: 586 parse_option_bool(opt->name, opt->str, &opt->value.boolean, errp); 587 break; 588 case QEMU_OPT_NUMBER: 589 parse_option_number(opt->name, opt->str, &opt->value.uint, errp); 590 break; 591 case QEMU_OPT_SIZE: 592 parse_option_size(opt->name, opt->str, &opt->value.uint, errp); 593 break; 594 default: 595 abort(); 596 } 597 } 598 599 static void qemu_opt_del(QemuOpt *opt) 600 { 601 QTAILQ_REMOVE(&opt->opts->head, opt, next); 602 g_free((/* !const */ char*)opt->name); 603 g_free((/* !const */ char*)opt->str); 604 g_free(opt); 605 } 606 607 static bool opts_accepts_any(const QemuOpts *opts) 608 { 609 return opts->list->desc[0].name == NULL; 610 } 611 612 static const QemuOptDesc *find_desc_by_name(const QemuOptDesc *desc, 613 const char *name) 614 { 615 int i; 616 617 for (i = 0; desc[i].name != NULL; i++) { 618 if (strcmp(desc[i].name, name) == 0) { 619 return &desc[i]; 620 } 621 } 622 623 return NULL; 624 } 625 626 static void opt_set(QemuOpts *opts, const char *name, const char *value, 627 bool prepend, Error **errp) 628 { 629 QemuOpt *opt; 630 const QemuOptDesc *desc; 631 Error *local_err = NULL; 632 633 desc = find_desc_by_name(opts->list->desc, name); 634 if (!desc && !opts_accepts_any(opts)) { 635 error_set(errp, QERR_INVALID_PARAMETER, name); 636 return; 637 } 638 639 opt = g_malloc0(sizeof(*opt)); 640 opt->name = g_strdup(name); 641 opt->opts = opts; 642 if (prepend) { 643 QTAILQ_INSERT_HEAD(&opts->head, opt, next); 644 } else { 645 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 646 } 647 opt->desc = desc; 648 opt->str = g_strdup(value); 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 #if 0 /* conversion from qerror_report() to error_set() broke this: */ 777 error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n"); 778 #endif 779 return NULL; 780 } 781 opts = qemu_opts_find(list, id); 782 if (opts != NULL) { 783 if (fail_if_exists && !list->merge_lists) { 784 error_set(errp, QERR_DUPLICATE_ID, id, list->name); 785 return NULL; 786 } else { 787 return opts; 788 } 789 } 790 } else if (list->merge_lists) { 791 opts = qemu_opts_find(list, NULL); 792 if (opts) { 793 return opts; 794 } 795 } 796 opts = g_malloc0(sizeof(*opts)); 797 opts->id = g_strdup(id); 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