From 2abe02c0511b2278af9386e7ac5e266d890a38b1 Mon Sep 17 00:00:00 2001 From: David Turner Date: Fri, 10 Sep 2010 00:31:27 +0200 Subject: upstream: qemu-option.c --- qemu-objects.h | 5 +- qemu-option.c | 264 ++++++++++++++++++++++++++++++++++++++++++++++----------- qemu-option.h | 10 ++- 3 files changed, 225 insertions(+), 54 deletions(-) diff --git a/qemu-objects.h b/qemu-objects.h index e1d1e0c..c53fbaa 100644 --- a/qemu-objects.h +++ b/qemu-objects.h @@ -6,9 +6,10 @@ * Authors: * Luiz Capitulino * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. + * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. + * See the COPYING.LIB file in the top-level directory. */ + #ifndef QEMU_OBJECTS_H #define QEMU_OBJECTS_H diff --git a/qemu-option.c b/qemu-option.c index 6a5d2ef..1f8f41a 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -27,7 +27,10 @@ #include #include "qemu-common.h" +#include "qemu-error.h" +#include "qemu-objects.h" #include "qemu-option.h" +#include "qerror.h" /* * Extracts the name of an option from the parameter string (p points at the @@ -167,16 +170,16 @@ QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list, static int parse_option_bool(const char *name, const char *value, int *ret) { - if (value != NULL) { - if (!strcmp(value, "on")) { + if (value != NULL) { + if (!strcmp(value, "on")) { *ret = 1; - } else if (!strcmp(value, "off")) { + } else if (!strcmp(value, "off")) { *ret = 0; - } else { - fprintf(stderr, "Option '%s': Use 'on' or 'off'\n", name); - return -1; - } } else { + qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'"); + return -1; + } + } else { *ret = 1; } return 0; @@ -187,17 +190,17 @@ static int parse_option_number(const char *name, const char *value, uint64_t *re char *postfix; uint64_t number; - if (value != NULL) { + if (value != NULL) { number = strtoull(value, &postfix, 0); if (*postfix != '\0') { - fprintf(stderr, "Option '%s' needs a number as parameter\n", name); + qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number"); return -1; } *ret = number; - } else { - fprintf(stderr, "Option '%s' needs a parameter\n", name); - return -1; - } + } else { + qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number"); + return -1; + } return 0; } @@ -206,32 +209,32 @@ static int parse_option_size(const char *name, const char *value, uint64_t *ret) char *postfix; double sizef; - if (value != NULL) { + if (value != NULL) { sizef = strtod(value, &postfix); switch (*postfix) { - case 'T': - sizef *= 1024; - case 'G': - sizef *= 1024; - case 'M': - sizef *= 1024; - case 'K': - case 'k': - sizef *= 1024; - case 'b': - case '\0': + case 'T': + sizef *= 1024; + case 'G': + sizef *= 1024; + case 'M': + sizef *= 1024; + case 'K': + case 'k': + sizef *= 1024; + case 'b': + case '\0': *ret = (uint64_t) sizef; - break; - default: - fprintf(stderr, "Option '%s' needs size as parameter\n", name); - fprintf(stderr, "You may use k, M, G or T suffixes for " + break; + default: + qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size"); + error_printf_unless_qmp("You may use k, M, G or T suffixes for " "kilobytes, megabytes, gigabytes and terabytes.\n"); - return -1; - } - } else { - fprintf(stderr, "Option '%s' needs a parameter\n", name); return -1; } + } else { + qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size"); + return -1; + } return 0; } @@ -343,6 +346,52 @@ void free_option_parameters(QEMUOptionParameter *list) } /* + * Count valid options in list + */ +static size_t count_option_parameters(QEMUOptionParameter *list) +{ + size_t num_options = 0; + + while (list && list->name) { + num_options++; + list++; + } + + return num_options; +} + +/* + * Append an option list (list) to an option list (dest). + * + * If dest is NULL, a new copy of list is created. + * + * Returns a pointer to the first element of dest (or the newly allocated copy) + */ +QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, + QEMUOptionParameter *list) +{ + size_t num_options, num_dest_options; + + num_options = count_option_parameters(dest); + num_dest_options = num_options; + + num_options += count_option_parameters(list); + + dest = qemu_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter)); + dest[num_dest_options].name = NULL; + + while (list && list->name) { + if (get_option_parameter(dest, list->name) == NULL) { + dest[num_dest_options++] = *list; + dest[num_dest_options].name = NULL; + } + list++; + } + + return dest; +} + +/* * Parses a parameter string (param) into an option list (dest). * * list is the templace is. If dest is NULL, a new copy of list is created for @@ -362,7 +411,6 @@ void free_option_parameters(QEMUOptionParameter *list) QEMUOptionParameter *parse_option_parameters(const char *param, QEMUOptionParameter *list, QEMUOptionParameter *dest) { - QEMUOptionParameter *cur; QEMUOptionParameter *allocated = NULL; char name[256]; char value[256]; @@ -376,12 +424,7 @@ QEMUOptionParameter *parse_option_parameters(const char *param, if (dest == NULL) { // Count valid options - num_options = 0; - cur = list; - while (cur->name) { - num_options++; - cur++; - } + num_options = count_option_parameters(list); // Create a copy of the option list to fill in values dest = qemu_mallocz((num_options + 1) * sizeof(QEMUOptionParameter)); @@ -483,6 +526,7 @@ struct QemuOpt { struct QemuOpts { char *id; QemuOptsList *list; + Location loc; QTAILQ_HEAD(QemuOptHead, QemuOpt) head; QTAILQ_ENTRY(QemuOpts) next; }; @@ -577,8 +621,7 @@ int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) if (i == 0) { /* empty list -> allow any */; } else { - fprintf(stderr, "option \"%s\" is not valid for %s\n", - name, opts->list->name); + qerror_report(QERR_INVALID_PARAMETER, name); return -1; } } @@ -594,8 +637,6 @@ int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) opt->str = qemu_strdup(value); } if (qemu_opt_parse(opt) < 0) { - fprintf(stderr, "Failed to parse \"%s\" for \"%s.%s\"\n", opt->str, - opts->list->name, opt->name); qemu_opt_del(opt); return -1; } @@ -632,16 +673,35 @@ QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id) return NULL; } +static int id_wellformed(const char *id) +{ + int i; + + if (!qemu_isalpha(id[0])) { + return 0; + } + for (i = 1; id[i]; i++) { + if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) { + return 0; + } + } + return 1; +} + QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists) { QemuOpts *opts = NULL; if (id) { + if (!id_wellformed(id)) { + qerror_report(QERR_INVALID_PARAMETER_VALUE, "id", "an identifier"); + error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n"); + return NULL; + } opts = qemu_opts_find(list, id); if (opts != NULL) { if (fail_if_exists) { - fprintf(stderr, "tried to create id \"%s\" twice for \"%s\"\n", - id, list->name); + qerror_report(QERR_DUPLICATE_ID, id, list->name); return NULL; } else { return opts; @@ -653,11 +713,26 @@ QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exist opts->id = qemu_strdup(id); } opts->list = list; + loc_save(&opts->loc); QTAILQ_INIT(&opts->head); QTAILQ_INSERT_TAIL(&list->head, opts, next); return opts; } +void qemu_opts_reset(QemuOptsList *list) +{ + QemuOpts *opts, *next_opts; + + QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) { + qemu_opts_del(opts); + } +} + +void qemu_opts_loc_restore(QemuOpts *opts) +{ + loc_restore(&opts->loc); +} + int qemu_opts_set(QemuOptsList *list, const char *id, const char *name, const char *value) { @@ -749,18 +824,23 @@ int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname return 0; } -QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, const char *firstname) +QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, + int permit_abbrev) { + const char *firstname; char value[1024], *id = NULL; const char *p; QemuOpts *opts; + assert(!permit_abbrev || list->implied_opt_name); + firstname = permit_abbrev ? list->implied_opt_name : NULL; + if (strncmp(params, "id=", 3) == 0) { get_opt_value(value, sizeof(value), params+3); - id = qemu_strdup(value); + id = value; } else if ((p = strstr(params, ",id=")) != NULL) { get_opt_value(value, sizeof(value), p+4); - id = qemu_strdup(value); + id = value; } opts = qemu_opts_create(list, id, 1); if (opts == NULL) @@ -774,6 +854,85 @@ QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, const char *fi return opts; } +static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque) +{ + char buf[32]; + const char *value; + int n; + + if (!strcmp(key, "id")) { + return; + } + + switch (qobject_type(obj)) { + case QTYPE_QSTRING: + value = qstring_get_str(qobject_to_qstring(obj)); + break; + case QTYPE_QINT: + n = snprintf(buf, sizeof(buf), "%" PRId64, + qint_get_int(qobject_to_qint(obj))); + assert(n < sizeof(buf)); + value = buf; + break; + case QTYPE_QFLOAT: + n = snprintf(buf, sizeof(buf), "%.17g", + qfloat_get_double(qobject_to_qfloat(obj))); + assert(n < sizeof(buf)); + value = buf; + break; + case QTYPE_QBOOL: + pstrcpy(buf, sizeof(buf), + qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off"); + value = buf; + break; + default: + return; + } + qemu_opt_set(opaque, key, value); +} + +/* + * Create QemuOpts from a QDict. + * Use value of key "id" as ID if it exists and is a QString. + * Only QStrings, QInts, QFloats and QBools are copied. Entries with + * other types are silently ignored. + */ +QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict) +{ + QemuOpts *opts; + + opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1); + if (opts == NULL) + return NULL; + + qdict_iter(qdict, qemu_opts_from_qdict_1, opts); + return opts; +} + +/* + * Convert from QemuOpts to QDict. + * The QDict values are of type QString. + * TODO We'll want to use types appropriate for opt->desc->type, but + * this is enough for now. + */ +QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict) +{ + QemuOpt *opt; + QObject *val; + + if (!qdict) { + qdict = qdict_new(); + } + if (opts->id) { + qdict_put(qdict, "id", qstring_from_str(opts->id)); + } + QTAILQ_FOREACH(opt, &opts->head, next) { + val = QOBJECT(qstring_from_str(opt->str)); + qdict_put_obj(qdict, opt->name, val); + } + return qdict; +} + /* Validate parsed opts against descriptions where no * descriptions were provided in the QemuOptsList. */ @@ -792,8 +951,7 @@ int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc) } } if (desc[i].name == NULL) { - fprintf(stderr, "option \"%s\" is not valid for %s\n", - opt->name, opts->list->name); + qerror_report(QERR_INVALID_PARAMETER, opt->name); return -1; } @@ -810,13 +968,17 @@ int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc) int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, int abort_on_failure) { + Location loc; QemuOpts *opts; int rc = 0; + loc_push_none(&loc); QTAILQ_FOREACH(opts, &list->head, next) { + loc_restore(&opts->loc); rc |= func(opts, opaque); if (abort_on_failure && rc != 0) break; } + loc_pop(&loc); return rc; } diff --git a/qemu-option.h b/qemu-option.h index f3f1de7..b515813 100644 --- a/qemu-option.h +++ b/qemu-option.h @@ -28,6 +28,7 @@ #include #include "qemu-queue.h" +#include "qdict.h" enum QEMUOptionParType { OPT_FLAG, @@ -69,6 +70,8 @@ int set_option_parameter(QEMUOptionParameter *list, const char *name, const char *value); int set_option_parameter_int(QEMUOptionParameter *list, const char *name, uint64_t value); +QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, + QEMUOptionParameter *list); QEMUOptionParameter *parse_option_parameters(const char *param, QEMUOptionParameter *list, QEMUOptionParameter *dest); void free_option_parameters(QEMUOptionParameter *list); @@ -96,6 +99,7 @@ typedef struct QemuOptDesc { struct QemuOptsList { const char *name; + const char *implied_opt_name; QTAILQ_HEAD(, QemuOpts) head; QemuOptDesc desc[]; }; @@ -111,13 +115,17 @@ int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id); QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists); +void qemu_opts_reset(QemuOptsList *list); +void qemu_opts_loc_restore(QemuOpts *opts); int qemu_opts_set(QemuOptsList *list, const char *id, const char *name, const char *value); const char *qemu_opts_id(QemuOpts *opts); void qemu_opts_del(QemuOpts *opts); int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc); int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname); -QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, const char *firstname); +QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, int permit_abbrev); +QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict); +QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict); typedef int (*qemu_opts_loopfunc)(QemuOpts *opts, void *opaque); int qemu_opts_print(QemuOpts *opts, void *dummy); -- cgit v1.1