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 static void parse_option_bool(const char *name, const char *value, bool *ret, 127 Error **errp) 128 { 129 if (value != NULL) { 130 if (!strcmp(value, "on")) { 131 *ret = 1; 132 } else if (!strcmp(value, "off")) { 133 *ret = 0; 134 } else { 135 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 136 name, "'on' or 'off'"); 137 } 138 } else { 139 *ret = 1; 140 } 141 } 142 143 static void parse_option_number(const char *name, const char *value, 144 uint64_t *ret, Error **errp) 145 { 146 char *postfix; 147 uint64_t number; 148 149 if (value != NULL) { 150 number = strtoull(value, &postfix, 0); 151 if (*postfix != '\0') { 152 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number"); 153 return; 154 } 155 *ret = number; 156 } else { 157 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number"); 158 } 159 } 160 161 static const QemuOptDesc *find_desc_by_name(const QemuOptDesc *desc, 162 const char *name) 163 { 164 int i; 165 166 for (i = 0; desc[i].name != NULL; i++) { 167 if (strcmp(desc[i].name, name) == 0) { 168 return &desc[i]; 169 } 170 } 171 172 return NULL; 173 } 174 175 void parse_option_size(const char *name, const char *value, 176 uint64_t *ret, Error **errp) 177 { 178 char *postfix; 179 double sizef; 180 181 if (value != NULL) { 182 sizef = strtod(value, &postfix); 183 if (sizef < 0 || sizef > UINT64_MAX) { 184 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, 185 "a non-negative number below 2^64"); 186 return; 187 } 188 switch (*postfix) { 189 case 'T': 190 sizef *= 1024; 191 /* fall through */ 192 case 'G': 193 sizef *= 1024; 194 /* fall through */ 195 case 'M': 196 sizef *= 1024; 197 /* fall through */ 198 case 'K': 199 case 'k': 200 sizef *= 1024; 201 /* fall through */ 202 case 'b': 203 case '\0': 204 *ret = (uint64_t) sizef; 205 break; 206 default: 207 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size"); 208 error_append_hint(errp, "You may use k, M, G or T suffixes for " 209 "kilobytes, megabytes, gigabytes and terabytes.\n"); 210 return; 211 } 212 } else { 213 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size"); 214 } 215 } 216 217 bool has_help_option(const char *param) 218 { 219 size_t buflen = strlen(param) + 1; 220 char *buf = g_malloc(buflen); 221 const char *p = param; 222 bool result = false; 223 224 while (*p) { 225 p = get_opt_value(buf, buflen, p); 226 if (*p) { 227 p++; 228 } 229 230 if (is_help_option(buf)) { 231 result = true; 232 goto out; 233 } 234 } 235 236 out: 237 g_free(buf); 238 return result; 239 } 240 241 bool is_valid_option_list(const char *param) 242 { 243 size_t buflen = strlen(param) + 1; 244 char *buf = g_malloc(buflen); 245 const char *p = param; 246 bool result = true; 247 248 while (*p) { 249 p = get_opt_value(buf, buflen, p); 250 if (*p && !*++p) { 251 result = false; 252 goto out; 253 } 254 255 if (!*buf || *buf == ',') { 256 result = false; 257 goto out; 258 } 259 } 260 261 out: 262 g_free(buf); 263 return result; 264 } 265 266 void qemu_opts_print_help(QemuOptsList *list) 267 { 268 QemuOptDesc *desc; 269 270 assert(list); 271 desc = list->desc; 272 printf("Supported options:\n"); 273 while (desc && desc->name) { 274 printf("%-16s %s\n", desc->name, 275 desc->help ? desc->help : "No description available"); 276 desc++; 277 } 278 } 279 /* ------------------------------------------------------------------ */ 280 281 QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) 282 { 283 QemuOpt *opt; 284 285 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 286 if (strcmp(opt->name, name) != 0) 287 continue; 288 return opt; 289 } 290 return NULL; 291 } 292 293 static void qemu_opt_del(QemuOpt *opt) 294 { 295 QTAILQ_REMOVE(&opt->opts->head, opt, next); 296 g_free(opt->name); 297 g_free(opt->str); 298 g_free(opt); 299 } 300 301 /* qemu_opt_set allows many settings for the same option. 302 * This function deletes all settings for an option. 303 */ 304 static void qemu_opt_del_all(QemuOpts *opts, const char *name) 305 { 306 QemuOpt *opt, *next_opt; 307 308 QTAILQ_FOREACH_SAFE(opt, &opts->head, next, next_opt) { 309 if (!strcmp(opt->name, name)) { 310 qemu_opt_del(opt); 311 } 312 } 313 } 314 315 const char *qemu_opt_get(QemuOpts *opts, const char *name) 316 { 317 QemuOpt *opt; 318 319 if (opts == NULL) { 320 return NULL; 321 } 322 323 opt = qemu_opt_find(opts, name); 324 if (!opt) { 325 const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name); 326 if (desc && desc->def_value_str) { 327 return desc->def_value_str; 328 } 329 } 330 return opt ? opt->str : NULL; 331 } 332 333 /* Get a known option (or its default) and remove it from the list 334 * all in one action. Return a malloced string of the option value. 335 * Result must be freed by caller with g_free(). 336 */ 337 char *qemu_opt_get_del(QemuOpts *opts, const char *name) 338 { 339 QemuOpt *opt; 340 const QemuOptDesc *desc; 341 char *str = NULL; 342 343 if (opts == NULL) { 344 return NULL; 345 } 346 347 opt = qemu_opt_find(opts, name); 348 if (!opt) { 349 desc = find_desc_by_name(opts->list->desc, name); 350 if (desc && desc->def_value_str) { 351 str = g_strdup(desc->def_value_str); 352 } 353 return str; 354 } 355 str = opt->str; 356 opt->str = NULL; 357 qemu_opt_del_all(opts, name); 358 return str; 359 } 360 361 bool qemu_opt_has_help_opt(QemuOpts *opts) 362 { 363 QemuOpt *opt; 364 365 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { 366 if (is_help_option(opt->name)) { 367 return true; 368 } 369 } 370 return false; 371 } 372 373 static bool qemu_opt_get_bool_helper(QemuOpts *opts, const char *name, 374 bool defval, bool del) 375 { 376 QemuOpt *opt; 377 bool ret = defval; 378 379 if (opts == NULL) { 380 return ret; 381 } 382 383 opt = qemu_opt_find(opts, name); 384 if (opt == NULL) { 385 const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name); 386 if (desc && desc->def_value_str) { 387 parse_option_bool(name, desc->def_value_str, &ret, &error_abort); 388 } 389 return ret; 390 } 391 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL); 392 ret = opt->value.boolean; 393 if (del) { 394 qemu_opt_del_all(opts, name); 395 } 396 return ret; 397 } 398 399 bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval) 400 { 401 return qemu_opt_get_bool_helper(opts, name, defval, false); 402 } 403 404 bool qemu_opt_get_bool_del(QemuOpts *opts, const char *name, bool defval) 405 { 406 return qemu_opt_get_bool_helper(opts, name, defval, true); 407 } 408 409 static uint64_t qemu_opt_get_number_helper(QemuOpts *opts, const char *name, 410 uint64_t defval, bool del) 411 { 412 QemuOpt *opt; 413 uint64_t ret = defval; 414 415 if (opts == NULL) { 416 return ret; 417 } 418 419 opt = qemu_opt_find(opts, name); 420 if (opt == NULL) { 421 const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name); 422 if (desc && desc->def_value_str) { 423 parse_option_number(name, desc->def_value_str, &ret, &error_abort); 424 } 425 return ret; 426 } 427 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER); 428 ret = opt->value.uint; 429 if (del) { 430 qemu_opt_del_all(opts, name); 431 } 432 return ret; 433 } 434 435 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval) 436 { 437 return qemu_opt_get_number_helper(opts, name, defval, false); 438 } 439 440 uint64_t qemu_opt_get_number_del(QemuOpts *opts, const char *name, 441 uint64_t defval) 442 { 443 return qemu_opt_get_number_helper(opts, name, defval, true); 444 } 445 446 static uint64_t qemu_opt_get_size_helper(QemuOpts *opts, const char *name, 447 uint64_t defval, bool del) 448 { 449 QemuOpt *opt; 450 uint64_t ret = defval; 451 452 if (opts == NULL) { 453 return ret; 454 } 455 456 opt = qemu_opt_find(opts, name); 457 if (opt == NULL) { 458 const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name); 459 if (desc && desc->def_value_str) { 460 parse_option_size(name, desc->def_value_str, &ret, &error_abort); 461 } 462 return ret; 463 } 464 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE); 465 ret = opt->value.uint; 466 if (del) { 467 qemu_opt_del_all(opts, name); 468 } 469 return ret; 470 } 471 472 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval) 473 { 474 return qemu_opt_get_size_helper(opts, name, defval, false); 475 } 476 477 uint64_t qemu_opt_get_size_del(QemuOpts *opts, const char *name, 478 uint64_t defval) 479 { 480 return qemu_opt_get_size_helper(opts, name, defval, true); 481 } 482 483 static void qemu_opt_parse(QemuOpt *opt, Error **errp) 484 { 485 if (opt->desc == NULL) 486 return; 487 488 switch (opt->desc->type) { 489 case QEMU_OPT_STRING: 490 /* nothing */ 491 return; 492 case QEMU_OPT_BOOL: 493 parse_option_bool(opt->name, opt->str, &opt->value.boolean, errp); 494 break; 495 case QEMU_OPT_NUMBER: 496 parse_option_number(opt->name, opt->str, &opt->value.uint, errp); 497 break; 498 case QEMU_OPT_SIZE: 499 parse_option_size(opt->name, opt->str, &opt->value.uint, errp); 500 break; 501 default: 502 abort(); 503 } 504 } 505 506 static bool opts_accepts_any(const QemuOpts *opts) 507 { 508 return opts->list->desc[0].name == NULL; 509 } 510 511 int qemu_opt_unset(QemuOpts *opts, const char *name) 512 { 513 QemuOpt *opt = qemu_opt_find(opts, name); 514 515 assert(opts_accepts_any(opts)); 516 517 if (opt == NULL) { 518 return -1; 519 } else { 520 qemu_opt_del(opt); 521 return 0; 522 } 523 } 524 525 static void opt_set(QemuOpts *opts, const char *name, const char *value, 526 bool prepend, Error **errp) 527 { 528 QemuOpt *opt; 529 const QemuOptDesc *desc; 530 Error *local_err = NULL; 531 532 desc = find_desc_by_name(opts->list->desc, name); 533 if (!desc && !opts_accepts_any(opts)) { 534 error_setg(errp, QERR_INVALID_PARAMETER, name); 535 return; 536 } 537 538 opt = g_malloc0(sizeof(*opt)); 539 opt->name = g_strdup(name); 540 opt->opts = opts; 541 if (prepend) { 542 QTAILQ_INSERT_HEAD(&opts->head, opt, next); 543 } else { 544 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 545 } 546 opt->desc = desc; 547 opt->str = g_strdup(value); 548 qemu_opt_parse(opt, &local_err); 549 if (local_err) { 550 error_propagate(errp, local_err); 551 qemu_opt_del(opt); 552 } 553 } 554 555 void qemu_opt_set(QemuOpts *opts, const char *name, const char *value, 556 Error **errp) 557 { 558 opt_set(opts, name, value, false, errp); 559 } 560 561 void qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val, 562 Error **errp) 563 { 564 QemuOpt *opt; 565 const QemuOptDesc *desc = opts->list->desc; 566 567 opt = g_malloc0(sizeof(*opt)); 568 opt->desc = find_desc_by_name(desc, name); 569 if (!opt->desc && !opts_accepts_any(opts)) { 570 error_setg(errp, QERR_INVALID_PARAMETER, name); 571 g_free(opt); 572 return; 573 } 574 575 opt->name = g_strdup(name); 576 opt->opts = opts; 577 opt->value.boolean = !!val; 578 opt->str = g_strdup(val ? "on" : "off"); 579 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 580 } 581 582 void qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val, 583 Error **errp) 584 { 585 QemuOpt *opt; 586 const QemuOptDesc *desc = opts->list->desc; 587 588 opt = g_malloc0(sizeof(*opt)); 589 opt->desc = find_desc_by_name(desc, name); 590 if (!opt->desc && !opts_accepts_any(opts)) { 591 error_setg(errp, QERR_INVALID_PARAMETER, name); 592 g_free(opt); 593 return; 594 } 595 596 opt->name = g_strdup(name); 597 opt->opts = opts; 598 opt->value.uint = val; 599 opt->str = g_strdup_printf("%" PRId64, val); 600 QTAILQ_INSERT_TAIL(&opts->head, opt, next); 601 } 602 603 /** 604 * For each member of @opts, call @func(@opaque, name, value, @errp). 605 * @func() may store an Error through @errp, but must return non-zero then. 606 * When @func() returns non-zero, break the loop and return that value. 607 * Return zero when the loop completes. 608 */ 609 int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, 610 Error **errp) 611 { 612 QemuOpt *opt; 613 int rc; 614 615 QTAILQ_FOREACH(opt, &opts->head, next) { 616 rc = func(opaque, opt->name, opt->str, errp); 617 if (rc) { 618 return rc; 619 } 620 assert(!errp || !*errp); 621 } 622 return 0; 623 } 624 625 QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id) 626 { 627 QemuOpts *opts; 628 629 QTAILQ_FOREACH(opts, &list->head, next) { 630 if (!opts->id && !id) { 631 return opts; 632 } 633 if (opts->id && id && !strcmp(opts->id, id)) { 634 return opts; 635 } 636 } 637 return NULL; 638 } 639 640 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, 641 int fail_if_exists, Error **errp) 642 { 643 QemuOpts *opts = NULL; 644 645 if (id) { 646 if (!id_wellformed(id)) { 647 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id", 648 "an identifier"); 649 error_append_hint(errp, "Identifiers consist of letters, digits, " 650 "'-', '.', '_', starting with a letter.\n"); 651 return NULL; 652 } 653 opts = qemu_opts_find(list, id); 654 if (opts != NULL) { 655 if (fail_if_exists && !list->merge_lists) { 656 error_setg(errp, "Duplicate ID '%s' for %s", id, list->name); 657 return NULL; 658 } else { 659 return opts; 660 } 661 } 662 } else if (list->merge_lists) { 663 opts = qemu_opts_find(list, NULL); 664 if (opts) { 665 return opts; 666 } 667 } 668 opts = g_malloc0(sizeof(*opts)); 669 opts->id = g_strdup(id); 670 opts->list = list; 671 loc_save(&opts->loc); 672 QTAILQ_INIT(&opts->head); 673 QTAILQ_INSERT_TAIL(&list->head, opts, next); 674 return opts; 675 } 676 677 void qemu_opts_reset(QemuOptsList *list) 678 { 679 QemuOpts *opts, *next_opts; 680 681 QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) { 682 qemu_opts_del(opts); 683 } 684 } 685 686 void qemu_opts_loc_restore(QemuOpts *opts) 687 { 688 loc_restore(&opts->loc); 689 } 690 691 void qemu_opts_set(QemuOptsList *list, const char *id, 692 const char *name, const char *value, Error **errp) 693 { 694 QemuOpts *opts; 695 Error *local_err = NULL; 696 697 opts = qemu_opts_create(list, id, 1, &local_err); 698 if (local_err) { 699 error_propagate(errp, local_err); 700 return; 701 } 702 qemu_opt_set(opts, name, value, errp); 703 } 704 705 const char *qemu_opts_id(QemuOpts *opts) 706 { 707 return opts->id; 708 } 709 710 /* The id string will be g_free()d by qemu_opts_del */ 711 void qemu_opts_set_id(QemuOpts *opts, char *id) 712 { 713 opts->id = id; 714 } 715 716 void qemu_opts_del(QemuOpts *opts) 717 { 718 QemuOpt *opt; 719 720 if (opts == NULL) { 721 return; 722 } 723 724 for (;;) { 725 opt = QTAILQ_FIRST(&opts->head); 726 if (opt == NULL) 727 break; 728 qemu_opt_del(opt); 729 } 730 QTAILQ_REMOVE(&opts->list->head, opts, next); 731 g_free(opts->id); 732 g_free(opts); 733 } 734 735 /* print value, escaping any commas in value */ 736 static void escaped_print(const char *value) 737 { 738 const char *ptr; 739 740 for (ptr = value; *ptr; ++ptr) { 741 if (*ptr == ',') { 742 putchar(','); 743 } 744 putchar(*ptr); 745 } 746 } 747 748 void qemu_opts_print(QemuOpts *opts, const char *separator) 749 { 750 QemuOpt *opt; 751 QemuOptDesc *desc = opts->list->desc; 752 const char *sep = ""; 753 754 if (opts->id) { 755 printf("id=%s", opts->id); /* passed id_wellformed -> no commas */ 756 sep = separator; 757 } 758 759 if (desc[0].name == NULL) { 760 QTAILQ_FOREACH(opt, &opts->head, next) { 761 printf("%s%s=", sep, opt->name); 762 escaped_print(opt->str); 763 sep = separator; 764 } 765 return; 766 } 767 for (; desc && desc->name; desc++) { 768 const char *value; 769 QemuOpt *opt = qemu_opt_find(opts, desc->name); 770 771 value = opt ? opt->str : desc->def_value_str; 772 if (!value) { 773 continue; 774 } 775 if (desc->type == QEMU_OPT_STRING) { 776 printf("%s%s=", sep, desc->name); 777 escaped_print(value); 778 } else if ((desc->type == QEMU_OPT_SIZE || 779 desc->type == QEMU_OPT_NUMBER) && opt) { 780 printf("%s%s=%" PRId64, sep, desc->name, opt->value.uint); 781 } else { 782 printf("%s%s=%s", sep, desc->name, value); 783 } 784 sep = separator; 785 } 786 } 787 788 static void opts_do_parse(QemuOpts *opts, const char *params, 789 const char *firstname, bool prepend, Error **errp) 790 { 791 char option[128], value[1024]; 792 const char *p,*pe,*pc; 793 Error *local_err = NULL; 794 795 for (p = params; *p != '\0'; p++) { 796 pe = strchr(p, '='); 797 pc = strchr(p, ','); 798 if (!pe || (pc && pc < pe)) { 799 /* found "foo,more" */ 800 if (p == params && firstname) { 801 /* implicitly named first option */ 802 pstrcpy(option, sizeof(option), firstname); 803 p = get_opt_value(value, sizeof(value), p); 804 } else { 805 /* option without value, probably a flag */ 806 p = get_opt_name(option, sizeof(option), p, ','); 807 if (strncmp(option, "no", 2) == 0) { 808 memmove(option, option+2, strlen(option+2)+1); 809 pstrcpy(value, sizeof(value), "off"); 810 } else { 811 pstrcpy(value, sizeof(value), "on"); 812 } 813 } 814 } else { 815 /* found "foo=bar,more" */ 816 p = get_opt_name(option, sizeof(option), p, '='); 817 if (*p != '=') { 818 break; 819 } 820 p++; 821 p = get_opt_value(value, sizeof(value), p); 822 } 823 if (strcmp(option, "id") != 0) { 824 /* store and parse */ 825 opt_set(opts, option, value, prepend, &local_err); 826 if (local_err) { 827 error_propagate(errp, local_err); 828 return; 829 } 830 } 831 if (*p != ',') { 832 break; 833 } 834 } 835 } 836 837 /** 838 * Store options parsed from @params into @opts. 839 * If @firstname is non-null, the first key=value in @params may omit 840 * key=, and is treated as if key was @firstname. 841 * On error, store an error object through @errp if non-null. 842 */ 843 void qemu_opts_do_parse(QemuOpts *opts, const char *params, 844 const char *firstname, Error **errp) 845 { 846 opts_do_parse(opts, params, firstname, false, errp); 847 } 848 849 static QemuOpts *opts_parse(QemuOptsList *list, const char *params, 850 bool permit_abbrev, bool defaults, Error **errp) 851 { 852 const char *firstname; 853 char value[1024], *id = NULL; 854 const char *p; 855 QemuOpts *opts; 856 Error *local_err = NULL; 857 858 assert(!permit_abbrev || list->implied_opt_name); 859 firstname = permit_abbrev ? list->implied_opt_name : NULL; 860 861 if (strncmp(params, "id=", 3) == 0) { 862 get_opt_value(value, sizeof(value), params+3); 863 id = value; 864 } else if ((p = strstr(params, ",id=")) != NULL) { 865 get_opt_value(value, sizeof(value), p+4); 866 id = value; 867 } 868 869 /* 870 * This code doesn't work for defaults && !list->merge_lists: when 871 * params has no id=, and list has an element with !opts->id, it 872 * appends a new element instead of returning the existing opts. 873 * However, we got no use for this case. Guard against possible 874 * (if unlikely) future misuse: 875 */ 876 assert(!defaults || list->merge_lists); 877 opts = qemu_opts_create(list, id, !defaults, &local_err); 878 if (opts == NULL) { 879 error_propagate(errp, local_err); 880 return NULL; 881 } 882 883 opts_do_parse(opts, params, firstname, defaults, &local_err); 884 if (local_err) { 885 error_propagate(errp, local_err); 886 qemu_opts_del(opts); 887 return NULL; 888 } 889 890 return opts; 891 } 892 893 /** 894 * Create a QemuOpts in @list and with options parsed from @params. 895 * If @permit_abbrev, the first key=value in @params may omit key=, 896 * and is treated as if key was @list->implied_opt_name. 897 * On error, store an error object through @errp if non-null. 898 * Return the new QemuOpts on success, null pointer on error. 899 */ 900 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, 901 bool permit_abbrev, Error **errp) 902 { 903 return opts_parse(list, params, permit_abbrev, false, errp); 904 } 905 906 /** 907 * Create a QemuOpts in @list and with options parsed from @params. 908 * If @permit_abbrev, the first key=value in @params may omit key=, 909 * and is treated as if key was @list->implied_opt_name. 910 * Report errors with error_report_err(). This is inappropriate in 911 * QMP context. Do not use this function there! 912 * Return the new QemuOpts on success, null pointer on error. 913 */ 914 QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params, 915 bool permit_abbrev) 916 { 917 Error *err = NULL; 918 QemuOpts *opts; 919 920 opts = opts_parse(list, params, permit_abbrev, false, &err); 921 if (err) { 922 error_report_err(err); 923 } 924 return opts; 925 } 926 927 void qemu_opts_set_defaults(QemuOptsList *list, const char *params, 928 int permit_abbrev) 929 { 930 QemuOpts *opts; 931 932 opts = opts_parse(list, params, permit_abbrev, true, NULL); 933 assert(opts); 934 } 935 936 typedef struct OptsFromQDictState { 937 QemuOpts *opts; 938 Error **errp; 939 } OptsFromQDictState; 940 941 static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque) 942 { 943 OptsFromQDictState *state = opaque; 944 char buf[32]; 945 const char *value; 946 int n; 947 948 if (!strcmp(key, "id") || *state->errp) { 949 return; 950 } 951 952 switch (qobject_type(obj)) { 953 case QTYPE_QSTRING: 954 value = qstring_get_str(qobject_to_qstring(obj)); 955 break; 956 case QTYPE_QINT: 957 n = snprintf(buf, sizeof(buf), "%" PRId64, 958 qint_get_int(qobject_to_qint(obj))); 959 assert(n < sizeof(buf)); 960 value = buf; 961 break; 962 case QTYPE_QFLOAT: 963 n = snprintf(buf, sizeof(buf), "%.17g", 964 qfloat_get_double(qobject_to_qfloat(obj))); 965 assert(n < sizeof(buf)); 966 value = buf; 967 break; 968 case QTYPE_QBOOL: 969 pstrcpy(buf, sizeof(buf), 970 qbool_get_bool(qobject_to_qbool(obj)) ? "on" : "off"); 971 value = buf; 972 break; 973 default: 974 return; 975 } 976 977 qemu_opt_set(state->opts, key, value, state->errp); 978 } 979 980 /* 981 * Create QemuOpts from a QDict. 982 * Use value of key "id" as ID if it exists and is a QString. 983 * Only QStrings, QInts, QFloats and QBools are copied. Entries with 984 * other types are silently ignored. 985 */ 986 QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict, 987 Error **errp) 988 { 989 OptsFromQDictState state; 990 Error *local_err = NULL; 991 QemuOpts *opts; 992 993 opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1, 994 &local_err); 995 if (local_err) { 996 error_propagate(errp, local_err); 997 return NULL; 998 } 999 1000 assert(opts != NULL); 1001 1002 state.errp = &local_err; 1003 state.opts = opts; 1004 qdict_iter(qdict, qemu_opts_from_qdict_1, &state); 1005 if (local_err) { 1006 error_propagate(errp, local_err); 1007 qemu_opts_del(opts); 1008 return NULL; 1009 } 1010 1011 return opts; 1012 } 1013 1014 /* 1015 * Adds all QDict entries to the QemuOpts that can be added and removes them 1016 * from the QDict. When this function returns, the QDict contains only those 1017 * entries that couldn't be added to the QemuOpts. 1018 */ 1019 void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp) 1020 { 1021 const QDictEntry *entry, *next; 1022 1023 entry = qdict_first(qdict); 1024 1025 while (entry != NULL) { 1026 Error *local_err = NULL; 1027 OptsFromQDictState state = { 1028 .errp = &local_err, 1029 .opts = opts, 1030 }; 1031 1032 next = qdict_next(qdict, entry); 1033 1034 if (find_desc_by_name(opts->list->desc, entry->key)) { 1035 qemu_opts_from_qdict_1(entry->key, entry->value, &state); 1036 if (local_err) { 1037 error_propagate(errp, local_err); 1038 return; 1039 } else { 1040 qdict_del(qdict, entry->key); 1041 } 1042 } 1043 1044 entry = next; 1045 } 1046 } 1047 1048 /* 1049 * Convert from QemuOpts to QDict. 1050 * The QDict values are of type QString. 1051 * TODO We'll want to use types appropriate for opt->desc->type, but 1052 * this is enough for now. 1053 */ 1054 QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict) 1055 { 1056 QemuOpt *opt; 1057 QObject *val; 1058 1059 if (!qdict) { 1060 qdict = qdict_new(); 1061 } 1062 if (opts->id) { 1063 qdict_put(qdict, "id", qstring_from_str(opts->id)); 1064 } 1065 QTAILQ_FOREACH(opt, &opts->head, next) { 1066 val = QOBJECT(qstring_from_str(opt->str)); 1067 qdict_put_obj(qdict, opt->name, val); 1068 } 1069 return qdict; 1070 } 1071 1072 /* Validate parsed opts against descriptions where no 1073 * descriptions were provided in the QemuOptsList. 1074 */ 1075 void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp) 1076 { 1077 QemuOpt *opt; 1078 Error *local_err = NULL; 1079 1080 assert(opts_accepts_any(opts)); 1081 1082 QTAILQ_FOREACH(opt, &opts->head, next) { 1083 opt->desc = find_desc_by_name(desc, opt->name); 1084 if (!opt->desc) { 1085 error_setg(errp, QERR_INVALID_PARAMETER, opt->name); 1086 return; 1087 } 1088 1089 qemu_opt_parse(opt, &local_err); 1090 if (local_err) { 1091 error_propagate(errp, local_err); 1092 return; 1093 } 1094 } 1095 } 1096 1097 /** 1098 * For each member of @list, call @func(@opaque, member, @errp). 1099 * Call it with the current location temporarily set to the member's. 1100 * @func() may store an Error through @errp, but must return non-zero then. 1101 * When @func() returns non-zero, break the loop and return that value. 1102 * Return zero when the loop completes. 1103 */ 1104 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, 1105 void *opaque, Error **errp) 1106 { 1107 Location loc; 1108 QemuOpts *opts; 1109 int rc; 1110 1111 loc_push_none(&loc); 1112 QTAILQ_FOREACH(opts, &list->head, next) { 1113 loc_restore(&opts->loc); 1114 rc = func(opaque, opts, errp); 1115 if (rc) { 1116 return rc; 1117 } 1118 assert(!errp || !*errp); 1119 } 1120 loc_pop(&loc); 1121 return 0; 1122 } 1123 1124 static size_t count_opts_list(QemuOptsList *list) 1125 { 1126 QemuOptDesc *desc = NULL; 1127 size_t num_opts = 0; 1128 1129 if (!list) { 1130 return 0; 1131 } 1132 1133 desc = list->desc; 1134 while (desc && desc->name) { 1135 num_opts++; 1136 desc++; 1137 } 1138 1139 return num_opts; 1140 } 1141 1142 void qemu_opts_free(QemuOptsList *list) 1143 { 1144 g_free(list); 1145 } 1146 1147 /* Realloc dst option list and append options from an option list (list) 1148 * to it. dst could be NULL or a malloced list. 1149 * The lifetime of dst must be shorter than the input list because the 1150 * QemuOptDesc->name, ->help, and ->def_value_str strings are shared. 1151 */ 1152 QemuOptsList *qemu_opts_append(QemuOptsList *dst, 1153 QemuOptsList *list) 1154 { 1155 size_t num_opts, num_dst_opts; 1156 QemuOptDesc *desc; 1157 bool need_init = false; 1158 bool need_head_update; 1159 1160 if (!list) { 1161 return dst; 1162 } 1163 1164 /* If dst is NULL, after realloc, some area of dst should be initialized 1165 * before adding options to it. 1166 */ 1167 if (!dst) { 1168 need_init = true; 1169 need_head_update = true; 1170 } else { 1171 /* Moreover, even if dst is not NULL, the realloc may move it to a 1172 * different address in which case we may get a stale tail pointer 1173 * in dst->head. */ 1174 need_head_update = QTAILQ_EMPTY(&dst->head); 1175 } 1176 1177 num_opts = count_opts_list(dst); 1178 num_dst_opts = num_opts; 1179 num_opts += count_opts_list(list); 1180 dst = g_realloc(dst, sizeof(QemuOptsList) + 1181 (num_opts + 1) * sizeof(QemuOptDesc)); 1182 if (need_init) { 1183 dst->name = NULL; 1184 dst->implied_opt_name = NULL; 1185 dst->merge_lists = false; 1186 } 1187 if (need_head_update) { 1188 QTAILQ_INIT(&dst->head); 1189 } 1190 dst->desc[num_dst_opts].name = NULL; 1191 1192 /* append list->desc to dst->desc */ 1193 if (list) { 1194 desc = list->desc; 1195 while (desc && desc->name) { 1196 if (find_desc_by_name(dst->desc, desc->name) == NULL) { 1197 dst->desc[num_dst_opts++] = *desc; 1198 dst->desc[num_dst_opts].name = NULL; 1199 } 1200 desc++; 1201 } 1202 } 1203 1204 return dst; 1205 } 1206