]>
git.proxmox.com Git - qemu.git/blob - qemu-option.c
2 * Commandline option parsing functions
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009 Kevin Wolf <kwolf@redhat.com>
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
29 #include "qemu-common.h"
30 #include "qemu-option.h"
33 * Extracts the name of an option from the parameter string (p points at the
34 * first byte of the option name)
36 * The option name is delimited by delim (usually , or =) or the string end
37 * and is copied into buf. If the option name is longer than buf_size, it is
38 * truncated. buf is always zero terminated.
40 * The return value is the position of the delimiter/zero byte after the option
43 const char *get_opt_name(char *buf
, int buf_size
, const char *p
, char delim
)
48 while (*p
!= '\0' && *p
!= delim
) {
49 if (q
&& (q
- buf
) < buf_size
- 1)
60 * Extracts the value of an option from the parameter string p (p points at the
61 * first byte of the option value)
63 * This function is comparable to get_opt_name with the difference that the
64 * delimiter is fixed to be comma which starts a new option. To specify an
65 * option value that contains commas, double each comma.
67 const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
78 if (q
&& (q
- buf
) < buf_size
- 1)
88 int get_next_param_value(char *buf
, int buf_size
,
89 const char *tag
, const char **pstr
)
96 p
= get_opt_name(option
, sizeof(option
), p
, '=');
100 if (!strcmp(tag
, option
)) {
101 *pstr
= get_opt_value(buf
, buf_size
, p
);
107 p
= get_opt_value(NULL
, 0, p
);
116 int get_param_value(char *buf
, int buf_size
,
117 const char *tag
, const char *str
)
119 return get_next_param_value(buf
, buf_size
, tag
, &str
);
122 int check_params(char *buf
, int buf_size
,
123 const char * const *params
, const char *str
)
130 p
= get_opt_name(buf
, buf_size
, p
, '=');
135 for (i
= 0; params
[i
] != NULL
; i
++) {
136 if (!strcmp(params
[i
], buf
)) {
140 if (params
[i
] == NULL
) {
143 p
= get_opt_value(NULL
, 0, p
);
153 * Searches an option list for an option with the given name
155 QEMUOptionParameter
*get_option_parameter(QEMUOptionParameter
*list
,
158 while (list
&& list
->name
) {
159 if (!strcmp(list
->name
, name
)) {
169 * Sets the value of a parameter in a given option list. The parsing of the
170 * value depends on the type of option:
172 * OPT_FLAG (uses value.n):
173 * If no value is given, the flag is set to 1.
174 * Otherwise the value must be "on" (set to 1) or "off" (set to 0)
176 * OPT_STRING (uses value.s):
177 * value is strdup()ed and assigned as option value
179 * OPT_SIZE (uses value.n):
180 * The value is converted to an integer. Suffixes for kilobytes etc. are
181 * allowed (powers of 1024).
183 * Returns 0 on succes, -1 in error cases
185 int set_option_parameter(QEMUOptionParameter
*list
, const char *name
,
188 // Find a matching parameter
189 list
= get_option_parameter(list
, name
);
191 fprintf(stderr
, "Unknown option '%s'\n", name
);
196 switch (list
->type
) {
199 if (!strcmp(value
, "on")) {
201 } else if (!strcmp(value
, "off")) {
204 fprintf(stderr
, "Option '%s': Use 'on' or 'off'\n", name
);
214 list
->value
.s
= strdup(value
);
216 fprintf(stderr
, "Option '%s' needs a parameter\n", name
);
223 double sizef
= strtod(value
, (char**) &value
);
237 list
->value
.n
= (uint64_t) sizef
;
240 fprintf(stderr
, "Option '%s' needs size as parameter\n", name
);
241 fprintf(stderr
, "You may use k, M, G or T suffixes for "
242 "kilobytes, megabytes, gigabytes and terabytes.\n");
246 fprintf(stderr
, "Option '%s' needs a parameter\n", name
);
251 fprintf(stderr
, "Bug: Option '%s' has an unknown type\n", name
);
259 * Sets the given parameter to an integer instead of a string.
260 * This function cannot be used to set string options.
262 * Returns 0 on success, -1 in error cases
264 int set_option_parameter_int(QEMUOptionParameter
*list
, const char *name
,
267 // Find a matching parameter
268 list
= get_option_parameter(list
, name
);
270 fprintf(stderr
, "Unknown option '%s'\n", name
);
275 switch (list
->type
) {
279 list
->value
.n
= value
;
290 * Frees a option list. If it contains strings, the strings are freed as well.
292 void free_option_parameters(QEMUOptionParameter
*list
)
294 QEMUOptionParameter
*cur
= list
;
296 while (cur
&& cur
->name
) {
297 if (cur
->type
== OPT_STRING
) {
307 * Parses a parameter string (param) into an option list (dest).
309 * list is the templace is. If dest is NULL, a new copy of list is created for
310 * it. If list is NULL, this function fails.
312 * A parameter string consists of one or more parameters, separated by commas.
313 * Each parameter consists of its name and possibly of a value. In the latter
314 * case, the value is delimited by an = character. To specify a value which
315 * contains commas, double each comma so it won't be recognized as the end of
318 * For more details of the parsing see above.
320 * Returns a pointer to the first element of dest (or the newly allocated copy)
321 * or NULL in error cases
323 QEMUOptionParameter
*parse_option_parameters(const char *param
,
324 QEMUOptionParameter
*list
, QEMUOptionParameter
*dest
)
326 QEMUOptionParameter
*cur
;
327 QEMUOptionParameter
*allocated
= NULL
;
330 char *param_delim
, *value_delim
;
339 // Count valid options
347 // Create a copy of the option list to fill in values
348 dest
= qemu_mallocz((num_options
+ 1) * sizeof(QEMUOptionParameter
));
350 memcpy(dest
, list
, (num_options
+ 1) * sizeof(QEMUOptionParameter
));
355 // Find parameter name and value in the string
356 param_delim
= strchr(param
, ',');
357 value_delim
= strchr(param
, '=');
359 if (value_delim
&& (value_delim
< param_delim
|| !param_delim
)) {
366 param
= get_opt_name(name
, sizeof(name
), param
, next_delim
);
368 param
= get_opt_value(value
, sizeof(value
), param
+ 1);
370 if (*param
!= '\0') {
375 if (set_option_parameter(dest
, name
, value_delim
? value
: NULL
)) {
383 // Only free the list if it was newly allocated
384 free_option_parameters(allocated
);
389 * Prints all options of a list that have a value to stdout
391 void print_option_parameters(QEMUOptionParameter
*list
)
393 while (list
&& list
->name
) {
394 switch (list
->type
) {
396 if (list
->value
.s
!= NULL
) {
397 printf("%s='%s' ", list
->name
, list
->value
.s
);
401 printf("%s=%s ", list
->name
, list
->value
.n
? "on" : "off");
405 printf("%s=%" PRId64
" ", list
->name
, list
->value
.n
);
408 printf("%s=(unkown type) ", list
->name
);
416 * Prints an overview of all available options
418 void print_option_help(QEMUOptionParameter
*list
)
420 printf("Supported options:\n");
421 while (list
&& list
->name
) {
422 printf("%-16s %s\n", list
->name
,
423 list
->help
? list
->help
: "No description available");