It was requested to make the 'c', 'opt', and 'arg' params the same, i.e.
defined through the FOREACH_OPTION macro. But we can't do that easily,
because 'c' was defined in the for loop definition, and we can only
define variables of the same type in that way. Also, in some cases we
need only 'c', in other cases with need 'c' and 'arg, in some cases 'c'
and 'opt', and in other cases all three. We'd need to either
conditionalize or mark those variables with _unused_ to deal with
compiler warnings. But a different approach works quite nicely: add
state.opt and state.arg to show the current option and it's argument.
(The short names are picked on purpose to reduce verbosity since those
are used a lot.)
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program takes no arguments.");
return 1;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return version();
OPTION_LONG("icon", "NAME", "Icon name"):
- arg_icon = arg;
+ arg_icon = opts.arg;
break;
OPTION_LONG("timeout", "SEC", "Timeout in seconds"):
- r = parse_sec(arg, &arg_timeout);
+ r = parse_sec(opts.arg, &arg_timeout);
if (r < 0)
- return log_error_errno(r, "Failed to parse --timeout= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --timeout= parameter: %s", opts.arg);
break;
/* Note the asymmetry: the long option --echo= allows an optional argument,
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "echo", "yes|no|masked",
"Control whether to show password while typing"): {}
OPTION('e', "echo", NULL, "Equivalent to --echo=yes"):
- if (!arg) {
+ if (!opts.arg) {
/* Short option -e is used, or no argument to long option --echo= */
arg_flags |= ASK_PASSWORD_ECHO;
arg_flags &= ~ASK_PASSWORD_SILENT;
- } else if (isempty(arg) || streq(arg, "masked"))
+ } else if (isempty(opts.arg) || streq(opts.arg, "masked"))
/* Empty argument or explicit string "masked" for default behaviour. */
arg_flags &= ~(ASK_PASSWORD_ECHO|ASK_PASSWORD_SILENT);
else {
- r = parse_boolean_argument("--echo=", arg, NULL);
+ r = parse_boolean_argument("--echo=", opts.arg, NULL);
if (r < 0)
return r;
break;
OPTION_LONG("emoji", "yes|no|auto", "Show a lock and key emoji"):
- emoji = arg;
+ emoji = opts.arg;
break;
OPTION_LONG("no-tty", NULL, "Ask question via agent even on TTY"):
break;
OPTION_LONG("id", "ID", "Query identifier (e.g. \"cryptsetup:/dev/sda5\")"):
- arg_id = arg;
+ arg_id = opts.arg;
break;
OPTION_LONG("keyname", "NAME", "Kernel key name for caching passwords"):
- arg_key_name = arg;
+ arg_key_name = opts.arg;
break;
OPTION_LONG("no-output", NULL, "Do not print password to standard output"):
OPTION_LONG("credential", "NAME",
"Credential name for ImportCredential=, LoadCredential= or SetCredential= credentials"):
- arg_credential_name = arg;
+ arg_credential_name = opts.arg;
break;
OPTION_LONG("user", NULL, "Ask only our own user's agents"):
SET_FLAG(arg_flags, ASK_PASSWORD_HIDE_EMOJI, !r);
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!strv_isempty(args)) {
arg_message = strv_join(args, " ");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* ret_a= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- if (option_parser_get_n_args(&state) != 0)
+ if (option_parser_get_n_args(&opts) != 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s takes no argument.",
program_invocation_short_name);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if ((arg_unregister || arg_cat_flags != CAT_CONFIG_OFF) && !strv_isempty(args))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return version();
OPTION_LONG("path", "PATH", "Path to the $BOOT partition (may be used multiple times)"):
- r = strv_extend(&arg_path, arg);
+ r = strv_extend(&arg_path, opts.arg);
if (r < 0)
return log_oom();
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* ret_a= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_GROUP("Block Device Discovery Commands"): {}
OPTION_LONG("esp-path", "PATH", "Path to the EFI System Partition (ESP)"): {}
OPTION_LONG("path", "PATH", /* help= */ NULL): /* Compatibility alias */
- r = free_and_strdup(&arg_esp_path, arg);
+ r = free_and_strdup(&arg_esp_path, opts.arg);
if (r < 0)
return log_oom();
break;
OPTION_LONG("boot-path", "PATH", "Path to the $BOOT partition"):
- r = free_and_strdup(&arg_xbootldr_path, arg);
+ r = free_and_strdup(&arg_xbootldr_path, opts.arg);
if (r < 0)
return log_oom();
break;
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ true, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ true, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("install-source", "SOURCE",
"Where to pick files when using --root=/--image= (auto, image, host)"): {
- InstallSource is = install_source_from_string(arg);
+ InstallSource is = install_source_from_string(opts.arg);
if (is < 0)
- return log_error_errno(is, "Unexpected parameter for --install-source=: %s", arg);
+ return log_error_errno(is, "Unexpected parameter for --install-source=: %s", opts.arg);
arg_install_source = is;
break;
}
OPTION_LONG("variables", "BOOL", "Whether to modify EFI variables"):
- r = parse_tristate_argument_with_auto("--variables=", arg, &arg_touch_variables);
+ r = parse_tristate_argument_with_auto("--variables=", opts.arg, &arg_touch_variables);
if (r < 0)
return r;
#if !ENABLE_EFI
if (arg_touch_variables > 0)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "Compiled without support for EFI, --variables=%s cannot be specified.", arg);
+ "Compiled without support for EFI, --variables=%s cannot be specified.", opts.arg);
#endif
break;
break;
OPTION_LONG("random-seed", "BOOL", "Whether to create random-seed file during install"):
- r = parse_boolean_argument("--random-seed=", arg, &arg_install_random_seed);
+ r = parse_boolean_argument("--random-seed=", opts.arg, &arg_install_random_seed);
if (r < 0)
return r;
break;
OPTION_LONG("entry-token", "TOKEN",
"Entry token to use for this installation"
" (machine-id, os-id, os-image-id, auto, literal:…)"):
- r = parse_boot_entry_token_type(arg, &arg_entry_token_type, &arg_entry_token);
+ r = parse_boot_entry_token_type(opts.arg, &arg_entry_token_type, &arg_entry_token);
if (r < 0)
return r;
break;
OPTION_LONG("make-entry-directory", "yes|no|auto", "Create $BOOT/ENTRY-TOKEN/ directory"): {}
OPTION_LONG("make-machine-id-directory", "BOOL", /* help= */ NULL): /* Compatibility alias */
- if (streq(arg, "auto")) /* retained for backwards compatibility */
+ if (streq(opts.arg, "auto")) /* retained for backwards compatibility */
arg_make_entry_directory = -1; /* yes if machine-id is permanent */
else {
- r = parse_boolean_argument("--make-entry-directory=", arg, NULL);
+ r = parse_boolean_argument("--make-entry-directory=", opts.arg, NULL);
if (r < 0)
return r;
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("efi-boot-option-description", "DESCRIPTION",
"Description of the entry in the boot option list"):
- if (!string_is_safe(arg, STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS)) {
- _cleanup_free_ char *escaped = cescape(arg);
+ if (!string_is_safe(opts.arg, STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS)) {
+ _cleanup_free_ char *escaped = cescape(opts.arg);
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid --efi-boot-option-description=: %s", strna(escaped));
}
- if (strlen(arg) > EFI_BOOT_OPTION_DESCRIPTION_MAX)
+ if (strlen(opts.arg) > EFI_BOOT_OPTION_DESCRIPTION_MAX)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"--efi-boot-option-description= too long: %zu > %zu",
- strlen(arg), EFI_BOOT_OPTION_DESCRIPTION_MAX);
- r = free_and_strdup_warn(&arg_efi_boot_option_description, arg);
+ strlen(opts.arg), EFI_BOOT_OPTION_DESCRIPTION_MAX);
+ r = free_and_strdup_warn(&arg_efi_boot_option_description, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("efi-boot-option-description-with-device", "BOOL",
"Suffix description with disk vendor/model/serial"):
- r = parse_boolean_argument("--efi-boot-option-description-with-device=", arg,
+ r = parse_boolean_argument("--efi-boot-option-description-with-device=", opts.arg,
&arg_efi_boot_option_description_with_device);
if (r < 0)
return r;
break;
OPTION_LONG("secure-boot-auto-enroll", "BOOL", "Set up secure boot auto-enrollment"):
- r = parse_boolean_argument("--secure-boot-auto-enroll=", arg,
+ r = parse_boolean_argument("--secure-boot-auto-enroll=", opts.arg,
&arg_secure_boot_auto_enroll);
if (r < 0)
return r;
break;
OPTION_COMMON_PRIVATE_KEY("Private key for Secure Boot auto-enrollment"):
- r = free_and_strdup_warn(&arg_private_key, arg);
+ r = free_and_strdup_warn(&arg_private_key, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_PRIVATE_KEY_SOURCE:
- r = parse_openssl_key_source_argument(arg,
+ r = parse_openssl_key_source_argument(opts.arg,
&arg_private_key_source,
&arg_private_key_source_type);
if (r < 0)
break;
OPTION_COMMON_CERTIFICATE("PEM certificate to use when setting up Secure Boot auto-enrollment"):
- r = free_and_strdup_warn(&arg_certificate, arg);
+ r = free_and_strdup_warn(&arg_certificate, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE_SOURCE:
- r = parse_openssl_certificate_source_argument(arg,
+ r = parse_openssl_certificate_source_argument(opts.arg,
&arg_certificate_source,
&arg_certificate_source_type);
if (r < 0)
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!!arg_print_esp_path + !!arg_print_dollar_boot_path + (arg_print_root_device > 0) + arg_print_loader_path + arg_print_stub_path + arg_print_efi_architecture > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argc >= 1);
assert(argv);
- OptionParser state = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
"Cannot combine --unit with --user-unit.");
arg_show_unit = SHOW_UNIT_SYSTEM;
- if (strv_extend(&arg_names, arg) < 0) /* push arg if not empty */
+ if (strv_extend(&arg_names, opts.arg) < 0) /* push arg if not empty */
return log_oom();
break;
"Cannot combine --user-unit with --unit.");
arg_show_unit = SHOW_UNIT_USER;
- if (strv_extend(&arg_names, arg) < 0) /* push arg if not empty */
+ if (strv_extend(&arg_names, opts.arg) < 0) /* push arg if not empty */
return log_oom();
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "xattr", "BOOL",
"Show cgroup extended attributes"): {}
OPTION_SHORT('x', NULL, "Same as --xattr=true"):
- if (arg) {
- r = parse_boolean(arg);
+ if (opts.arg) {
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --xattr= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --xattr= value: %s", opts.arg);
} else
r = true;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "cgroup-id", "BOOL",
"Show cgroup ID"): {}
OPTION_SHORT('c', NULL, "Same as --cgroup-id=true"):
- if (arg) {
- r = parse_boolean(arg);
+ if (opts.arg) {
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --cgroup-id= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --cgroup-id= value: %s", opts.arg);
} else
r = true;
break;
OPTION_COMMON_MACHINE:
- arg_machine = arg;
+ arg_machine = opts.arg;
break;
OPTION_POSITIONAL:
- if (strv_extend(&arg_names, arg) < 0) /* push arg */
+ if (strv_extend(&arg_names, opts.arg) < 0) /* push arg */
return log_oom();
break;
}
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Cannot combine --unit or --user-unit with --machine=.");
- assert(option_parser_get_n_args(&state) == 0);
+ assert(option_parser_get_n_args(&opts) == 0);
return 1;
}
assert(argc >= 1);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("order", "PROPERTY",
"Order by specified property (path, tasks, cpu, memory, io)"):
- arg_order = order_from_string(arg);
+ arg_order = order_from_string(opts.arg);
if (arg_order < 0)
return log_error_errno(arg_order,
"Invalid argument to --order=: %s",
- arg);
+ opts.arg);
break;
OPTION_SHORT('p', NULL, "Same as --order=path, order by path"):
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "cpu", "percentage|time",
"Show CPU usage as percentage (default) or time"):
- if (arg) {
- arg_cpu_type = cpu_type_from_string(arg);
+ if (opts.arg) {
+ arg_cpu_type = cpu_type_from_string(opts.arg);
if (arg_cpu_type < 0)
return log_error_errno(arg_cpu_type,
"Unknown argument to --cpu=: %s",
- arg);
+ opts.arg);
} else
arg_cpu_type = CPU_TIME;
break;
break;
OPTION_LONG("recursive", "BOOL", "Sum up process count recursively"):
- r = parse_boolean_argument("--recursive=", arg, &arg_recursive);
+ r = parse_boolean_argument("--recursive=", opts.arg, &arg_recursive);
if (r < 0)
return r;
break;
OPTION('d', "delay", "DELAY", "Delay between updates"):
- r = parse_sec(arg, &arg_delay);
+ r = parse_sec(opts.arg, &arg_delay);
if (r < 0)
- return log_error_errno(r, "Failed to parse delay parameter '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse delay parameter '%s': %m", opts.arg);
if (arg_delay <= 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid delay parameter '%s'",
- arg);
+ opts.arg);
break;
OPTION('n', "iterations", "N", "Run for N iterations before exiting"):
- r = safe_atou(arg, &arg_iterations);
+ r = safe_atou(opts.arg, &arg_iterations);
if (r < 0)
- return log_error_errno(r, "Failed to parse iterations parameter '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse iterations parameter '%s': %m", opts.arg);
break;
OPTION_SHORT('1', NULL, "Shortcut for --iterations=1"):
OPTION_LONG("depth", "DEPTH",
"Maximum traversal depth (default: "STRINGIFY(DEFAULT_MAXIMUM_DEPTH)")"):
- r = safe_atou(arg, &arg_depth);
+ r = safe_atou(opts.arg, &arg_depth);
if (r < 0)
- return log_error_errno(r, "Failed to parse depth parameter '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse depth parameter '%s': %m", opts.arg);
break;
OPTION_COMMON_MACHINE:
- arg_machine = arg;
+ arg_machine = opts.arg;
break;
}
- size_t n_args = option_parser_get_n_args(&state);
+ size_t n_args = option_parser_get_n_args(&opts);
if (n_args > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Too many arguments.");
if (n_args == 1)
- arg_root = option_parser_get_args(&state)[0];
+ arg_root = option_parser_get_args(&opts)[0];
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_COMMON_LOG_LEVEL:
- r = log_set_max_level_from_string(arg);
+ r = log_set_max_level_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse log level \"%s\": %m", arg);
+ return log_error_errno(r, "Failed to parse log level \"%s\": %m", opts.arg);
break;
OPTION_COMMON_LOG_TARGET:
- r = log_set_target_from_string(arg);
+ r = log_set_target_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse log target \"%s\": %m", arg);
+ return log_error_errno(r, "Failed to parse log target \"%s\": %m", opts.arg);
break;
OPTION_COMMON_LOG_COLOR:
- r = log_show_color_from_string(arg);
+ r = log_show_color_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse log color setting \"%s\": %m", arg);
+ return log_error_errno(r, "Failed to parse log color setting \"%s\": %m", opts.arg);
break;
OPTION_COMMON_LOG_LOCATION:
- r = log_show_location_from_string(arg);
+ r = log_show_location_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse log location setting \"%s\": %m", arg);
+ return log_error_errno(r, "Failed to parse log location setting \"%s\": %m", opts.arg);
break;
OPTION_COMMON_LOG_TIME:
- r = log_show_time_from_string(arg);
+ r = log_show_time_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse log time setting \"%s\": %m", arg);
+ return log_error_errno(r, "Failed to parse log time setting \"%s\": %m", opts.arg);
break;
OPTION_LONG("deserialize", "FD", "Deserialize process config from FD"): {
- int fd = parse_fd(arg);
+ int fd = parse_fd(opts.arg);
if (fd < 0)
- return log_error_errno(fd, "Failed to parse serialization fd \"%s\": %m", arg);
+ return log_error_errno(fd, "Failed to parse serialization fd \"%s\": %m", opts.arg);
/* Set O_CLOEXEC and as a side effect, verify that the fd is valid. */
r = fd_cloexec(fd, /* cloexec= */ true);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("transcode", "METHOD",
"Transcode credential data (base64, unbase64, hex, unhex)"):
- if (streq(arg, "help")) {
+ if (streq(opts.arg, "help")) {
if (arg_legend)
puts("Supported transcode types:");
return DUMP_STRING_TABLE(transcode_mode, TranscodeMode, _TRANSCODE_MAX);
}
- if (parse_boolean(arg) == 0) /* If specified as "false", turn transcoding off */
+ if (parse_boolean(opts.arg) == 0) /* If specified as "false", turn transcoding off */
arg_transcode = TRANSCODE_OFF;
else {
TranscodeMode m;
- m = transcode_mode_from_string(arg);
+ m = transcode_mode_from_string(opts.arg);
if (m < 0)
return log_error_errno(m, "Failed to parse transcode mode: %m");
break;
OPTION_LONG("newline", "auto|yes|no", "Suffix output with newline"):
- r = parse_tristate_argument_with_auto("--newline=", arg, &arg_newline);
+ r = parse_tristate_argument_with_auto("--newline=", opts.arg, &arg_newline);
if (r < 0)
return r;
break;
OPTION_LONG("name", "NAME",
"Override filename included in encrypted credential"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_name = NULL;
arg_name_any = true;
break;
}
- if (!credential_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid credential name: %s", arg);
+ if (!credential_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid credential name: %s", opts.arg);
- arg_name = arg;
+ arg_name = opts.arg;
arg_name_any = false;
break;
OPTION_LONG("timestamp", "TIME",
"Include specified timestamp in encrypted credential"):
- r = parse_timestamp(arg, &arg_timestamp);
+ r = parse_timestamp(opts.arg, &arg_timestamp);
if (r < 0)
- return log_error_errno(r, "Failed to parse timestamp: %s", arg);
+ return log_error_errno(r, "Failed to parse timestamp: %s", opts.arg);
break;
OPTION_LONG("not-after", "TIME",
"Include specified invalidation time in encrypted credential"):
- r = parse_timestamp(arg, &arg_not_after);
+ r = parse_timestamp(opts.arg, &arg_not_after);
if (r < 0)
- return log_error_errno(r, "Failed to parse --not-after= timestamp: %s", arg);
+ return log_error_errno(r, "Failed to parse --not-after= timestamp: %s", opts.arg);
break;
OPTION_LONG("with-key", "KEY",
"Which keys to encrypt with (host, tpm2, host+tpm2, null, auto, auto-initrd)"):
- if (streq(arg, "help")) {
+ if (streq(opts.arg, "help")) {
if (arg_legend)
puts("Supported key types:");
return DUMP_STRING_TABLE(cred_key_type, CredKeyType, _CRED_KEY_TYPE_MAX);
}
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_with_key = _CRED_AUTO;
else {
- CredKeyType t = cred_key_type_from_string(arg);
+ CredKeyType t = cred_key_type_from_string(opts.arg);
if (t < 0)
return log_error_errno(t, "Failed to parse key type: %m");
break;
OPTION_LONG("tpm2-device", "PATH", "Pick TPM2 device"):
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(arg_legend, arg_quiet);
- arg_tpm2_device = streq(arg, "auto") ? NULL : arg;
+ arg_tpm2_device = streq(opts.arg, "auto") ? NULL : opts.arg;
break;
OPTION_LONG("tpm2-pcrs", "PCR1+PCR2+PCR3+…",
"Specify TPM2 PCRs to seal against (fixed hash)"):
/* For fixed hash PCR policies only */
- r = tpm2_parse_pcr_argument_to_mask(arg, &arg_tpm2_pcr_mask);
+ r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_tpm2_pcr_mask);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-public-key", "PATH",
"Specify PEM certificate to seal against"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_public_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_public_key);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-public-key-pcrs", "PCR1+PCR2+…",
"Specify TPM2 PCRs to seal against (public key)"):
/* For public key PCR policies only */
- r = tpm2_parse_pcr_argument_to_mask(arg, &arg_tpm2_public_key_pcr_mask);
+ r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_tpm2_public_key_pcr_mask);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-signature", "PATH",
"Specify signature for public key PCR policy"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_signature);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_signature);
if (r < 0)
return r;
break;
break;
OPTION_LONG("uid", "UID", "Select user for scoped credentials"):
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_uid = UID_INVALID;
- else if (streq(arg, "self"))
+ else if (streq(opts.arg, "self"))
arg_uid = getuid();
else {
- const char *name = arg;
+ const char *name = opts.arg;
r = get_user_creds(
&name,
/* flags= */ 0);
if (r < 0)
return log_error_errno(r, "Failed to resolve user '%s': %s",
- arg, STRERROR_USER(r));
+ opts.arg, STRERROR_USER(r));
}
break;
return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
arg_varlink = r;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("wipe-slot", "SLOT1,SLOT2,…",
"Wipe specified slots"):
- r = parse_wipe_slot(arg);
+ r = parse_wipe_slot(opts.arg);
if (r < 0)
return r;
break;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Multiple unlock methods specified at once, refusing.");
- r = parse_path_argument(arg, /* suppress_root= */ true, &arg_unlock_keyfile);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ true, &arg_unlock_keyfile);
if (r < 0)
return r;
assert(!arg_unlock_fido2_device);
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
assert(!arg_unlock_tpm2_device);
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
"Enroll a PKCS#11 security token or list them"): {
_cleanup_free_ char *uri = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return pkcs11_list_tokens();
if (arg_enroll_type >= 0 || arg_pkcs11_token_uri)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Multiple operations specified at once, refusing.");
- if (streq(arg, "auto")) {
+ if (streq(opts.arg, "auto")) {
r = pkcs11_find_token_auto(&uri);
if (r < 0)
return r;
} else {
- if (!pkcs11_uri_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not a valid PKCS#11 URI: %s", arg);
+ if (!pkcs11_uri_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not a valid PKCS#11 URI: %s", opts.arg);
- uri = strdup(arg);
+ uri = strdup(opts.arg);
if (!uri)
return log_oom();
}
"Enroll a FIDO2-HMAC security token or list them"): {
_cleanup_free_ char *device = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return fido2_list_devices();
if (arg_enroll_type >= 0 || arg_fido2_device)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Multiple operations specified at once, refusing.");
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
OPTION_LONG("fido2-salt-file", "PATH",
"Use salt from a file instead of generating one"):
- r = parse_path_argument(arg, /* suppress_root= */ true, &arg_fido2_salt_file);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ true, &arg_fido2_salt_file);
if (r < 0)
return r;
break;
OPTION_LONG("fido2-parameters-in-header", "BOOL",
"Whether to store FIDO2 parameters in the LUKS2 header"):
- r = parse_boolean_argument("--fido2-parameters-in-header=", arg, &arg_fido2_parameters_in_header);
+ r = parse_boolean_argument("--fido2-parameters-in-header=", opts.arg, &arg_fido2_parameters_in_header);
if (r < 0)
return r;
break;
OPTION_LONG("fido2-credential-algorithm", "STRING",
"Specify COSE algorithm for FIDO2 credential"):
- r = parse_fido2_algorithm(arg, &arg_fido2_cred_alg);
+ r = parse_fido2_algorithm(opts.arg, &arg_fido2_cred_alg);
if (r < 0)
- return log_error_errno(r, "Failed to parse COSE algorithm: %s", arg);
+ return log_error_errno(r, "Failed to parse COSE algorithm: %s", opts.arg);
break;
OPTION_LONG("fido2-with-client-pin", "BOOL",
"Whether to require entering a PIN to unlock the volume"):
- r = parse_boolean_argument("--fido2-with-client-pin=", arg, NULL);
+ r = parse_boolean_argument("--fido2-with-client-pin=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_PIN, r);
OPTION_LONG("fido2-with-user-presence", "BOOL",
"Whether to require user presence to unlock the volume"):
- r = parse_boolean_argument("--fido2-with-user-presence=", arg, NULL);
+ r = parse_boolean_argument("--fido2-with-user-presence=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_UP, r);
OPTION_LONG("fido2-with-user-verification", "BOOL",
"Whether to require user verification to unlock the volume"):
- r = parse_boolean_argument("--fido2-with-user-verification=", arg, NULL);
+ r = parse_boolean_argument("--fido2-with-user-verification=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_fido2_lock_with, FIDO2ENROLL_UV, r);
"Enroll a TPM2 device or list them"): {
_cleanup_free_ char *device = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(/* legend= */ true, /* quiet= */ false);
if (arg_enroll_type >= 0 || arg_tpm2_device)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Multiple operations specified at once, refusing.");
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Multiple operations specified at once, refusing.");
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_device_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_device_key);
if (r < 0)
return r;
OPTION_LONG("tpm2-seal-key-handle", "HANDLE",
"Specify handle of key to use for sealing"):
- r = safe_atou32_full(arg, 16, &arg_tpm2_seal_key_handle);
+ r = safe_atou32_full(opts.arg, 16, &arg_tpm2_seal_key_handle);
if (r < 0)
- return log_error_errno(r, "Could not parse TPM2 seal key handle index '%s': %m", arg);
+ return log_error_errno(r, "Could not parse TPM2 seal key handle index '%s': %m", opts.arg);
break;
OPTION_LONG("tpm2-pcrs", "PCR1+PCR2+PCR3+…",
"Specify TPM2 PCRs to seal against"):
- r = tpm2_parse_pcr_argument_append(arg, &arg_tpm2_hash_pcr_values, &arg_tpm2_n_hash_pcr_values);
+ r = tpm2_parse_pcr_argument_append(opts.arg, &arg_tpm2_hash_pcr_values, &arg_tpm2_n_hash_pcr_values);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-public-key", "PATH",
"Enroll signed TPM2 PCR policy against PEM public key"):
/* an empty argument disables loading a public key */
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_tpm2_load_public_key = false;
arg_tpm2_public_key = mfree(arg_tpm2_public_key);
break;
}
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_public_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_public_key);
if (r < 0)
return r;
arg_tpm2_load_public_key = true;
OPTION_LONG("tpm2-public-key-pcrs", "PCR1+PCR2+PCR3+…",
"Enroll signed TPM2 PCR policy for specified TPM2 PCRs"):
auto_public_key_pcr_mask = false;
- r = tpm2_parse_pcr_argument_to_mask(arg, &arg_tpm2_public_key_pcr_mask);
+ r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_tpm2_public_key_pcr_mask);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-signature", "PATH",
"Validate public key enrollment works with JSON signature file"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_signature);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_signature);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-pcrlock", "PATH",
"Specify pcrlock policy to lock against"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_pcrlock);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_pcrlock);
if (r < 0)
return r;
auto_pcrlock = false;
OPTION_LONG("tpm2-with-pin", "BOOL",
"Whether to require entering a PIN to unlock the volume"):
- r = parse_boolean_argument("--tpm2-with-pin=", arg, &arg_tpm2_pin);
+ r = parse_boolean_argument("--tpm2-with-pin=", opts.arg, &arg_tpm2_pin);
if (r < 0)
return r;
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION('t', "type", "TYPE...", "Only display a selected set of override types"):
- r = parse_flags(arg, arg_flags);
+ r = parse_flags(opts.arg, arg_flags);
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse flags field.");
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "diff", "yes|no",
"Show a diff when overridden files differ"):
- r = parse_boolean_argument("--diff", arg, NULL);
+ r = parse_boolean_argument("--diff", opts.arg, NULL);
if (r < 0)
return r;
arg_diff = r;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return DUMP_STRING_TABLE(confidential_virtualization, ConfidentialVirtualization, _CONFIDENTIAL_VIRTUALIZATION_MAX);
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s takes no arguments.",
program_invocation_short_name);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const Option *current;
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION_FULL(&state, c, ¤t, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_NO_PAGER:
OPTION_LONG("discard", "MODE", "Choose discard mode (disabled, loop, all, crypto)"): {
DissectImageFlags flags;
- if (streq(arg, "disabled"))
+ if (streq(opts.arg, "disabled"))
flags = 0;
- else if (streq(arg, "loop"))
+ else if (streq(opts.arg, "loop"))
flags = DISSECT_IMAGE_DISCARD_ON_LOOP;
- else if (streq(arg, "all"))
+ else if (streq(opts.arg, "all"))
flags = DISSECT_IMAGE_DISCARD_ON_LOOP | DISSECT_IMAGE_DISCARD;
- else if (streq(arg, "crypt"))
+ else if (streq(opts.arg, "crypt"))
flags = DISSECT_IMAGE_DISCARD_ANY;
- else if (streq(arg, "list")) {
+ else if (streq(opts.arg, "list")) {
puts("disabled\n"
"all\n"
"crypt\n"
return 0;
} else
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Unknown --discard= parameter: %s", arg);
+ "Unknown --discard= parameter: %s", opts.arg);
arg_flags = (arg_flags & ~DISSECT_IMAGE_DISCARD_ANY) | flags;
break;
OPTION_LONG("usr-hash", "HASH", "Same, but for the usr partition"): {
_cleanup_(iovec_done) struct iovec roothash = {};
- PartitionDesignator d = streq(current->long_code, "root-hash") ? PARTITION_ROOT : PARTITION_USR;
+ PartitionDesignator d = streq(opts.opt->long_code, "root-hash") ? PARTITION_ROOT : PARTITION_USR;
if (arg_verity_settings.designator >= 0 &&
arg_verity_settings.designator != d)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Cannot combine --root-hash=/--root-hash-sig= and --usr-hash=/--usr-hash-sig= options.");
- r = unhexmem(arg, &roothash.iov_base, &roothash.iov_len);
+ r = unhexmem(opts.arg, &roothash.iov_base, &roothash.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to parse root hash '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse root hash '%s': %m", opts.arg);
if (roothash.iov_len < sizeof(sd_id128_t))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Root hash must be at least 128-bit long: %s", arg);
+ "Root hash must be at least 128-bit long: %s", opts.arg);
iovec_done(&arg_verity_settings.root_hash);
arg_verity_settings.root_hash = TAKE_STRUCT(roothash);
const char *value;
_cleanup_(iovec_done) struct iovec sig = {};
- PartitionDesignator d = streq(current->long_code, "root-hash-sig") ? PARTITION_ROOT : PARTITION_USR;
+ PartitionDesignator d = streq(opts.opt->long_code, "root-hash-sig") ? PARTITION_ROOT : PARTITION_USR;
if (arg_verity_settings.designator >= 0 &&
arg_verity_settings.designator != d)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Cannot combine --root-hash=/--root-hash-sig= and --usr-hash=/--usr-hash-sig= options.");
- if ((value = startswith(arg, "base64:"))) {
+ if ((value = startswith(opts.arg, "base64:"))) {
r = unbase64mem(value, &sig.iov_base, &sig.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to parse root hash signature '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse root hash signature '%s': %m", opts.arg);
} else {
- r = read_full_file(arg, (char**) &sig.iov_base, &sig.iov_len);
+ r = read_full_file(opts.arg, (char**) &sig.iov_base, &sig.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to read root hash signature file '%s': %m", arg);
+ return log_error_errno(r, "Failed to read root hash signature file '%s': %m", opts.arg);
}
iovec_done(&arg_verity_settings.root_hash_sig);
OPTION_LONG("verity-data", "PATH",
"Specify data file with hash tree for verity if it is not embedded in IMAGE"):
- r = parse_path_argument(arg, false, &arg_verity_settings.data_path);
+ r = parse_path_argument(opts.arg, false, &arg_verity_settings.data_path);
if (r < 0)
return r;
break;
OPTION_LONG("fsck", "BOOL", "Run fsck before mounting"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --fsck= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --fsck= parameter: %s", opts.arg);
SET_FLAG(arg_flags, DISSECT_IMAGE_FSCK, r);
break;
OPTION_LONG("growfs", "BOOL", "Grow file system to partition size, if marked"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --growfs= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --growfs= parameter: %s", opts.arg);
SET_FLAG(arg_flags, DISSECT_IMAGE_GROWFS, r);
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("loop-ref", "NAME", "Set reference string for loopback device"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_loop_ref = mfree(arg_loop_ref);
arg_loop_ref_auto = false;
break;
}
- if (strlen(arg) >= sizeof_field(struct loop_info64, lo_file_name))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Loop device ref string '%s' is too long.", arg);
+ if (strlen(opts.arg) >= sizeof_field(struct loop_info64, lo_file_name))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Loop device ref string '%s' is too long.", opts.arg);
- r = free_and_strdup_warn(&arg_loop_ref, arg);
+ r = free_and_strdup_warn(&arg_loop_ref, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("mtree-hash", "BOOL", "Whether to include SHA256 hash in the mtree output"):
- r = parse_boolean_argument("--mtree-hash=", arg, &arg_mtree_hash);
+ r = parse_boolean_argument("--mtree-hash=", opts.arg, &arg_mtree_hash);
if (r < 0)
return r;
break;
OPTION_LONG("image-filter", "FILTER", "Specify image dissection filter"): {
_cleanup_(image_filter_freep) ImageFilter *f = NULL;
- r = image_filter_parse(arg, &f);
+ r = image_filter_parse(opts.arg, &f);
if (r < 0)
- return log_error_errno(r, "Failed to parse image filter expression: %s", arg);
+ return log_error_errno(r, "Failed to parse image filter expression: %s", opts.arg);
image_filter_free(arg_image_filter);
arg_image_filter = TAKE_PTR(f);
}
OPTION_LONG("copy-ownership", "BOOL", "Whether to copy ownership when copying files"):
- r = parse_tristate_argument_with_auto("--copy-ownership=", arg, &arg_copy_ownership);
+ r = parse_tristate_argument_with_auto("--copy-ownership=", opts.arg, &arg_copy_ownership);
if (r < 0)
return r;
break;
arg_runtime_scope = system_scope_requested && user_scope_requested ? _RUNTIME_SCOPE_INVALID :
system_scope_requested ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER;
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
switch (arg_action) {
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("suffix", "SUFFIX", "Unit suffix to append to escaped strings"): {
- UnitType t = unit_type_from_string(arg);
+ UnitType t = unit_type_from_string(opts.arg);
if (t < 0)
- return log_error_errno(t, "Invalid unit suffix type \"%s\".", arg);
+ return log_error_errno(t, "Invalid unit suffix type \"%s\".", opts.arg);
- arg_suffix = arg;
+ arg_suffix = opts.arg;
break;
}
OPTION_LONG("template", "TEMPLATE", "Insert strings as instance into template"):
- if (!unit_name_is_valid(arg, UNIT_NAME_TEMPLATE))
+ if (!unit_name_is_valid(opts.arg, UNIT_NAME_TEMPLATE))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Template name %s is not valid.", arg);
+ "Template name %s is not valid.", opts.arg);
- arg_template = arg;
+ arg_template = opts.arg;
break;
OPTION_LONG("instance", NULL, "With --unescape, show just the instance part"):
break;
}
- if (option_parser_get_n_args(&state) == 0)
+ if (option_parser_get_n_args(&opts) == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Not enough arguments.");
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"--instance may not be combined with --template.");
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
if (r > 0)
arg_varlink = true;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, true, &arg_root);
+ r = parse_path_argument(opts.arg, true, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, false, &arg_image);
+ r = parse_path_argument(opts.arg, false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("locale", "LOCALE", "Set primary locale (LANG=)"):
- r = free_and_strdup_warn(&arg_locale, arg);
+ r = free_and_strdup_warn(&arg_locale, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("locale-messages", "LOCALE", "Set message locale (LC_MESSAGES=)"):
- r = free_and_strdup_warn(&arg_locale_messages, arg);
+ r = free_and_strdup_warn(&arg_locale_messages, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("keymap", "KEYMAP", "Set keymap"):
- if (!keymap_is_valid(arg))
+ if (!keymap_is_valid(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Keymap %s is not valid.", arg);
+ "Keymap %s is not valid.", opts.arg);
- r = free_and_strdup_warn(&arg_keymap, arg);
+ r = free_and_strdup_warn(&arg_keymap, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("timezone", "TIMEZONE", "Set timezone"):
- if (!timezone_is_valid(arg, LOG_ERR))
+ if (!timezone_is_valid(opts.arg, LOG_ERR))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Timezone %s is not valid.", arg);
+ "Timezone %s is not valid.", opts.arg);
- r = free_and_strdup_warn(&arg_timezone, arg);
+ r = free_and_strdup_warn(&arg_timezone, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("hostname", "NAME", "Set hostname"):
- if (!hostname_is_valid(arg, VALID_HOSTNAME_TRAILING_DOT|VALID_HOSTNAME_QUESTION_MARK))
+ if (!hostname_is_valid(opts.arg, VALID_HOSTNAME_TRAILING_DOT|VALID_HOSTNAME_QUESTION_MARK))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Host name %s is not valid.", arg);
+ "Host name %s is not valid.", opts.arg);
- r = free_and_strdup_warn(&arg_hostname, arg);
+ r = free_and_strdup_warn(&arg_hostname, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("machine-id", "ID", "Set specified machine ID"):
- r = sd_id128_from_string(arg, &arg_machine_id);
+ r = sd_id128_from_string(opts.arg, &arg_machine_id);
if (r < 0)
- return log_error_errno(r, "Failed to parse machine id %s.", arg);
+ return log_error_errno(r, "Failed to parse machine id %s.", opts.arg);
break;
OPTION_LONG("root-password", "PASSWORD", "Set root password from plaintext password"):
- r = free_and_strdup_warn(&arg_root_password, arg);
+ r = free_and_strdup_warn(&arg_root_password, opts.arg);
if (r < 0)
return r;
OPTION_LONG("root-password-file", "FILE", "Set root password from file"):
arg_root_password = mfree(arg_root_password);
- r = read_one_line_file(arg, &arg_root_password);
+ r = read_one_line_file(opts.arg, &arg_root_password);
if (r < 0)
- return log_error_errno(r, "Failed to read %s: %m", arg);
+ return log_error_errno(r, "Failed to read %s: %m", opts.arg);
arg_root_password_is_hashed = false;
break;
OPTION_LONG("root-password-hashed", "HASH", "Set root password from hashed password"):
- r = free_and_strdup_warn(&arg_root_password, arg);
+ r = free_and_strdup_warn(&arg_root_password, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("root-shell", "SHELL", "Set root shell"):
- r = free_and_strdup_warn(&arg_root_shell, arg);
+ r = free_and_strdup_warn(&arg_root_shell, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("kernel-command-line", "CMDLINE", "Set kernel command line"):
- r = free_and_strdup_warn(&arg_kernel_cmdline, arg);
+ r = free_and_strdup_warn(&arg_kernel_cmdline, opts.arg);
if (r < 0)
return r;
break;
break;
OPTION_LONG("welcome", "BOOL", "Whether to show the welcome text"):
- r = parse_boolean_argument("--welcome=", arg, &arg_welcome);
+ r = parse_boolean_argument("--welcome=", opts.arg, &arg_welcome);
if (r < 0)
return r;
break;
OPTION_LONG("chrome", "BOOL",
"Whether to show a color bar at top and bottom of terminal"):
- r = parse_boolean_argument("--chrome=", arg, &arg_chrome);
+ r = parse_boolean_argument("--chrome=", opts.arg, &arg_chrome);
if (r < 0)
return r;
break;
OPTION_LONG("mute-console", "BOOL",
"Whether to disallow kernel/PID 1 writes to the console while running"):
- r = parse_boolean_argument("--mute-console=", arg, &arg_mute_console);
+ r = parse_boolean_argument("--mute-console=", opts.arg, &arg_mute_console);
if (r < 0)
return r;
break;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- if (option_parser_get_n_args(&state) != 1)
+ if (option_parser_get_n_args(&opts) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s expects exactly one argument (the mount point).",
program_invocation_short_name);
- arg_target = option_parser_get_args(&state)[0];
+ arg_target = option_parser_get_args(&opts)[0];
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- if (option_parser_get_n_args(&state) > 0 && arg_clear)
+ if (option_parser_get_n_args(&opts) > 0 && arg_clear)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Extraneous arguments specified with --clear, refusing.");
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
OPTION_COMMON_HOST:
arg_transport = BUS_TRANSPORT_REMOTE;
- arg_host = arg;
+ arg_host = opts.arg;
break;
OPTION_COMMON_MACHINE:
- r = parse_machine_argument(arg, &arg_host, &arg_transport);
+ r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
if (r < 0)
return r;
break;
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION('r', "root", "PATH", "Alternative root path in the filesystem"):
- arg_root = arg;
+ arg_root = opts.arg;
break;
OPTION_LONG("usr", NULL,
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
OPTION_LONG("json", "FORMAT",
"Output inspection data in JSON (takes one of pretty, short, off)"):
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
break;
OPTION('a', "app-specific", "ID", "Generate app-specific IDs"):
- r = id128_from_string_nonzero(arg, &arg_app);
+ r = id128_from_string_nonzero(opts.arg, &arg_app);
if (r == -ENXIO)
return log_error_errno(r, "Application ID cannot be all zeros.");
if (r < 0)
- return log_error_errno(r, "Failed to parse \"%s\" as application ID: %m", arg);
+ return log_error_errno(r, "Failed to parse \"%s\" as application ID: %m", opts.arg);
break;
OPTION('u', "uuid", NULL, "Output in UUID format"):
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
"Select well-known key/base, one of:"
" hostname, region, zone, ipv4-public, ipv6-public, ssh-key,"
" userdata, userdata-base, userdata-base64"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_well_known = _IMDS_WELL_KNOWN_INVALID;
break;
}
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(imds_well_known, ImdsWellKnown, _IMDS_WELL_KNOWN_MAX);
- ImdsWellKnown wk = imds_well_known_from_string(arg);
+ ImdsWellKnown wk = imds_well_known_from_string(opts.arg);
if (wk < 0)
- return log_error_errno(wk, "Failed to parse --well-known= argument: %s", arg);
+ return log_error_errno(wk, "Failed to parse --well-known= argument: %s", opts.arg);
arg_well_known = wk;
break;
}
OPTION_LONG("refresh", "SEC", "Set minimum freshness time for returned data"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_refresh_usec_set = false;
break;
}
usec_t t;
- r = parse_sec(arg, &t);
+ r = parse_sec(opts.arg, &t);
if (r < 0)
- return log_error_errno(r, "Failed to parse refresh timeout: %s", arg);
+ return log_error_errno(r, "Failed to parse refresh timeout: %s", opts.arg);
arg_refresh_usec = t;
arg_refresh_usec_set = true;
}
OPTION_LONG("cache", "BOOL", "Control cache use"):
- r = parse_tristate_argument_with_auto("--cache=", arg, &arg_cache);
+ r = parse_tristate_argument_with_auto("--cache=", opts.arg, &arg_cache);
if (r < 0)
return r;
break;
break;
}
- char **args = option_parser_get_args(&state);
- size_t n_args = option_parser_get_n_args(&state);
+ char **args = option_parser_get_args(&opts);
+ size_t n_args = option_parser_get_n_args(&opts);
if (IN_SET(arg_action, ACTION_USERDATA, ACTION_IMPORT)) {
if (n_args != 0)
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION('i', "interface", "INTERFACE", "Use the specified interface"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_ifname = mfree(arg_ifname);
break;
}
- if (!ifname_valid_full(arg, IFNAME_VALID_ALTERNATIVE|IFNAME_VALID_NUMERIC))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Interface name '%s' is not valid.", arg);
+ if (!ifname_valid_full(opts.arg, IFNAME_VALID_ALTERNATIVE|IFNAME_VALID_NUMERIC))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Interface name '%s' is not valid.", opts.arg);
- r = free_and_strdup_warn(&arg_ifname, arg);
+ r = free_and_strdup_warn(&arg_ifname, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("refresh", "SEC", "Set token refresh time"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_refresh_usec = REFRESH_USEC_DEFAULT;
break;
}
usec_t t;
- r = parse_sec(arg, &t);
+ r = parse_sec(opts.arg, &t);
if (r < 0)
- return log_error_errno(r, "Failed to parse refresh timeout: %s", arg);
+ return log_error_errno(r, "Failed to parse refresh timeout: %s", opts.arg);
if (t < REFRESH_USEC_MIN) {
log_warning("Increasing specified refresh time to %s, lower values are not supported.", FORMAT_TIMESPAN(REFRESH_USEC_MIN, 0));
arg_refresh_usec = REFRESH_USEC_MIN;
}
OPTION_LONG("fwmark", "INTEGER", "Choose firewall mark for HTTP traffic"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_fwmark_set = false;
break;
}
- if (streq(arg, "default")) {
+ if (streq(opts.arg, "default")) {
arg_fwmark = FWMARK_DEFAULT;
arg_fwmark_set = true;
break;
}
- r = safe_atou32(arg, &arg_fwmark);
+ r = safe_atou32(opts.arg, &arg_fwmark);
if (r < 0)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse --fwmark= parameter: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse --fwmark= parameter: %s", opts.arg);
arg_fwmark_set = true;
break;
OPTION_LONG("cache", "BOOL", "Enable/disable cache use"):
- r = parse_boolean_argument("--cache", arg, &arg_cache);
+ r = parse_boolean_argument("--cache", opts.arg, &arg_cache);
if (r < 0)
return r;
break;
OPTION_LONG("wait", "BOOL", "Whether to wait for connectivity"):
- r = parse_boolean_argument("--wait", arg, &arg_wait);
+ r = parse_boolean_argument("--wait", opts.arg, &arg_wait);
if (r < 0)
return r;
break;
break;
OPTION('K', "well-known", "KEY", "Select well-known key"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_well_known = _IMDS_WELL_KNOWN_INVALID;
break;
}
- ImdsWellKnown wk = imds_well_known_from_string(arg);
+ ImdsWellKnown wk = imds_well_known_from_string(opts.arg);
if (wk < 0)
return log_error_errno(wk, "Failed to parse --well-known= parameter: %m");
OPTION_GROUP("Manual Endpoint Configuration"): {}
OPTION_LONG("vendor", "VENDOR", "Specify IMDS vendor literally"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_vendor = mfree(arg_vendor);
break;
}
- r = free_and_strdup_warn(&arg_vendor, arg);
+ r = free_and_strdup_warn(&arg_vendor, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("token-url", "URL", "URL for acquiring token"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_token_url = mfree(arg_token_url);
break;
}
- if (!http_url_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", arg);
+ if (!http_url_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", opts.arg);
- r = free_and_strdup_warn(&arg_token_url, arg);
+ r = free_and_strdup_warn(&arg_token_url, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("refresh-header-name", "NAME", "Header name for passing refresh time"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_refresh_header_name = mfree(arg_refresh_header_name);
break;
}
- if (!http_header_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", arg);
+ if (!http_header_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", opts.arg);
- r = free_and_strdup_warn(&arg_refresh_header_name, arg);
+ r = free_and_strdup_warn(&arg_refresh_header_name, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("data-url", "URL", "Base URL for acquiring data"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_data_url = mfree(arg_data_url);
break;
}
- if (!http_url_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", arg);
+ if (!http_url_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", opts.arg);
- r = free_and_strdup_warn(&arg_data_url, arg);
+ r = free_and_strdup_warn(&arg_data_url, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("data-url-suffix", "STRING", "Suffix to append to data URL"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_data_url_suffix = mfree(arg_data_url_suffix);
break;
}
- if (!ascii_is_valid(arg) || string_has_cc(arg, /* ok= */ NULL))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL suffix: %s", arg);
+ if (!ascii_is_valid(opts.arg) || string_has_cc(opts.arg, /* ok= */ NULL))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL suffix: %s", opts.arg);
- r = free_and_strdup_warn(&arg_data_url_suffix, arg);
+ r = free_and_strdup_warn(&arg_data_url_suffix, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("token-header-name", "NAME", "Header name for passing token string"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_token_header_name = mfree(arg_token_header_name);
break;
}
- if (!http_header_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", arg);
+ if (!http_header_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", opts.arg);
- r = free_and_strdup_warn(&arg_token_header_name, arg);
+ r = free_and_strdup_warn(&arg_token_header_name, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("extra-header", "NAME: VALUE", "Additional header to pass to data transfer"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_extra_header = strv_free(arg_extra_header);
break;
}
- if (!http_header_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header: %s", arg);
+ if (!http_header_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header: %s", opts.arg);
- if (strv_extend(&arg_extra_header, arg) < 0)
+ if (strv_extend(&arg_extra_header, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("address-ipv4", "ADDRESS", "Configure IPv4 address of the IMDS server"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_address_ipv4 = (struct in_addr) {};
break;
}
union in_addr_union u;
- r = in_addr_from_string(AF_INET, arg, &u);
+ r = in_addr_from_string(AF_INET, opts.arg, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse IPv4 address: %s", arg);
+ return log_error_errno(r, "Failed to parse IPv4 address: %s", opts.arg);
arg_address_ipv4 = u.in;
break;
}
OPTION_LONG("address-ipv6", "ADDRESS", "Configure IPv6 address of the IMDS server"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_address_ipv6 = (struct in6_addr) {};
break;
}
union in_addr_union u;
- r = in_addr_from_string(AF_INET6, arg, &u);
+ r = in_addr_from_string(AF_INET6, opts.arg, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse IPv6 address: %s", arg);
+ return log_error_errno(r, "Failed to parse IPv6 address: %s", opts.arg);
arg_address_ipv6 = u.in6;
break;
}
OPTION_LONG("well-known-key", "NAME:KEY", "Configure the location of well-known keys"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
for (ImdsWellKnown wk = 0; wk < _IMDS_WELL_KNOWN_MAX; wk++)
arg_well_known_key[wk] = mfree(arg_well_known_key[wk]);
break;
}
- const char *e = strchr(arg, ':');
+ const char *e = strchr(opts.arg, ':');
if (!e)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--well-known-key= expects colon separated name and key pairs.");
- _cleanup_free_ char *name = strndup(arg, e - arg);
+ _cleanup_free_ char *name = strndup(opts.arg, e - opts.arg);
if (!name)
return log_oom();
arg_varlink = r;
if (!arg_varlink) {
- char **args = option_parser_get_args(&state);
- size_t n_args = option_parser_get_n_args(&state);
+ char **args = option_parser_get_args(&opts);
+ size_t n_args = option_parser_get_n_args(&opts);
if (arg_setup_network) {
if (n_args != 0)
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("format", "FORMAT", "Select format"):
- arg_compress = compression_from_string_harder(arg);
+ arg_compress = compression_from_string_harder(opts.arg);
if (arg_compress < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Unknown format: %s", arg);
+ "Unknown format: %s", opts.arg);
break;
OPTION_LONG("class", "CLASS",
"Select image class (machine, sysext, confext, portable)"):
- arg_class = image_class_from_string(arg);
+ arg_class = image_class_from_string(opts.arg);
if (arg_class < 0)
- return log_error_errno(arg_class, "Failed to parse --class= argument: %s", arg);
+ return log_error_errno(arg_class, "Failed to parse --class= argument: %s", opts.arg);
break;
OPTION_LONG("system", NULL, "Operate in per-system mode"):
if (arg_runtime_scope == RUNTIME_SCOPE_USER)
arg_import_flags |= IMPORT_FOREIGN_UID;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_LONG("image-root", "PATH", "Image root directory"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image_root);
if (r < 0)
return r;
break;
OPTION_LONG("btrfs-subvol", "BOOL",
"Controls whether to create a btrfs subvolume instead of a directory"):
- r = parse_boolean_argument("--btrfs-subvol=", arg, &arg_btrfs_subvol);
+ r = parse_boolean_argument("--btrfs-subvol=", opts.arg, &arg_btrfs_subvol);
if (r < 0)
return r;
break;
OPTION_LONG("btrfs-quota", "BOOL",
"Controls whether to set up quota for btrfs subvolume"):
- r = parse_boolean_argument("--btrfs-quota=", arg, &arg_btrfs_quota);
+ r = parse_boolean_argument("--btrfs-quota=", opts.arg, &arg_btrfs_quota);
if (r < 0)
return r;
break;
OPTION_LONG("sync", "BOOL", "Controls whether to sync() before completing"):
- r = parse_boolean_argument("--sync=", arg, &arg_sync);
+ r = parse_boolean_argument("--sync=", opts.arg, &arg_sync);
if (r < 0)
return r;
break;
OPTION_LONG("class", "CLASS",
"Select image class (machine, sysext, confext, portable)"):
- arg_class = image_class_from_string(arg);
+ arg_class = image_class_from_string(opts.arg);
if (arg_class < 0)
- return log_error_errno(arg_class, "Failed to parse --class= argument: %s", arg);
+ return log_error_errno(arg_class, "Failed to parse --class= argument: %s", opts.arg);
break;
OPTION_LONG("system", NULL, "Operate in per-system mode"):
return log_error_errno(r, "Failed to pick image root: %m");
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_LONG("image-root", "PATH", "Image root directory"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image_root);
if (r < 0)
return r;
break;
OPTION_LONG("btrfs-subvol", "BOOL",
"Controls whether to create a btrfs subvolume instead of a directory"):
- r = parse_boolean_argument("--btrfs-subvol=", arg, NULL);
+ r = parse_boolean_argument("--btrfs-subvol=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_BTRFS_SUBVOL, r);
OPTION_LONG("btrfs-quota", "BOOL",
"Controls whether to set up quota for btrfs subvolume"):
- r = parse_boolean_argument("--btrfs-quota=", arg, NULL);
+ r = parse_boolean_argument("--btrfs-quota=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_BTRFS_QUOTA, r);
OPTION_LONG("convert-qcow2", "BOOL",
"Controls whether to convert QCOW2 images to regular disk images"):
- r = parse_boolean_argument("--convert-qcow2=", arg, NULL);
+ r = parse_boolean_argument("--convert-qcow2=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_CONVERT_QCOW2, r);
break;
OPTION_LONG("sync", "BOOL", "Controls whether to sync() before completing"):
- r = parse_boolean_argument("--sync=", arg, NULL);
+ r = parse_boolean_argument("--sync=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_SYNC, r);
OPTION_LONG("offset", "BYTES", "Offset to seek to in destination"): {
uint64_t u;
- r = safe_atou64(arg, &u);
+ r = safe_atou64(opts.arg, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse --offset= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --offset= argument: %s", opts.arg);
if (!FILE_SIZE_VALID(u))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --offset= switch too large: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --offset= switch too large: %s", opts.arg);
arg_offset = u;
break;
OPTION_LONG("size-max", "BYTES", "Maximum number of bytes to write to destination"): {
uint64_t u;
- r = parse_size(arg, 1024, &u);
+ r = parse_size(opts.arg, 1024, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse --size-max= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --size-max= argument: %s", opts.arg);
if (!FILE_SIZE_VALID(u))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --size-max= switch too large: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --size-max= switch too large: %s", opts.arg);
arg_size_max = u;
break;
OPTION_LONG("class", "CLASS",
"Select image class (machine, sysext, confext, portable)"):
- arg_class = image_class_from_string(arg);
+ arg_class = image_class_from_string(opts.arg);
if (arg_class < 0)
- return log_error_errno(arg_class, "Failed to parse --class= argument: %s", arg);
+ return log_error_errno(arg_class, "Failed to parse --class= argument: %s", opts.arg);
break;
OPTION_LONG("system", NULL, "Operate in per-system mode"):
if (arg_runtime_scope == RUNTIME_SCOPE_USER)
arg_import_flags |= IMPORT_FOREIGN_UID;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_COMMON_HOST:
arg_transport = BUS_TRANSPORT_REMOTE;
- arg_host = arg;
+ arg_host = opts.arg;
break;
OPTION_COMMON_MACHINE:
- r = parse_machine_argument(arg, &arg_host, &arg_transport);
+ r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
if (r < 0)
return r;
break;
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
arg_legend = false;
OPTION_LONG("verify", "MODE",
"Verification mode for downloaded images (no, checksum, signature)"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(import_verify, ImportVerify, _IMPORT_VERIFY_MAX);
- r = import_verify_from_string(arg);
+ r = import_verify_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --verify= setting: %s", arg);
+ return log_error_errno(r, "Failed to parse --verify= setting: %s", opts.arg);
arg_verify = r;
break;
OPTION_LONG("format", "FORMAT",
"Desired output format for export (zstd, xz, gzip, bzip2)"):
- if (!STR_IN_SET(arg, "uncompressed", "xz", "gzip", "bzip2", "zstd"))
+ if (!STR_IN_SET(opts.arg, "uncompressed", "xz", "gzip", "bzip2", "zstd"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Unknown format: %s", arg);
- arg_format = arg;
+ "Unknown format: %s", opts.arg);
+ arg_format = opts.arg;
break;
OPTION_LONG("force", NULL, "Install image even if already exists"):
break;
OPTION_LONG("class", "TYPE", "Install as the specified TYPE"):
- arg_image_class = image_class_from_string(arg);
+ arg_image_class = image_class_from_string(opts.arg);
if (arg_image_class < 0)
- return log_error_errno(arg_image_class, "Failed to parse --class= parameter: %s", arg);
+ return log_error_errno(arg_image_class, "Failed to parse --class= parameter: %s", opts.arg);
break;
OPTION_SHORT('m', NULL, "Install as --class=machine, machine image"):
OPTION_LONG("keep-download", "BOOL",
"Control whether to keep pristine copy of download"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --keep-download= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --keep-download= value: %s", opts.arg);
SET_FLAG(arg_import_flags, IMPORT_PULL_KEEP_DOWNLOAD, r);
arg_import_flags_mask |= IMPORT_PULL_KEEP_DOWNLOAD;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_LONG("image-root", "PATH", "Image root directory"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image_root);
if (r < 0)
return r;
break;
"Verify downloaded image, one of: 'no', 'checksum', 'signature' or literal SHA256 hash"): {
ImportVerify v;
- v = import_verify_from_string(arg);
+ v = import_verify_from_string(opts.arg);
if (v < 0) {
_cleanup_free_ void *h = NULL;
size_t n;
/* If this is not a valid verification mode, maybe it's a literally specified
* SHA256 hash? We can handle that too... */
- r = unhexmem(arg, &h, &n);
+ r = unhexmem(opts.arg, &h, &n);
if (r < 0 || n == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Invalid verification setting: %s", arg);
+ "Invalid verification setting: %s", opts.arg);
if (n != 32)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"64 hex character SHA256 hash required when specifying explicit checksum, %zu specified", n * 2);
}
OPTION_LONG("settings", "BOOL", "Download settings file with image"):
- r = parse_boolean_argument("--settings=", arg, NULL);
+ r = parse_boolean_argument("--settings=", opts.arg, NULL);
if (r < 0)
return r;
break;
OPTION_LONG("roothash", "BOOL", "Download root hash file with image"):
- r = parse_boolean_argument("--roothash=", arg, NULL);
+ r = parse_boolean_argument("--roothash=", opts.arg, NULL);
if (r < 0)
return r;
OPTION_LONG("roothash-signature", "BOOL",
"Download root hash signature file with image"):
- r = parse_boolean_argument("--roothash-signature=", arg, NULL);
+ r = parse_boolean_argument("--roothash-signature=", opts.arg, NULL);
if (r < 0)
return r;
break;
OPTION_LONG("verity", "BOOL", "Download verity file with image"):
- r = parse_boolean_argument("--verity=", arg, NULL);
+ r = parse_boolean_argument("--verity=", opts.arg, NULL);
if (r < 0)
return r;
OPTION_LONG("btrfs-subvol", "BOOL",
"Controls whether to create a btrfs subvolume instead of a directory"):
- r = parse_boolean_argument("--btrfs-subvol=", arg, NULL);
+ r = parse_boolean_argument("--btrfs-subvol=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_BTRFS_SUBVOL, r);
OPTION_LONG("btrfs-quota", "BOOL",
"Controls whether to set up quota for btrfs subvolume"):
- r = parse_boolean_argument("--btrfs-quota=", arg, NULL);
+ r = parse_boolean_argument("--btrfs-quota=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_BTRFS_QUOTA, r);
OPTION_LONG("convert-qcow2", "BOOL",
"Controls whether to convert QCOW2 images to regular disk images"):
- r = parse_boolean_argument("--convert-qcow2=", arg, NULL);
+ r = parse_boolean_argument("--convert-qcow2=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_CONVERT_QCOW2, r);
break;
OPTION_LONG("sync", "BOOL", "Controls whether to sync() before completing"):
- r = parse_boolean_argument("--sync=", arg, NULL);
+ r = parse_boolean_argument("--sync=", opts.arg, NULL);
if (r < 0)
return r;
SET_FLAG(arg_import_flags, IMPORT_SYNC, r);
OPTION_LONG("offset", "BYTES", "Offset to seek to in destination"): {
uint64_t u;
- r = safe_atou64(arg, &u);
+ r = safe_atou64(opts.arg, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse --offset= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --offset= argument: %s", opts.arg);
if (!FILE_SIZE_VALID(u))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --offset= switch too large: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --offset= switch too large: %s", opts.arg);
arg_offset = u;
break;
OPTION_LONG("size-max", "BYTES", "Maximum number of bytes to write to destination"): {
uint64_t u;
- r = parse_size(arg, 1024, &u);
+ r = parse_size(opts.arg, 1024, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse --size-max= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --size-max= argument: %s", opts.arg);
if (!FILE_SIZE_VALID(u))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --size-max= switch too large: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument to --size-max= switch too large: %s", opts.arg);
arg_size_max = u;
break;
OPTION_LONG("class", "CLASS",
"Select image class (machine, sysext, confext, portable)"):
- arg_class = image_class_from_string(arg);
+ arg_class = image_class_from_string(opts.arg);
if (arg_class < 0)
- return log_error_errno(arg_class, "Failed to parse --class= argument: %s", arg);
+ return log_error_errno(arg_class, "Failed to parse --class= argument: %s", opts.arg);
break;
OPTION_LONG("keep-download", "BOOL",
"Keep a pristine copy of the downloaded file around"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --keep-download= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --keep-download= argument: %s", opts.arg);
SET_FLAG(arg_import_flags, IMPORT_PULL_KEEP_DOWNLOAD, r);
auto_keep_download = false;
if (arg_runtime_scope == RUNTIME_SCOPE_USER)
arg_import_flags |= IMPORT_FOREIGN_UID;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Certificate file specified twice");
r = read_full_file_full(
- AT_FDCWD, arg, UINT64_MAX, SIZE_MAX,
+ AT_FDCWD, opts.arg, UINT64_MAX, SIZE_MAX,
READ_FULL_FILE_CONNECT_SOCKET,
NULL,
&arg_cert_pem, NULL);
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Key file specified twice");
r = read_full_file_full(
- AT_FDCWD, arg, UINT64_MAX, SIZE_MAX,
+ AT_FDCWD, opts.arg, UINT64_MAX, SIZE_MAX,
READ_FULL_FILE_SECURE|READ_FULL_FILE_WARN_WORLD_READABLE|READ_FULL_FILE_CONNECT_SOCKET,
NULL,
&arg_key_pem, NULL);
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"CA certificate file specified twice");
r = read_full_file_full(
- AT_FDCWD, arg, UINT64_MAX, SIZE_MAX,
+ AT_FDCWD, opts.arg, UINT64_MAX, SIZE_MAX,
READ_FULL_FILE_CONNECT_SOCKET,
NULL,
&arg_trust_pem, NULL);
break;
OPTION('D', "directory", "PATH", "Serve journal files in directory"):
- r = free_and_strdup_warn(&arg_directory, arg);
+ r = free_and_strdup_warn(&arg_directory, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("file", "PATH", "Serve this journal file"):
- r = glob_extend(&arg_file, arg, GLOB_NOCHECK);
+ r = glob_extend(&arg_file, opts.arg, GLOB_NOCHECK);
if (r < 0)
return log_error_errno(r, "Failed to add paths: %m");
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program does not take arguments.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("url", "URL", "Read events from systemd-journal-gatewayd at URL"):
- r = free_and_strdup_warn(&arg_url, arg);
+ r = free_and_strdup_warn(&arg_url, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("getter", "COMMAND", "Read events from the output of COMMAND"):
- r = free_and_strdup_warn(&arg_getter, arg);
+ r = free_and_strdup_warn(&arg_getter, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("listen-raw", "ADDR", "Listen for connections at ADDR"):
- r = free_and_strdup_warn(&arg_listen_raw, arg);
+ r = free_and_strdup_warn(&arg_listen_raw, opts.arg);
if (r < 0)
return r;
break;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Cannot currently use --listen-http= more than once");
- r = negative_fd(arg);
+ r = negative_fd(opts.arg);
if (r >= 0)
http_socket = r;
else {
- r = free_and_strdup_warn(&arg_listen_http, arg);
+ r = free_and_strdup_warn(&arg_listen_http, opts.arg);
if (r < 0)
return r;
}
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Cannot currently use --listen-https= more than once");
- r = negative_fd(arg);
+ r = negative_fd(opts.arg);
if (r >= 0)
https_socket = r;
else {
- r = free_and_strdup_warn(&arg_listen_https, arg);
+ r = free_and_strdup_warn(&arg_listen_https, opts.arg);
if (r < 0)
return r;
}
break;
OPTION_LONG("key", "FILENAME", "SSL key in PEM format (default: \"" PRIV_KEY_FILE "\")"):
- r = free_and_strdup_warn(&arg_key, arg);
+ r = free_and_strdup_warn(&arg_key, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("cert", "FILENAME", "SSL certificate in PEM format (default: \"" CERT_FILE "\")"):
- r = free_and_strdup_warn(&arg_cert, arg);
+ r = free_and_strdup_warn(&arg_cert, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("trust", "FILENAME|all",
"SSL CA certificate or disable checking (default: \"" TRUST_FILE "\")"):
#if HAVE_GNUTLS
- r = free_and_strdup_warn(&arg_trust, arg);
+ r = free_and_strdup_warn(&arg_trust, opts.arg);
if (r < 0)
return r;
#else
break;
OPTION('o', "output", "FILE|DIR", "Write output to FILE or DIR/external-*.journal"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_output);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_output);
if (r < 0)
return r;
break;
OPTION_LONG("split-mode", "none|host", "How many output files to create"):
- arg_split_mode = journal_write_split_mode_from_string(arg);
+ arg_split_mode = journal_write_split_mode_from_string(opts.arg);
if (arg_split_mode == _JOURNAL_WRITE_SPLIT_INVALID)
- return log_error_errno(arg_split_mode, "Invalid split mode: %s", arg);
+ return log_error_errno(arg_split_mode, "Invalid split mode: %s", opts.arg);
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "compress", "BOOL",
"Use compression in the output journal (default: yes)"):
- r = parse_boolean_argument("--compress", arg, &arg_compress);
+ r = parse_boolean_argument("--compress", opts.arg, &arg_compress);
if (r < 0)
return r;
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "seal", "BOOL",
"Use event sealing (default: no)"):
- r = parse_boolean_argument("--seal", arg, &arg_seal);
+ r = parse_boolean_argument("--seal", opts.arg, &arg_seal);
if (r < 0)
return r;
break;
OPTION_LONG("gnutls-log", "CATEGORY,...", "Specify a list of gnutls logging categories"):
#if HAVE_GNUTLS
- for (const char *p = arg;;) {
+ for (const char *p = opts.arg;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&p, &word, ",", 0);
break;
OPTION_LONG("max-use", "BYTES", "Maximum disk space to use"):
- r = parse_size(arg, 1024, &arg_max_use);
+ r = parse_size(opts.arg, 1024, &arg_max_use);
if (r < 0)
- return log_error_errno(r, "Failed to parse --max-use= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --max-use= value: %s", opts.arg);
break;
OPTION_LONG("keep-free", "BYTES", "Minimum disk space to keep free"):
- r = parse_size(arg, 1024, &arg_keep_free);
+ r = parse_size(opts.arg, 1024, &arg_keep_free);
if (r < 0)
- return log_error_errno(r, "Failed to parse --keep-free= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --keep-free= value: %s", opts.arg);
break;
OPTION_LONG("max-file-size", "BYTES", "Maximum size of individual journal files"):
- r = parse_size(arg, 1024, &arg_max_size);
+ r = parse_size(opts.arg, 1024, &arg_max_size);
if (r < 0)
- return log_error_errno(r, "Failed to parse --max-file-size= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --max-file-size= value: %s", opts.arg);
break;
OPTION_LONG("max-files", "N", "Maximum number of journal files to keep"):
- r = safe_atou64(arg, &arg_n_max_files);
+ r = safe_atou64(opts.arg, &arg_n_max_files);
if (r < 0)
- return log_error_errno(r, "Failed to parse --max-files= value: %s", arg);
+ return log_error_errno(r, "Failed to parse --max-files= value: %s", opts.arg);
break;
}
- arg_files = strv_copy(option_parser_get_args(&state));
+ arg_files = strv_copy(option_parser_get_args(&opts));
if (!arg_files)
return log_oom();
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_LONG("tty", "TTY", "Specify path to TTY to use"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tty);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tty);
if (r < 0)
return r;
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s takes no argument.",
program_invocation_short_name);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION('t', "identifier", "STRING", "Set syslog identifier"):
- arg_identifier = empty_to_null(arg);
+ arg_identifier = empty_to_null(opts.arg);
break;
OPTION('p', "priority", "PRIORITY", "Set priority value (0..7)"):
- arg_priority = log_level_from_string(arg);
+ arg_priority = log_level_from_string(opts.arg);
if (arg_priority < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse priority value.");
OPTION_LONG("stderr-priority", "PRIORITY",
"Set priority value (0..7) used for stderr"):
- arg_stderr_priority = log_level_from_string(arg);
+ arg_stderr_priority = log_level_from_string(opts.arg);
if (arg_stderr_priority < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse stderr priority value.");
OPTION_LONG("level-prefix", "BOOL",
"Control whether level prefix shall be parsed"):
- r = parse_boolean_argument("--level-prefix=", arg, &arg_level_prefix);
+ r = parse_boolean_argument("--level-prefix=", opts.arg, &arg_level_prefix);
if (r < 0)
return r;
break;
OPTION_LONG("namespace", "NAMESPACE",
"Connect to specified journal namespace"):
- arg_namespace = empty_to_null(arg);
+ arg_namespace = empty_to_null(opts.arg);
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_COMMON_PRIVATE_KEY("Private key in PEM format"):
- r = free_and_strdup_warn(&arg_private_key, arg);
+ r = free_and_strdup_warn(&arg_private_key, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_PRIVATE_KEY_SOURCE:
r = parse_openssl_key_source_argument(
- arg,
+ opts.arg,
&arg_private_key_source,
&arg_private_key_source_type);
if (r < 0)
break;
OPTION_COMMON_CERTIFICATE("PEM certificate to use for signing"):
- r = free_and_strdup_warn(&arg_certificate, arg);
+ r = free_and_strdup_warn(&arg_certificate, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE_SOURCE:
r = parse_openssl_certificate_source_argument(
- arg,
+ opts.arg,
&arg_certificate_source,
&arg_certificate_source_type);
if (r < 0)
break;
OPTION_LONG("signature", "PATH", "PKCS#1 signature to embed in PKCS#7 signature"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_signature);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_signature);
if (r < 0)
return r;
break;
OPTION_LONG("content", "PATH", "Raw data content to embed in PKCS#7 signature"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_content);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_content);
if (r < 0)
return r;
break;
OPTION_LONG("hash-algorithm", "ALGORITHM",
"Hash algorithm used to create the PKCS#1 signature"):
- arg_hash_algorithm = arg;
+ arg_hash_algorithm = opts.arg;
break;
OPTION_LONG("output", "PATH", "Where to write the PKCS#7 signature"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_output);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_output);
if (r < 0)
return r;
break;
if (arg_private_key_source && !arg_certificate)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "When using --private-key-source=, --certificate= must be specified.");
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_VERSION:
return version();
OPTION('i', "interface", "INTERFACE", "Network interface"):
- r = rtnl_resolve_interface_or_warn(&rtnl, arg);
+ r = rtnl_resolve_interface_or_warn(&rtnl, opts.arg);
if (r < 0)
return r;
arg_ifindex = r;
break;
OPTION('t', "type", "TYPE", "ICMPv6 message type"):
- r = parse_icmp6_type(arg);
+ r = parse_icmp6_type(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse message type: %m");
arg_icmp6_type = r;
break;
OPTION('d', "dest", "ADDRESS", "Destination address"):
- r = in_addr_from_string(AF_INET6, arg, &arg_dest);
+ r = in_addr_from_string(AF_INET6, opts.arg, &arg_dest);
if (r < 0)
return log_error_errno(r, "Failed to parse destination address: %m");
if (!in6_addr_is_link_local(&arg_dest.in6))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "The destination address %s is not a link-local address.", arg);
+ "The destination address %s is not a link-local address.", opts.arg);
break;
OPTION_GROUP("Router Advertisement"): {}
OPTION_LONG("hop-limit", "LIMIT", "Hop limit"):
- r = safe_atou8(arg, &arg_hop_limit);
+ r = safe_atou8(opts.arg, &arg_hop_limit);
if (r < 0)
return log_error_errno(r, "Failed to parse hop limit: %m");
break;
OPTION_LONG("managed", "BOOL", "Managed flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse managed flag: %m");
SET_FLAG(arg_ra_flags, ND_RA_FLAG_MANAGED, r);
break;
OPTION_LONG("other", "BOOL", "Other flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse other flag: %m");
SET_FLAG(arg_ra_flags, ND_RA_FLAG_OTHER, r);
break;
OPTION_LONG("home-agent", "BOOL", "Home-agent flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse home-agent flag: %m");
SET_FLAG(arg_ra_flags, ND_RA_FLAG_HOME_AGENT, r);
break;
OPTION_LONG("preference", "PREF", "Preference"):
- r = parse_preference(arg);
+ r = parse_preference(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse preference: %m");
arg_preference = r;
break;
OPTION_LONG("lifetime", "SECS", "Lifetime"):
- r = parse_sec(arg, &arg_lifetime);
+ r = parse_sec(opts.arg, &arg_lifetime);
if (r < 0)
return log_error_errno(r, "Failed to parse lifetime: %m");
break;
OPTION_LONG("reachable-time", "SECS", "Reachable time"):
- r = parse_sec(arg, &arg_reachable);
+ r = parse_sec(opts.arg, &arg_reachable);
if (r < 0)
return log_error_errno(r, "Failed to parse reachable time: %m");
break;
OPTION_LONG("retransmit-timer", "SECS", "Retransmit timer"):
- r = parse_sec(arg, &arg_retransmit);
+ r = parse_sec(opts.arg, &arg_retransmit);
if (r < 0)
return log_error_errno(r, "Failed to parse retransmit timer: %m");
break;
OPTION_GROUP("Neighbor Advertisement"): {}
OPTION_LONG("is-router", "BOOL", "Router flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse is-router flag: %m");
SET_FLAG(arg_na_flags, ND_NA_FLAG_ROUTER, r);
break;
OPTION_LONG("is-solicited", "BOOL", "Solicited flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse is-solicited flag: %m");
SET_FLAG(arg_na_flags, ND_NA_FLAG_SOLICITED, r);
break;
OPTION_LONG("is-override", "BOOL", "Override flag"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse is-override flag: %m");
SET_FLAG(arg_na_flags, ND_NA_FLAG_OVERRIDE, r);
OPTION_GROUP("Neighbor Solicit/Advertisement and Redirect"): {}
OPTION_LONG("target-address", "ADDRESS", "Target address"):
- r = in_addr_from_string(AF_INET6, arg, &arg_target_address);
+ r = in_addr_from_string(AF_INET6, opts.arg, &arg_target_address);
if (r < 0)
return log_error_errno(r, "Failed to parse target address: %m");
break;
OPTION_GROUP("Redirect"): {}
OPTION_LONG("redirect-destination", "ADDRESS", "Redirect destination address"):
- r = in_addr_from_string(AF_INET6, arg, &arg_redirect_destination);
+ r = in_addr_from_string(AF_INET6, opts.arg, &arg_redirect_destination);
if (r < 0)
return log_error_errno(r, "Failed to parse destination address: %m");
break;
OPTION_GROUP("NDisc Options"): {}
OPTION_LONG("source-ll-address", "BOOL", "Include source link-layer address"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse source LL address option: %m");
arg_set_source_mac = r;
break;
OPTION_LONG("target-ll-address", "ADDRESS", "Target link-layer address"):
- r = parse_ether_addr(arg, &arg_target_mac);
+ r = parse_ether_addr(opts.arg, &arg_target_mac);
if (r < 0)
return log_error_errno(r, "Failed to parse target LL address option: %m");
arg_set_target_mac = true;
_cleanup_free_ void *p = NULL;
size_t len;
- r = unbase64mem(arg, &p, &len);
+ r = unbase64mem(opts.arg, &p, &len);
if (r < 0)
return log_error_errno(r, "Failed to parse redirected header: %m");
}
OPTION_LONG("mtu", "MTU", "MTU"):
- r = safe_atou32(arg, &arg_mtu);
+ r = safe_atou32(opts.arg, &arg_mtu);
if (r < 0)
return log_error_errno(r, "Failed to parse MTU: %m");
arg_set_mtu = true;
test_setup_logging(LOG_DEBUG);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP: {
"Offset at which to start corrupting the journal "
"(default: random offset is picked, unless --sequential is used"
" - in that case we use 0 + iteration)"):
- r = safe_atou64(arg, &start_offset);
+ r = safe_atou64(opts.arg, &start_offset);
if (r < 0)
return log_error_errno(r, "Invalid starting offset: %m");
break;
OPTION_LONG("iterations", "ITER",
"Number of iterations to perform before exiting (default: 100)"):
- r = safe_atou64(arg, &iterations);
+ r = safe_atou64(opts.arg, &iterations);
if (r < 0)
return log_error_errno(r, "Invalid value for iterations: %m");
break;
OPTION_LONG("corrupt-step", "STEP",
"Corrupt every n-th byte starting from OFFSET (default: 31)"):
- r = safe_atou64(arg, &corrupt_step);
+ r = safe_atou64(opts.arg, &corrupt_step);
if (r < 0)
return log_error_errno(r, "Invalid value for corrupt-step: %m");
break;
OPTION_LONG("iteration-step", "STEP", "Iteration step (default: 1)"):
- r = safe_atou64(arg, &iteration_step);
+ r = safe_atou64(opts.arg, &iteration_step);
if (r < 0)
return log_error_errno(r, "Invalid value for iteration-step: %m");
break;
OPTION_LONG("run-one", "OFFSET",
"Single shot mode for reproducing issues. "
"Takes the same offset as --start-offset= and does only one iteration"):
- r = safe_atou64(arg, &start_offset);
+ r = safe_atou64(opts.arg, &start_offset);
if (r < 0)
return log_error_errno(r, "Invalid offset: %m");
assert(syspath);
assert(subsystem);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return 0;
OPTION('p', "syspath", "PATH", "Syspath to test"):
- *syspath = arg;
+ *syspath = opts.arg;
break;
OPTION('s', "subsystem", "SUBSYSTEM", "Subsystem to enumerate"):
- *subsystem = arg;
+ *subsystem = opts.arg;
break;
OPTION('d', "debug", NULL, "Enable debug logging"):
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
"(shutdown, sleep, idle, handle-power-key, "
"handle-suspend-key, handle-hibernate-key, "
"handle-lid-switch)"):
- arg_what = arg;
+ arg_what = opts.arg;
break;
OPTION_LONG("who", "STRING",
"A descriptive string who is inhibiting"):
- arg_who = arg;
+ arg_who = opts.arg;
break;
OPTION_LONG("why", "STRING",
"A descriptive string why is being inhibited"):
- arg_why = arg;
+ arg_why = opts.arg;
break;
OPTION_LONG("mode", "MODE", "One of block, block-weak, or delay"):
- arg_mode = arg;
+ arg_mode = opts.arg;
break;
OPTION_LONG("list", NULL, "List active inhibitors"):
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (arg_action == ACTION_INHIBIT && strv_isempty(args))
arg_action = ACTION_LIST;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_GROUP("Options"): {}
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, true, &arg_root);
+ r = parse_path_argument(opts.arg, true, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, false, &arg_image);
+ r = parse_path_argument(opts.arg, false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Extraneous arguments");
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
"Specify a boot phase to sign for"): {
char *n;
- n = normalize_phase(arg);
+ n = normalize_phase(opts.arg);
if (!n)
return log_oom();
if (r < 0)
return r;
- implementation = sym_EVP_get_digestbyname(arg);
+ implementation = sym_EVP_get_digestbyname(opts.arg);
if (!implementation)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown bank '%s', refusing.", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown bank '%s', refusing.", opts.arg);
if (strv_extend(&arg_banks, sym_EVP_MD_get0_name(implementation)) < 0)
return log_oom();
"Use specified TPM2 device"): {
_cleanup_free_ char *device = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(/* legend= */ true, /* quiet= */ false);
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
}
OPTION_COMMON_PRIVATE_KEY("Private key (PEM) to sign with"):
- r = free_and_strdup_warn(&arg_private_key, arg);
+ r = free_and_strdup_warn(&arg_private_key, opts.arg);
if (r < 0)
return r;
OPTION_COMMON_PRIVATE_KEY_SOURCE:
r = parse_openssl_key_source_argument(
- arg,
+ opts.arg,
&arg_private_key_source,
&arg_private_key_source_type);
if (r < 0)
OPTION_LONG("public-key", "KEY",
"Public key (PEM) to validate against"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_public_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_public_key);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE("PEM certificate to use for signing"):
- r = free_and_strdup_warn(&arg_certificate, arg);
+ r = free_and_strdup_warn(&arg_certificate, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE_SOURCE:
r = parse_openssl_certificate_source_argument(
- arg,
+ opts.arg,
&arg_certificate_source,
&arg_certificate_source_type);
if (r < 0)
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
OPTION_LONG("append", "PATH",
"Load specified JSON signature, and append new signature to it"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_append);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_append);
if (r < 0)
return r;
"Path to EFI firmware file (→ .efifw)"): {}
/* Make sure that if new sections are added, the list here is updated. */
assert_cc(UNIFIED_SECTION_EFIFW + 1 == _UNIFIED_SECTION_MAX);
- assert(opt->data < _UNIFIED_SECTION_MAX);
+ assert(opts.opt->data < _UNIFIED_SECTION_MAX);
- r = parse_path_argument(arg, /* suppress_root= */ false, arg_sections + opt->data);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, arg_sections + opts.opt->data);
if (r < 0)
return r;
break;
log_debug("Measuring boot phases: %s", j);
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* arg= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("kernel", "BOOL", "Mute kernel log output"):
- r = parse_boolean_argument("--kernel=", arg, &arg_mute_kernel);
+ r = parse_boolean_argument("--kernel=", opts.arg, &arg_mute_kernel);
if (r < 0)
return r;
break;
OPTION_LONG("pid1", "BOOL", "Mute PID 1 status output"):
- r = parse_boolean_argument("--pid1=", arg, &arg_mute_pid1);
+ r = parse_boolean_argument("--pid1=", opts.arg, &arg_mute_pid1);
if (r < 0)
return r;
break;
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("root", "PATH",
"Operate on an alternate filesystem root"):
- arg_root = arg;
+ arg_root = opts.arg;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
"Set main PID of daemon"):
pidref_done(&arg_pid);
- if (isempty(arg) || streq(arg, "auto"))
+ if (isempty(opts.arg) || streq(opts.arg, "auto"))
r = pidref_parent_if_applicable(&arg_pid);
- else if (streq(arg, "parent"))
+ else if (streq(opts.arg, "parent"))
r = pidref_set_parent(&arg_pid);
- else if (streq(arg, "self"))
+ else if (streq(opts.arg, "self"))
r = pidref_set_self(&arg_pid);
else
- r = pidref_set_pidstr(&arg_pid, arg);
+ r = pidref_set_pidstr(&arg_pid, opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to refer to --pid='%s': %m", arg);
+ return log_error_errno(r, "Failed to refer to --pid='%s': %m", opts.arg);
break;
OPTION_LONG("uid", "USER", "Set user to send from"):
- r = get_user_creds(&arg, &arg_uid, &arg_gid, NULL, NULL, 0);
+ r = get_user_creds(&opts.arg, &arg_uid, &arg_gid, NULL, NULL, 0);
if (r == -ESRCH) /* If the user doesn't exist, then accept it anyway as numeric */
- r = parse_uid(arg, &arg_uid);
+ r = parse_uid(opts.arg, &arg_uid);
if (r < 0)
- return log_error_errno(r, "Can't resolve user %s: %m", arg);
+ return log_error_errno(r, "Can't resolve user %s: %m", opts.arg);
break;
OPTION_LONG("status", "TEXT", "Set status text"):
- arg_status = arg;
+ arg_status = opts.arg;
break;
OPTION_LONG("booted", NULL, "Check if the system was booted up with systemd"):
OPTION_LONG("fd", "FD", "Pass specified file descriptor along with the message"): {
_cleanup_close_ int owned_fd = -EBADF;
- int fdnr = parse_fd(arg);
+ int fdnr = parse_fd(opts.arg);
if (fdnr < 0)
- return log_error_errno(fdnr, "Failed to parse file descriptor: %s", arg);
+ return log_error_errno(fdnr, "Failed to parse file descriptor: %s", opts.arg);
if (!passed) {
/* Take possession of all passed fds */
}
OPTION_LONG("fdname", "NAME", "Name to assign to passed file descriptors"):
- if (!fdname_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "File descriptor name invalid: %s", arg);
+ if (!fdname_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "File descriptor name invalid: %s", opts.arg);
- if (free_and_strdup(&arg_fdname, arg) < 0)
+ if (free_and_strdup(&arg_fdname, opts.arg) < 0)
return log_oom();
break;
bool have_env = arg_ready || arg_stopping || arg_reloading || arg_status || pidref_is_set(&arg_pid) || !fdset_isempty(arg_fds);
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
switch (arg_action) {
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, /* on_error= */ return c) {
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c) {
switch (c) {
OPTION_COMMON_HELP:
* trusted → read files, do not override cmdline, trust all
*/
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0) {
- if (streq(arg, "trusted")) {
+ if (streq(opts.arg, "trusted")) {
mask_all_settings = false;
mask_no_settings = false;
arg_settings_trusted = true;
- } else if (streq(arg, "override")) {
+ } else if (streq(opts.arg, "override")) {
mask_all_settings = false;
mask_no_settings = true;
arg_settings_trusted = -1;
} else
- return log_error_errno(r, "Failed to parse --settings= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --settings= argument: %s", opts.arg);
} else if (r > 0) {
/* yes */
mask_all_settings = false;
OPTION_GROUP("Image"): {}
OPTION('D', "directory", "PATH", "Root directory for the container"):
- r = parse_path_argument(arg, false, &arg_directory);
+ r = parse_path_argument(opts.arg, false, &arg_directory);
if (r < 0)
return r;
arg_settings_mask |= SETTING_DIRECTORY;
OPTION_LONG("template", "PATH",
"Initialize root directory from template directory, if missing"):
- r = parse_path_argument(arg, false, &arg_template);
+ r = parse_path_argument(opts.arg, false, &arg_template);
if (r < 0)
return r;
arg_settings_mask |= SETTING_DIRECTORY;
OPTION('i', "image", "PATH",
"Root file system disk image (or device node) for the container"):
- r = parse_path_argument(arg, false, &arg_image);
+ r = parse_path_argument(opts.arg, false, &arg_image);
if (r < 0)
return r;
arg_settings_mask |= SETTING_DIRECTORY;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("mstack", "PATH", /* help= */ NULL):
- r = parse_path_argument(arg, false, &arg_mstack);
+ r = parse_path_argument(opts.arg, false, &arg_mstack);
if (r < 0)
return r;
arg_settings_mask |= SETTING_DIRECTORY;
break;
OPTION_LONG("oci-bundle", "PATH", "OCI bundle directory"):
- r = parse_path_argument(arg, false, &arg_oci_bundle);
+ r = parse_path_argument(opts.arg, false, &arg_oci_bundle);
if (r < 0)
return r;
break;
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "volatile", "MODE", "Run the system in volatile mode"):
- if (!arg)
+ if (!opts.arg)
arg_volatile_mode = VOLATILE_YES;
- else if (streq(arg, "help"))
+ else if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(volatile_mode, VolatileMode, _VOLATILE_MODE_MAX);
else {
VolatileMode m;
- m = volatile_mode_from_string(arg);
+ m = volatile_mode_from_string(opts.arg);
if (m < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Failed to parse --volatile= argument: %s", arg);
+ "Failed to parse --volatile= argument: %s", opts.arg);
else
arg_volatile_mode = m;
}
OPTION_LONG("root-hash", "HASH", "Specify verity root hash for root disk image"): {
_cleanup_(iovec_done) struct iovec k = {};
- r = unhexmem(arg, &k.iov_base, &k.iov_len);
+ r = unhexmem(opts.arg, &k.iov_base, &k.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to parse root hash: %s", arg);
+ return log_error_errno(r, "Failed to parse root hash: %s", opts.arg);
if (k.iov_len < sizeof(sd_id128_t))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Root hash must be at least 128-bit long: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Root hash must be at least 128-bit long: %s", opts.arg);
iovec_done(&arg_verity_settings.root_hash);
arg_verity_settings.root_hash = TAKE_STRUCT(k);
_cleanup_(iovec_done) struct iovec p = {};
const char *value;
- if ((value = startswith(arg, "base64:"))) {
+ if ((value = startswith(opts.arg, "base64:"))) {
r = unbase64mem(value, &p.iov_base, &p.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to parse root hash signature '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse root hash signature '%s': %m", opts.arg);
} else {
- r = read_full_file(arg, (char**) &p.iov_base, &p.iov_len);
+ r = read_full_file(opts.arg, (char**) &p.iov_base, &p.iov_len);
if (r < 0)
- return log_error_errno(r, "Failed to parse root hash signature file '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse root hash signature file '%s': %m", opts.arg);
}
iovec_done(&arg_verity_settings.root_hash_sig);
}
OPTION_LONG("verity-data", "PATH", "Specify hash device for verity"):
- r = parse_path_argument(arg, false, &arg_verity_settings.data_path);
+ r = parse_path_argument(opts.arg, false, &arg_verity_settings.data_path);
if (r < 0)
return r;
break;
OPTION_LONG("pivot-root", "PATH[:PATH]",
"Pivot root to given directory in the container"):
- r = pivot_root_parse(&arg_pivot_root_new, &arg_pivot_root_old, arg);
+ r = pivot_root_parse(&arg_pivot_root_new, &arg_pivot_root_old, opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --pivot-root= argument %s: %m", arg);
+ return log_error_errno(r, "Failed to parse --pivot-root= argument %s: %m", opts.arg);
arg_settings_mask |= SETTING_PIVOT_ROOT;
break;
OPTION_LONG("chdir", "PATH", "Set working directory in the container"): {
_cleanup_free_ char *wd = NULL;
- if (!path_is_absolute(arg))
+ if (!path_is_absolute(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Working directory %s is not an absolute path.", arg);
+ "Working directory %s is not an absolute path.", opts.arg);
- r = path_simplify_alloc(arg, &wd);
+ r = path_simplify_alloc(opts.arg, &wd);
if (r < 0)
- return log_error_errno(r, "Failed to simplify path %s: %m", arg);
+ return log_error_errno(r, "Failed to simplify path %s: %m", opts.arg);
if (!path_is_normalized(wd))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Working directory path is not normalized: %s", wd);
}
OPTION('E', "setenv", "NAME[=VALUE]", "Pass an environment variable to PID 1"):
- r = strv_env_replace_strdup_passthrough(&arg_setenv, arg);
+ r = strv_env_replace_strdup_passthrough(&arg_setenv, opts.arg);
if (r < 0)
- return log_error_errno(r, "Cannot assign environment variable %s: %m", arg);
+ return log_error_errno(r, "Cannot assign environment variable %s: %m", opts.arg);
arg_settings_mask |= SETTING_ENVIRONMENT;
break;
OPTION('u', "uid", "USER", "Run the command under specified user or UID"):
- r = free_and_strdup(&arg_user, arg);
+ r = free_and_strdup(&arg_user, opts.arg);
if (r < 0)
return log_oom();
arg_settings_mask |= SETTING_USER;
break;
OPTION_LONG("kill-signal", "SIGNAL", "Select signal to use for shutting down PID 1"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(signal, int, _NSIG);
- arg_kill_signal = signal_from_string(arg);
+ arg_kill_signal = signal_from_string(opts.arg);
if (arg_kill_signal < 0)
- return log_error_errno(arg_kill_signal, "Cannot parse signal: %s", arg);
+ return log_error_errno(arg_kill_signal, "Cannot parse signal: %s", opts.arg);
arg_settings_mask |= SETTING_KILL_SIGNAL;
break;
OPTION_LONG("notify-ready", "BOOLEAN", "Receive notifications from the child init process"):
- r = parse_boolean_argument("--notify-ready=", arg, &arg_notify_ready);
+ r = parse_boolean_argument("--notify-ready=", opts.arg, &arg_notify_ready);
if (r < 0)
return r;
arg_settings_mask |= SETTING_NOTIFY_READY;
break;
OPTION_LONG("suppress-sync", "BOOLEAN", "Suppress any form of disk data synchronization"):
- r = parse_boolean_argument("--suppress-sync=", arg, &arg_suppress_sync);
+ r = parse_boolean_argument("--suppress-sync=", opts.arg, &arg_suppress_sync);
if (r < 0)
return r;
arg_settings_mask |= SETTING_SUPPRESS_SYNC;
OPTION_GROUP("System Identity"): {}
OPTION('M', "machine", "NAME", "Set the machine name for the container"):
- if (!isempty(arg) && !hostname_is_valid(arg, /* flags= */ 0))
+ if (!isempty(opts.arg) && !hostname_is_valid(opts.arg, /* flags= */ 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Invalid machine name: %s", arg);
- r = free_and_strdup_warn(&arg_machine, arg);
+ "Invalid machine name: %s", opts.arg);
+ r = free_and_strdup_warn(&arg_machine, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("hostname", "NAME", "Override the hostname for the container"):
- if (!isempty(arg) && !hostname_is_valid(arg, /* flags= */ 0))
+ if (!isempty(opts.arg) && !hostname_is_valid(opts.arg, /* flags= */ 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Invalid hostname: %s", arg);
- r = free_and_strdup_warn(&arg_hostname, arg);
+ "Invalid hostname: %s", opts.arg);
+ r = free_and_strdup_warn(&arg_hostname, opts.arg);
if (r < 0)
return r;
arg_settings_mask |= SETTING_HOSTNAME;
break;
OPTION_LONG("uuid", "UUID", "Set a specific machine UUID for the container"):
- r = id128_from_string_nonzero(arg, &arg_uuid);
+ r = id128_from_string_nonzero(opts.arg, &arg_uuid);
if (r == -ENXIO)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Machine UUID may not be all zeroes.");
if (r < 0)
- return log_error_errno(r, "Invalid UUID: %s", arg);
+ return log_error_errno(r, "Invalid UUID: %s", opts.arg);
arg_settings_mask |= SETTING_MACHINE_ID;
break;
OPTION('S', "slice", "SLICE", "Place the container in the specified slice"): {
_cleanup_free_ char *mangled = NULL;
- r = unit_name_mangle_with_suffix(arg, NULL, UNIT_NAME_MANGLE_WARN, ".slice", &mangled);
+ r = unit_name_mangle_with_suffix(opts.arg, NULL, UNIT_NAME_MANGLE_WARN, ".slice", &mangled);
if (r < 0)
return log_oom();
}
OPTION_LONG("property", "NAME=VALUE", "Set scope unit property"):
- if (strv_extend(&arg_property, arg) < 0)
+ if (strv_extend(&arg_property, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("register", "BOOLEAN", "Register container as machine"):
- r = parse_tristate_argument_with_auto("--register=", arg, &arg_register);
+ r = parse_tristate_argument_with_auto("--register=", opts.arg, &arg_register);
if (r < 0)
return r;
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "private-users", "MODE",
"Run within user namespace, configure UID/GID range"):
- r = parse_private_users(arg, &arg_userns_mode, &arg_uid_shift, &arg_uid_range);
+ r = parse_private_users(opts.arg, &arg_userns_mode, &arg_uid_shift, &arg_uid_range);
if (r < 0)
return r;
arg_settings_mask |= SETTING_USERNS;
OPTION_LONG("private-users-ownership", "MODE",
"Adjust ('chown') or map ('map') OS tree ownership to private UID/GID range"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(user_namespace_ownership, UserNamespaceOwnership, _USER_NAMESPACE_OWNERSHIP_MAX);
- arg_userns_ownership = user_namespace_ownership_from_string(arg);
+ arg_userns_ownership = user_namespace_ownership_from_string(opts.arg);
if (arg_userns_ownership < 0)
- return log_error_errno(arg_userns_ownership, "Cannot parse --private-users-ownership= value: %s", arg);
+ return log_error_errno(arg_userns_ownership, "Cannot parse --private-users-ownership= value: %s", opts.arg);
arg_settings_mask |= SETTING_USERNS;
break;
OPTION_LONG("private-users-delegate", "N",
"Delegate N additional 64K UID/GID ranges for use by nested containers"):
- r = safe_atou(arg, &arg_delegate_container_ranges);
+ r = safe_atou(opts.arg, &arg_delegate_container_ranges);
if (r < 0)
- return log_error_errno(r, "Failed to parse --private-users-delegate= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --private-users-delegate= parameter: %s", opts.arg);
arg_settings_mask |= SETTING_USERNS;
break;
OPTION_LONG("network-interface", "HOSTIF[:CONTAINERIF]",
"Assign an existing network interface to the container"):
- r = interface_pair_parse(&arg_network_interfaces, arg);
+ r = interface_pair_parse(&arg_network_interfaces, opts.arg);
if (r < 0)
return r;
arg_private_network = true;
OPTION_LONG("network-macvlan", "HOSTIF[:CONTAINERIF]",
"Create a macvlan network interface based on an existing network interface to the container"):
- r = macvlan_pair_parse(&arg_network_macvlan, arg);
+ r = macvlan_pair_parse(&arg_network_macvlan, opts.arg);
if (r < 0)
return r;
arg_private_network = true;
OPTION_LONG("network-ipvlan", "HOSTIF[:CONTAINERIF]",
"Create an ipvlan network interface based on an existing network interface to the container"):
- r = ipvlan_pair_parse(&arg_network_ipvlan, arg);
+ r = ipvlan_pair_parse(&arg_network_ipvlan, opts.arg);
if (r < 0)
return r;
arg_private_network = true;
OPTION_LONG("network-veth-extra", "HOSTIF[:CONTAINERIF]",
"Add an additional virtual Ethernet link between host and container"):
- r = veth_extra_parse(&arg_network_veth_extra, arg);
+ r = veth_extra_parse(&arg_network_veth_extra, opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --network-veth-extra= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --network-veth-extra= parameter: %s", opts.arg);
arg_private_network = true;
arg_settings_mask |= SETTING_NETWORK;
break;
OPTION_LONG("network-bridge", "INTERFACE",
"Add a virtual Ethernet connection to the container and attach it to an existing bridge on the host"):
- if (!ifname_valid(arg))
+ if (!ifname_valid(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Bridge interface name not valid: %s", arg);
- r = free_and_strdup(&arg_network_bridge, arg);
+ "Bridge interface name not valid: %s", opts.arg);
+ r = free_and_strdup(&arg_network_bridge, opts.arg);
if (r < 0)
return log_oom();
arg_network_veth = true;
"Similar, but attach the new interface to an automatically managed bridge interface"): {
_cleanup_free_ char *j = NULL;
- j = strjoin("vz-", arg);
+ j = strjoin("vz-", opts.arg);
if (!j)
return log_oom();
OPTION_LONG("network-namespace-path", "PATH",
"Set network namespace to the one represented by the specified kernel namespace file node"):
- r = parse_path_argument(arg, false, &arg_network_namespace_path);
+ r = parse_path_argument(opts.arg, false, &arg_network_namespace_path);
if (r < 0)
return r;
arg_settings_mask |= SETTING_NETWORK;
OPTION('p', "port", "[PROTOCOL:]HOSTPORT[:CONTAINERPORT]",
"Expose a container IP port on the host"):
- r = expose_port_parse(&arg_expose_ports, arg);
+ r = expose_port_parse(&arg_expose_ports, opts.arg);
if (r == -EEXIST)
- return log_error_errno(r, "Duplicate port specification: %s", arg);
+ return log_error_errno(r, "Duplicate port specification: %s", opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse host port %s: %m", arg);
+ return log_error_errno(r, "Failed to parse host port %s: %m", opts.arg);
arg_settings_mask |= SETTING_EXPOSE_PORTS;
break;
OPTION_LONG("drop-capability", "CAP",
"Drop the specified capability from the default set"): {
uint64_t m;
- r = parse_capability_spec(arg, &m);
+ r = parse_capability_spec(opts.arg, &m);
if (r <= 0)
return r;
- if (streq(opt->long_code, "capability"))
+ if (streq(opts.opt->long_code, "capability"))
plus |= m;
else
minus |= m;
OPTION_LONG("ambient-capability", "CAP",
"Sets the specified capability for the started process"): {
uint64_t m;
- r = parse_capability_spec(arg, &m);
+ r = parse_capability_spec(opts.arg, &m);
if (r <= 0)
return r;
arg_caps_ambient |= m;
OPTION_LONG("no-new-privileges", "BOOL",
"Set PR_SET_NO_NEW_PRIVS flag for container payload"):
- r = parse_boolean_argument("--no-new-privileges=", arg, &arg_no_new_privileges);
+ r = parse_boolean_argument("--no-new-privileges=", opts.arg, &arg_no_new_privileges);
if (r < 0)
return r;
arg_settings_mask |= SETTING_NO_NEW_PRIVILEGES;
bool negative;
const char *items;
- negative = arg[0] == '~';
- items = negative ? arg + 1 : arg;
+ negative = opts.arg[0] == '~';
+ items = negative ? opts.arg + 1 : opts.arg;
for (;;) {
_cleanup_free_ char *word = NULL;
OPTION('Z', "selinux-context", "SECLABEL",
"Set the SELinux security context to be used by processes in the container"):
- arg_selinux_context = arg;
+ arg_selinux_context = opts.arg;
break;
OPTION('L', "selinux-apifs-context", "SECLABEL",
"Set the SELinux security context to be used by API/tmpfs file systems in the container"):
- arg_selinux_apifs_context = arg;
+ arg_selinux_apifs_context = opts.arg;
break;
OPTION_GROUP("Resources"): {}
_cleanup_free_ char *name = NULL;
int rl;
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(rlimit, int, _RLIMIT_MAX);
- eq = strchr(arg, '=');
+ eq = strchr(opts.arg, '=');
if (!eq)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"--rlimit= expects an '=' assignment.");
- name = strndup(arg, eq - arg);
+ name = strndup(opts.arg, eq - opts.arg);
if (!name)
return log_oom();
}
OPTION_LONG("oom-score-adjust", "VALUE", "Adjust the OOM score value for the payload"):
- r = parse_oom_score_adjust(arg, &arg_oom_score_adjust);
+ r = parse_oom_score_adjust(opts.arg, &arg_oom_score_adjust);
if (r < 0)
- return log_error_errno(r, "Failed to parse --oom-score-adjust= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --oom-score-adjust= parameter: %s", opts.arg);
arg_oom_score_adjust_set = true;
arg_settings_mask |= SETTING_OOM_SCORE_ADJUST;
break;
OPTION_LONG("cpu-affinity", "CPUS", "Adjust the CPU affinity of the container"): {
CPUSet cpuset;
- r = parse_cpu_set(arg, &cpuset);
+ r = parse_cpu_set(opts.arg, &cpuset);
if (r < 0)
- return log_error_errno(r, "Failed to parse CPU affinity mask %s: %m", arg);
+ return log_error_errno(r, "Failed to parse CPU affinity mask %s: %m", opts.arg);
cpu_set_done_and_replace(arg_cpu_set, cpuset);
arg_settings_mask |= SETTING_CPU_AFFINITY;
}
OPTION_LONG("personality", "ARCH", "Pick personality for this container"):
- arg_personality = personality_from_string(arg);
+ arg_personality = personality_from_string(opts.arg);
if (arg_personality == PERSONALITY_INVALID)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Unknown or unsupported personality '%s'.", arg);
+ "Unknown or unsupported personality '%s'.", opts.arg);
arg_settings_mask |= SETTING_PERSONALITY;
break;
OPTION_GROUP("Integration"): {}
OPTION_LONG("resolv-conf", "MODE", "Select mode of /etc/resolv.conf initialization"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(resolv_conf_mode, ResolvConfMode, _RESOLV_CONF_MODE_MAX);
- arg_resolv_conf = resolv_conf_mode_from_string(arg);
+ arg_resolv_conf = resolv_conf_mode_from_string(opts.arg);
if (arg_resolv_conf < 0)
return log_error_errno(arg_resolv_conf,
- "Failed to parse /etc/resolv.conf mode: %s", arg);
+ "Failed to parse /etc/resolv.conf mode: %s", opts.arg);
arg_settings_mask |= SETTING_RESOLV_CONF;
break;
OPTION_LONG("timezone", "MODE", "Select mode of /etc/localtime initialization"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(timezone_mode, TimezoneMode, _TIMEZONE_MODE_MAX);
- arg_timezone = timezone_mode_from_string(arg);
+ arg_timezone = timezone_mode_from_string(opts.arg);
if (arg_timezone < 0)
return log_error_errno(arg_timezone,
- "Failed to parse /etc/localtime mode: %s", arg);
+ "Failed to parse /etc/localtime mode: %s", opts.arg);
arg_settings_mask |= SETTING_TIMEZONE;
break;
OPTION_LONG("link-journal", "MODE",
"Link up guest journal, one of no, auto, guest, host, try-guest, try-host"):
- r = parse_link_journal(arg, &arg_link_journal, &arg_link_journal_try);
+ r = parse_link_journal(opts.arg, &arg_link_journal, &arg_link_journal_try);
if (r < 0)
- return log_error_errno(r, "Failed to parse link journal mode %s", arg);
+ return log_error_errno(r, "Failed to parse link journal mode %s", opts.arg);
arg_settings_mask |= SETTING_LINK_JOURNAL;
break;
break;
OPTION_LONG("forward-journal", "FILE|DIR", "Forward the container's journal to the host"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_forward_journal);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_forward_journal);
if (r < 0)
return r;
break;
OPTION_LONG("forward-journal-max-use", "BYTES", "Maximum disk space for forwarded journal"):
- r = parse_size(arg, 1024, &arg_forward_journal_max_use);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_max_use);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-use= value: %s", optarg);
break;
OPTION_LONG("forward-journal-keep-free", "BYTES", "Minimum disk space to keep free"):
- r = parse_size(arg, 1024, &arg_forward_journal_keep_free);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_keep_free);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-keep-free= value: %s", optarg);
break;
OPTION_LONG("forward-journal-max-file-size", "BYTES", "Maximum size of individual journal files"):
- r = parse_size(arg, 1024, &arg_forward_journal_max_file_size);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_max_file_size);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-file-size= value: %s", optarg);
break;
OPTION_LONG("forward-journal-max-files", "N", "Maximum number of journal files to keep"):
- r = safe_atou64(arg, &arg_forward_journal_max_files);
+ r = safe_atou64(opts.arg, &arg_forward_journal_max_files);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-files= value: %s", optarg);
break;
"Bind mount a file or directory from the host into the container"): {}
OPTION_LONG("bind-ro", "PATH[:PATH[:OPTIONS]]",
"Similar, but creates a read-only bind mount"):
- r = bind_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, arg,
- streq(opt->long_code, "bind-ro"));
+ r = bind_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, opts.arg,
+ streq(opts.opt->long_code, "bind-ro"));
if (r < 0)
- return log_error_errno(r, "Failed to parse --bind(-ro)= argument %s: %m", arg);
+ return log_error_errno(r, "Failed to parse --bind(-ro)= argument %s: %m", opts.arg);
arg_settings_mask |= SETTING_CUSTOM_MOUNTS;
break;
OPTION_LONG("inaccessible", "PATH",
"Over-mount file node with inaccessible node to mask it"):
- r = inaccessible_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, arg);
+ r = inaccessible_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --inaccessible= argument %s: %m", arg);
+ return log_error_errno(r, "Failed to parse --inaccessible= argument %s: %m", opts.arg);
arg_settings_mask |= SETTING_CUSTOM_MOUNTS;
break;
OPTION_LONG("tmpfs", "PATH:[OPTIONS]",
"Mount an empty tmpfs to the specified directory"):
- r = tmpfs_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, arg);
+ r = tmpfs_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --tmpfs= argument %s: %m", arg);
+ return log_error_errno(r, "Failed to parse --tmpfs= argument %s: %m", opts.arg);
arg_settings_mask |= SETTING_CUSTOM_MOUNTS;
break;
"Create an overlay mount from the host to the container"): {}
OPTION_LONG("overlay-ro", "PATH[:PATH...]:PATH",
"Similar, but creates a read-only overlay mount"):
- r = overlay_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, arg,
- streq(opt->long_code, "overlay-ro"));
+ r = overlay_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, opts.arg,
+ streq(opts.opt->long_code, "overlay-ro"));
if (r == -EADDRNOTAVAIL)
return log_error_errno(r, "--overlay(-ro)= needs at least two colon-separated directories specified.");
if (r < 0)
- return log_error_errno(r, "Failed to parse --overlay(-ro)= argument %s: %m", arg);
+ return log_error_errno(r, "Failed to parse --overlay(-ro)= argument %s: %m", opts.arg);
arg_settings_mask |= SETTING_CUSTOM_MOUNTS;
break;
OPTION_LONG("bind-user", "NAME", "Bind user from host to container"):
- if (!valid_user_group_name(arg, 0))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid user name to bind: %s", arg);
- if (strv_extend(&arg_bind_user, arg) < 0)
+ if (!valid_user_group_name(opts.arg, 0))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid user name to bind: %s", opts.arg);
+ if (strv_extend(&arg_bind_user, opts.arg) < 0)
return log_oom();
arg_settings_mask |= SETTING_BIND_USER;
break;
"Configure the shell to use for --bind-user= users"): {
bool copy = false;
char *sh = NULL;
- r = parse_user_shell(arg, &sh, ©);
+ r = parse_user_shell(opts.arg, &sh, ©);
if (r == -ENOMEM)
return log_oom();
if (r < 0)
- return log_error_errno(r, "Invalid user shell to bind: %s", arg);
+ return log_error_errno(r, "Invalid user shell to bind: %s", opts.arg);
free_and_replace(arg_bind_user_shell, sh);
arg_bind_user_shell_copy = copy;
OPTION_LONG("bind-user-group", "GROUP",
"Add an auxiliary group to --bind-user= users"):
- if (!valid_user_group_name(arg, /* flags= */ 0))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid bind user auxiliary group name: %s", arg);
- if (strv_extend(&arg_bind_user_groups, arg) < 0)
+ if (!valid_user_group_name(opts.arg, /* flags= */ 0))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid bind user auxiliary group name: %s", opts.arg);
+ if (strv_extend(&arg_bind_user_groups, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("console", "MODE",
"Select how stdin/stdout/stderr and /dev/console are set up for the container"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(console_mode, ConsoleMode, _CONSOLE_MODE_MAX);
- arg_console_mode = console_mode_from_string(arg);
+ arg_console_mode = console_mode_from_string(opts.arg);
if (arg_console_mode < 0)
- return log_error_errno(arg_console_mode, "Unknown console mode: %s", arg);
+ return log_error_errno(arg_console_mode, "Unknown console mode: %s", opts.arg);
arg_settings_mask |= SETTING_CONSOLE_MODE;
break;
break;
OPTION_LONG("background", "COLOR", "Set ANSI color for background"):
- r = parse_background_argument(arg, &arg_background);
+ r = parse_background_argument(opts.arg, &arg_background);
if (r < 0)
return r;
break;
OPTION_LONG("set-credential", "ID:VALUE",
"Pass a credential with literal value to container"):
- r = machine_credential_set(&arg_credentials, arg);
+ r = machine_credential_set(&arg_credentials, opts.arg);
if (r < 0)
return r;
arg_settings_mask |= SETTING_CREDENTIALS;
OPTION_LONG("load-credential", "ID:PATH",
"Load credential to pass to container from file or AF_UNIX stream socket"):
- r = machine_credential_load(&arg_credentials, arg);
+ r = machine_credential_load(&arg_credentials, opts.arg);
if (r < 0)
return r;
arg_settings_mask |= SETTING_CREDENTIALS;
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "user", "NAME", "Run in the user service manager scope"):
- if (arg)
+ if (opts.arg)
/* --user=NAME is a deprecated alias for --uid=NAME */
log_warning("--user=NAME is deprecated, use --uid=NAME instead.");
else {
/* --user= used to require an argument (the container user to run as). It has
* been repurposed to optionally set the runtime scope, with --uid= replacing
* the old container user functionality. To maintain backwards compatibility
- * with the space-separated form (--user NAME), if the next arg does not look
+ * with the space-separated form (--user NAME), if the next opts.arg does not look
* like an option, interpret it as a user name. */
- const char *t = option_parser_next_arg(&state);
+ const char *t = option_parser_next_arg(&opts);
if (t && t[0] != '-') {
- arg = option_parser_consume_next_arg(&state);
+ opts.arg = option_parser_consume_next_arg(&opts);
log_warning("--user NAME is deprecated, use --uid=NAME instead.");
}
}
- if (arg) {
- r = free_and_strdup(&arg_user, arg);
+ if (opts.arg) {
+ r = free_and_strdup(&arg_user, opts.arg);
if (r < 0)
return log_oom();
arg_settings_mask |= SETTING_USER;
}
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!strv_isempty(args)) {
strv_free(arg_parameters);
arg_parameters = strv_copy(args);
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
"Write D-Bus XML introspection data"):
return bus_introspect_implementations(
stdout,
- arg,
+ opts.arg,
BUS_IMPLEMENTATIONS(&manager_object,
&log_control_object));
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program takes no arguments.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("suffix", "SUFFIX", "Suffix to append to paths"):
- arg_suffix = arg;
+ arg_suffix = opts.arg;
break;
OPTION_COMMON_NO_PAGER:
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
if (r < 0)
return r;
- implementation = sym_EVP_get_digestbyname(arg);
+ implementation = sym_EVP_get_digestbyname(opts.arg);
if (!implementation)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown bank '%s', refusing.", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown bank '%s', refusing.", opts.arg);
if (strv_extend(&arg_banks, sym_EVP_MD_get0_name(implementation)) < 0)
return log_oom();
}
OPTION_LONG("pcr", "INDEX", "Select TPM PCR index (0…23)"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_pcr_mask = 0;
break;
}
- r = tpm2_pcr_index_from_string(arg);
+ r = tpm2_pcr_index_from_string(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse PCR index: %s", arg);
+ return log_error_errno(r, "Failed to parse PCR index: %s", opts.arg);
arg_pcr_mask |= INDEX_TO_MASK(uint32_t, r);
break;
OPTION_LONG("nvpcr", "NAME", "Select TPM PCR mode nvindex name"):
- if (!tpm2_nvpcr_name_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "NvPCR name is not valid: %s", arg);
+ if (!tpm2_nvpcr_name_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "NvPCR name is not valid: %s", opts.arg);
- r = free_and_strdup_warn(&arg_nvpcr_name, arg);
+ r = free_and_strdup_warn(&arg_nvpcr_name, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("tpm2-device", "PATH", "Use specified TPM2 device"): {
_cleanup_free_ char *device = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(/* legend= */ true, /* quiet= */ false);
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
OPTION_LONG("file-system", "PATH",
"Measure UUID/labels of file system into PCR 15"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_file_system);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_file_system);
if (r < 0)
return r;
break;
OPTION_LONG("event-type", "TYPE",
"Event type to include in the event log"):
- if (streq(arg, "help"))
+ if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(tpm2_userspace_event_type, Tpm2UserspaceEventType, _TPM2_USERSPACE_EVENT_TYPE_MAX);
- arg_event_type = tpm2_userspace_event_type_from_string(arg);
+ arg_event_type = tpm2_userspace_event_type_from_string(opts.arg);
if (arg_event_type < 0)
- return log_error_errno(arg_event_type, "Failed to parse --event-type= argument: %s", arg);
+ return log_error_errno(arg_event_type, "Failed to parse --event-type= argument: %s", opts.arg);
break;
}
return r;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
bool auto_location = true;
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("pcr", "NR",
"Generate .pcrlock for specified PCR"):
- r = tpm2_parse_pcr_argument_to_mask(arg, &arg_pcr_mask);
+ r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_pcr_mask);
if (r < 0)
- return log_error_errno(r, "Failed to parse PCR specification: %s", arg);
+ return log_error_errno(r, "Failed to parse PCR specification: %s", opts.arg);
break;
OPTION_LONG("nv-index", "NUMBER",
"Use the specified NV index, instead of a random one"):
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_nv_index = 0;
else {
uint32_t u;
- r = safe_atou32_full(arg, 16, &u);
+ r = safe_atou32_full(opts.arg, 16, &u);
if (r < 0)
- return log_error_errno(r, "Failed to parse --nv-index= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --nv-index= argument: %s", opts.arg);
if (u < TPM2_NV_INDEX_FIRST || u > TPM2_NV_INDEX_LAST)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Argument for --nv-index= outside of valid range 0x%" PRIx32 "…0x%" PRIx32 ": 0x%" PRIx32,
"Directory to read .pcrlock files from"): {
_cleanup_free_ char *p = NULL;
- r = parse_path_argument(arg, /* suppress_root= */ false, &p);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &p);
if (r < 0)
return r;
auto_location = false;
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_location_start = mfree(arg_location_start);
arg_location_end = mfree(arg_location_end);
break;
}
- e = strchr(arg, ':');
+ e = strchr(opts.arg, ':');
if (e) {
- start = strndup(arg, e - arg);
+ start = strndup(opts.arg, e - opts.arg);
if (!start)
return log_oom();
if (!end)
return log_oom();
} else {
- start = strdup(arg);
+ start = strdup(opts.arg);
if (!start)
return log_oom();
- end = strdup(arg);
+ end = strdup(opts.arg);
if (!end)
return log_oom();
}
OPTION_LONG("recovery-pin", "MODE",
"Controls whether to show, hide, or ask for a recovery PIN"):
- arg_recovery_pin = recovery_pin_mode_from_string(arg);
+ arg_recovery_pin = recovery_pin_mode_from_string(opts.arg);
if (arg_recovery_pin < 0)
- return log_error_errno(arg_recovery_pin, "Failed to parse --recovery-pin= mode: %s", arg);
+ return log_error_errno(arg_recovery_pin, "Failed to parse --recovery-pin= mode: %s", opts.arg);
break;
OPTION_LONG("pcrlock", "PATH",
".pcrlock file to write expected PCR measurement to"):
- if (empty_or_dash(arg))
+ if (empty_or_dash(opts.arg))
arg_pcrlock_path = mfree(arg_pcrlock_path);
else {
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_pcrlock_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_pcrlock_path);
if (r < 0)
return r;
}
OPTION_LONG("policy", "PATH",
"JSON file to write policy output to"):
- if (empty_or_dash(arg))
+ if (empty_or_dash(opts.arg))
arg_policy_path = mfree(arg_policy_path);
else {
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_policy_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_policy_path);
if (r < 0)
return r;
}
OPTION_LONG("entry-token", "TOKEN",
"Boot entry token to use for this installation "
"(machine-id, os-id, os-image-id, auto, literal:…)"):
- r = parse_boot_entry_token_type(arg, &arg_entry_token_type, &arg_entry_token);
+ r = parse_boot_entry_token_type(opts.arg, &arg_entry_token_type, &arg_entry_token);
if (r < 0)
return r;
break;
arg_pager_flags |= PAGER_DISABLE;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_LONG("background", "COLOR", "Set ANSI color for background"):
- r = parse_background_argument(arg, &arg_background);
+ r = parse_background_argument(opts.arg, &arg_background);
if (r < 0)
return r;
break;
OPTION_LONG("title", "TITLE", "Set terminal title"):
- r = free_and_strdup_warn(&arg_title, arg);
+ r = free_and_strdup_warn(&arg_title, opts.arg);
if (r < 0)
return r;
break;
}
- if (option_parser_get_n_args(&state) == 0)
+ if (option_parser_get_n_args(&opts) == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected command line, refusing.");
- *remaining_args = option_parser_get_args(&state);
+ *remaining_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- r = dispatch_verb_with_args(option_parser_get_args(&state), NULL);
+ r = dispatch_verb_with_args(option_parser_get_args(&opts), NULL);
if (r < 0)
return r;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
bool auto_public_key_pcr_mask = true, auto_pcrlock = true;
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_GROUP("Options"): {}
OPTION_LONG("dry-run", "BOOL",
"Whether to run dry-run operation"):
- r = parse_boolean_argument("--dry-run=", arg, &arg_dry_run);
+ r = parse_boolean_argument("--dry-run=", opts.arg, &arg_dry_run);
if (r < 0)
return r;
break;
OPTION_LONG("empty", "MODE",
"How to handle empty disks lacking partition tables (refuse, allow, require, force, create)"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_empty = EMPTY_UNSET;
break;
}
- arg_empty = empty_mode_from_string(arg);
+ arg_empty = empty_mode_from_string(opts.arg);
if (arg_empty < 0)
- return log_error_errno(arg_empty, "Failed to parse --empty= parameter: %s", arg);
+ return log_error_errno(arg_empty, "Failed to parse --empty= parameter: %s", opts.arg);
break;
OPTION_LONG("offline", "BOOL",
"Whether to build the image offline"):
- r = parse_tristate_argument_with_auto("--offline=", arg, &arg_offline);
+ r = parse_tristate_argument_with_auto("--offline=", opts.arg, &arg_offline);
if (r < 0)
return r;
break;
OPTION_LONG("discard", "BOOL",
"Whether to discard backing blocks for new partitions"):
- r = parse_boolean_argument("--discard=", arg, &arg_discard);
+ r = parse_boolean_argument("--discard=", opts.arg, &arg_discard);
if (r < 0)
return r;
break;
OPTION_LONG("sector-size", "SIZE",
"Set the logical sector size for the image"):
- r = parse_sector_size(arg, &arg_sector_size);
+ r = parse_sector_size(opts.arg, &arg_sector_size);
if (r < 0)
return r;
OPTION_LONG("grain-size", "BYTES",
"Set the grain size for partition alignment"):
- r = parse_size(arg, 1024, &arg_grain_size);
+ r = parse_size(opts.arg, 1024, &arg_grain_size);
if (r < 0)
- return log_error_errno(r, "Failed to parse --grain-size= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --grain-size= parameter: %s", opts.arg);
if (arg_grain_size < 512 || !ISPOWEROF2(arg_grain_size))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Grain size must be a power of 2 >= 512.");
OPTION_LONG("architecture", "ARCH",
"Set the generic architecture for the image"):
- r = architecture_from_string(arg);
+ r = architecture_from_string(opts.arg);
if (r < 0)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid architecture '%s'.", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid architecture '%s'.", opts.arg);
arg_architecture = r;
break;
"Grow loopback file to specified size"): {
uint64_t parsed, rounded;
- if (streq(arg, "auto")) {
+ if (streq(opts.arg, "auto")) {
arg_size = UINT64_MAX;
arg_size_auto = true;
break;
}
- r = parse_size(arg, 1024, &parsed);
+ r = parse_size(opts.arg, 1024, &parsed);
if (r < 0)
- return log_error_errno(r, "Failed to parse --size= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --size= parameter: %s", opts.arg);
rounded = round_up_size(parsed, 4096);
if (rounded == 0)
OPTION_LONG("seed", "UUID",
"128-bit seed UUID to derive all UUIDs from"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_seed = SD_ID128_NULL;
arg_randomize = false;
- } else if (streq(arg, "random"))
+ } else if (streq(opts.arg, "random"))
arg_randomize = true;
else {
- r = sd_id128_from_string(arg, &arg_seed);
+ r = sd_id128_from_string(opts.arg, &arg_seed);
if (r < 0)
- return log_error_errno(r, "Failed to parse seed: %s", arg);
+ return log_error_errno(r, "Failed to parse seed: %s", opts.arg);
arg_randomize = false;
}
OPTION_LONG("split", "BOOL",
"Whether to generate split artifacts"):
- r = parse_boolean_argument("--split=", arg, NULL);
+ r = parse_boolean_argument("--split=", opts.arg, NULL);
if (r < 0)
return r;
OPTION_LONG("pretty", "BOOL",
"Whether to show pretty summary before doing changes"):
- r = parse_boolean_argument("--pretty=", arg, NULL);
+ r = parse_boolean_argument("--pretty=", opts.arg, NULL);
if (r < 0)
return r;
arg_pretty = r;
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
OPTION_LONG("factory-reset", "BOOL",
"Whether to remove data partitions before recreating them"):
- r = parse_boolean_argument("--factory-reset=", arg, NULL);
+ r = parse_boolean_argument("--factory-reset=", opts.arg, NULL);
if (r < 0)
return r;
arg_factory_reset = r;
OPTION_LONG("root", "PATH",
"Operate relative to root path"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH",
"Operate relative to image file"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
OPTION_LONG("image-policy", "POLICY",
"Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("definitions", "DIR",
"Find partition definitions in specified directory"): {
_cleanup_free_ char *path = NULL;
- r = parse_path_argument(arg, false, &path);
+ r = parse_path_argument(opts.arg, false, &path);
if (r < 0)
return r;
if (strv_consume(&arg_definitions, TAKE_PTR(path)) < 0)
OPTION_GROUP("Verity"): {}
OPTION_COMMON_PRIVATE_KEY("Private key to use when generating verity roothash signatures"):
- r = free_and_strdup_warn(&arg_private_key, arg);
+ r = free_and_strdup_warn(&arg_private_key, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_PRIVATE_KEY_SOURCE:
r = parse_openssl_key_source_argument(
- arg,
+ opts.arg,
&arg_private_key_source,
&arg_private_key_source_type);
if (r < 0)
break;
OPTION_COMMON_CERTIFICATE("PEM certificate to use when generating verity roothash signatures"):
- r = free_and_strdup_warn(&arg_certificate, arg);
+ r = free_and_strdup_warn(&arg_certificate, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE_SOURCE:
r = parse_openssl_certificate_source_argument(
- arg,
+ opts.arg,
&arg_certificate_source,
&arg_certificate_source_type);
if (r < 0)
"Specify root hash and pkcs7 signature of root hash for verity as a tuple of "
"hex-encoded hash and a DER-encoded PKCS7, either as a path to a file or as an "
"ASCII base64-encoded string prefixed by 'base64:'"):
- r = parse_join_signature(arg, &arg_verity_settings);
+ r = parse_join_signature(opts.arg, &arg_verity_settings);
if (r < 0)
return r;
break;
OPTION_LONG("key-file", "PATH",
"Key to use when encrypting partitions"):
- r = parse_key_file(arg, &arg_key);
+ r = parse_key_file(opts.arg, &arg_key);
if (r < 0)
return r;
break;
"Path to TPM2 device node to use"): {
_cleanup_free_ char *device = NULL;
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(/* legend= */ true, /* quiet= */ false);
- if (!streq(arg, "auto")) {
- device = strdup(arg);
+ if (!streq(opts.arg, "auto")) {
+ device = strdup(opts.arg);
if (!device)
return log_oom();
}
OPTION_LONG("tpm2-device-key", "PATH",
"Enroll a TPM2 device using its public key"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_device_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_device_key);
if (r < 0)
return r;
OPTION_LONG("tpm2-seal-key-handle", "HANDLE",
"Specify handle of key to use for sealing"):
- r = safe_atou32_full(arg, 16, &arg_tpm2_seal_key_handle);
+ r = safe_atou32_full(opts.arg, 16, &arg_tpm2_seal_key_handle);
if (r < 0)
- return log_error_errno(r, "Could not parse TPM2 seal key handle index '%s': %m", arg);
+ return log_error_errno(r, "Could not parse TPM2 seal key handle index '%s': %m", opts.arg);
break;
OPTION_LONG("tpm2-pcrs", "PCR1+PCR2+…",
"TPM2 PCR indexes to use for TPM2 enrollment"):
- r = tpm2_parse_pcr_argument_append(arg, &arg_tpm2_hash_pcr_values, &arg_tpm2_n_hash_pcr_values);
+ r = tpm2_parse_pcr_argument_append(opts.arg, &arg_tpm2_hash_pcr_values, &arg_tpm2_n_hash_pcr_values);
if (r < 0)
return r;
OPTION_LONG("tpm2-public-key", "PATH",
"Enroll signed TPM2 PCR policy against PEM public key"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_public_key);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_public_key);
if (r < 0)
return r;
OPTION_LONG("tpm2-public-key-pcrs", "PCR1+PCR2+…",
"Enroll signed TPM2 PCR policy for specified TPM2 PCRs"):
auto_public_key_pcr_mask = false;
- r = tpm2_parse_pcr_argument_to_mask(arg, &arg_tpm2_public_key_pcr_mask);
+ r = tpm2_parse_pcr_argument_to_mask(opts.arg, &arg_tpm2_public_key_pcr_mask);
if (r < 0)
return r;
OPTION_LONG("tpm2-pcrlock", "PATH",
"Specify pcrlock policy to lock against"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm2_pcrlock);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm2_pcrlock);
if (r < 0)
return r;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Combination of --include-partitions= and --exclude-partitions= is invalid.");
- r = parse_partition_types(arg, &arg_filter_partitions, &arg_n_filter_partitions);
+ r = parse_partition_types(opts.arg, &arg_filter_partitions, &arg_n_filter_partitions);
if (r < 0)
return r;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Combination of --include-partitions= and --exclude-partitions= is invalid.");
- r = parse_partition_types(arg, &arg_filter_partitions, &arg_n_filter_partitions);
+ r = parse_partition_types(opts.arg, &arg_filter_partitions, &arg_n_filter_partitions);
if (r < 0)
return r;
OPTION_LONG("defer-partitions", "PART1,PART2…",
"Take partitions of the specified types into account but don't populate them yet"):
- r = parse_partition_types(arg, &arg_defer_partitions, &arg_n_defer_partitions);
+ r = parse_partition_types(opts.arg, &arg_defer_partitions, &arg_n_defer_partitions);
if (r < 0)
return r;
OPTION_LONG("defer-partitions-empty", "BOOL",
"Defer all partitions marked for formatting as empty"):
- r = parse_boolean_argument("--defer-partitions-empty=", arg, &arg_defer_partitions_empty);
+ r = parse_boolean_argument("--defer-partitions-empty=", opts.arg, &arg_defer_partitions_empty);
if (r < 0)
return r;
OPTION_LONG("defer-partitions-factory-reset", "BOOL",
"Defer all partitions marked for factory reset"):
- r = parse_boolean_argument("--defer-partitions-factory-reset=", arg, &arg_defer_partitions_factory_reset);
+ r = parse_boolean_argument("--defer-partitions-factory-reset=", opts.arg, &arg_defer_partitions_factory_reset);
if (r < 0)
return r;
OPTION('s', "copy-source", "PATH",
"Specify the primary source tree to copy files from"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_copy_source);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_copy_source);
if (r < 0)
return r;
break;
"Copy partitions from the given image"): {
_cleanup_free_ char *p = NULL;
- r = parse_path_argument(arg, /* suppress_root= */ false, &p);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &p);
if (r < 0)
return r;
OPTION_LONG("make-ddi", "TYPE",
"Create a DDI of the given type"):
- if (!filename_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid DDI type: %s", arg);
+ if (!filename_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid DDI type: %s", opts.arg);
- r = free_and_strdup_warn(&arg_make_ddi, arg);
+ r = free_and_strdup_warn(&arg_make_ddi, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("append-fstab", "MODE",
"How to join the content of a pre-existing fstab with the generated one "
"(no, auto, replace)"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_append_fstab = APPEND_AUTO;
break;
}
- arg_append_fstab = append_mode_from_string(arg);
+ arg_append_fstab = append_mode_from_string(opts.arg);
if (arg_append_fstab < 0)
- return log_error_errno(arg_append_fstab, "Failed to parse --append-fstab= parameter: %s", arg);
+ return log_error_errno(arg_append_fstab, "Failed to parse --append-fstab= parameter: %s", opts.arg);
break;
OPTION_LONG("generate-fstab", "PATH",
"Write fstab configuration to the given path"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_generate_fstab);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_generate_fstab);
if (r < 0)
return r;
break;
OPTION_LONG("generate-crypttab", "PATH",
"Write crypttab configuration to the given path"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_generate_crypttab);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_generate_crypttab);
if (r < 0)
return r;
break;
OPTION_LONG("el-torito", "BOOL",
"Whether to add a boot catalog to boot the ESP"):
- r = parse_boolean_argument("--el-torito=", arg, &arg_eltorito);
+ r = parse_boolean_argument("--el-torito=", opts.arg, &arg_eltorito);
if (r < 0)
return r;
OPTION_LONG("el-torito-system", "STRING",
"Set the system identifier in the ISO9660 descriptor"):
- if (!iso9660_system_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-system=.", arg);
+ if (!iso9660_system_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-system=.", opts.arg);
- r = free_and_strdup_warn(&arg_eltorito_system, arg);
+ r = free_and_strdup_warn(&arg_eltorito_system, opts.arg);
if (r < 0)
return r;
OPTION_LONG("el-torito-volume", "STRING",
"Set the volume identifier in the ISO9660 descriptor"):
- if (!iso9660_volume_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-volume=.", arg);
+ if (!iso9660_volume_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-volume=.", opts.arg);
- r = free_and_strdup_warn(&arg_eltorito_volume, arg);
+ r = free_and_strdup_warn(&arg_eltorito_volume, opts.arg);
if (r < 0)
return r;
OPTION_LONG("el-torito-publisher", "STRING",
"Set the publisher identifier in the ISO9660 descriptor"):
- if (!iso9660_publisher_name_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-publisher=.", arg);
+ if (!iso9660_publisher_name_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value '%s' for --el-torito-publisher=.", opts.arg);
- r = free_and_strdup_warn(&arg_eltorito_publisher, arg);
+ r = free_and_strdup_warn(&arg_eltorito_publisher, opts.arg);
if (r < 0)
return r;
break;
}
- if (option_parser_get_n_args(&state) > 1)
+ if (option_parser_get_n_args(&opts) > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Expected at most one argument, the path to the block device or image file.");
arg_relax_copy_block_security = true;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!strv_isempty(args)) {
if (empty_or_dash(args[0]))
arg_node_none = true;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* ret_a= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return version();
}
- if (state.optind < argc)
+ if (opts.optind < argc)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program takes no arguments.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("url", "URL",
"Upload to this address"):
- r = free_and_strdup_warn(&arg_url, arg);
+ r = free_and_strdup_warn(&arg_url, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("key", "FILENAME",
"Specify key in PEM format (default: \"" REPORT_PRIV_KEY_FILE "\")"):
- r = free_and_strdup_warn(&arg_key, arg);
+ r = free_and_strdup_warn(&arg_key, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("cert", "FILENAME",
"Specify certificate in PEM format (default: \"" REPORT_CERT_FILE "\")"):
- r = free_and_strdup_warn(&arg_cert, arg);
+ r = free_and_strdup_warn(&arg_cert, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("trust", "FILENAME|all",
"Specify CA certificate or disable checking (default: \"" REPORT_TRUST_FILE "\")"):
- r = free_and_strdup_warn(&arg_trust, arg);
+ r = free_and_strdup_warn(&arg_trust, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("network-timeout", "SEC", "Specify timeout for network upload operation"):
- r = parse_sec(arg, &arg_network_timeout_usec);
+ r = parse_sec(opts.arg, &arg_network_timeout_usec);
if (r < 0)
- return log_error_errno(r, "Failed to parse --network-timeout value: %s", arg);
+ return log_error_errno(r, "Failed to parse --network-timeout value: %s", opts.arg);
break;
OPTION_LONG("extra-header", "NAME: VALUE",
"Inject additional header into the upload request"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_extra_headers = strv_free(arg_extra_headers);
break;
}
- if (!http_header_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header: %s", arg);
+ if (!http_header_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header: %s", opts.arg);
- if (strv_extend(&arg_extra_headers, arg) < 0)
+ if (strv_extend(&arg_extra_headers, opts.arg) < 0)
return log_oom();
break;
}
if ((arg_url || arg_key || arg_cert || arg_trust || arg_extra_headers) && !HAVE_LIBCURL)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Compiled without libcurl.");
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("output", "PATH",
"Where to write the signed PE binary"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_output);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_output);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE("PEM certificate to use for signing"):
- r = free_and_strdup_warn(&arg_certificate, arg);
+ r = free_and_strdup_warn(&arg_certificate, opts.arg);
if (r < 0)
return r;
break;
OPTION_COMMON_CERTIFICATE_SOURCE:
r = parse_openssl_certificate_source_argument(
- arg,
+ opts.arg,
&arg_certificate_source,
&arg_certificate_source_type);
if (r < 0)
break;
OPTION_COMMON_PRIVATE_KEY("Private key (PEM) to sign with"):
- r = free_and_strdup_warn(&arg_private_key, arg);
+ r = free_and_strdup_warn(&arg_private_key, opts.arg);
if (r < 0)
return r;
OPTION_COMMON_PRIVATE_KEY_SOURCE:
r = parse_openssl_key_source_argument(
- arg,
+ opts.arg,
&arg_private_key_source,
&arg_private_key_source_type);
if (r < 0)
break;
OPTION_LONG("signed-data", "PATH", /* help= */ NULL):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_signed_data);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_signed_data);
if (r < 0)
return r;
break;
OPTION_LONG("signed-data-signature", "PATH", /* help= */ NULL):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_signed_data_signature);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_signed_data_signature);
if (r < 0)
return r;
if (arg_prepare_offline_signing && (arg_private_key || arg_signed_data || arg_signed_data_signature))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--prepare-offline-signing cannot be used with --private-key=, --signed-data= or --signed-data-signature=");
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
int option_parse(
const Option options[],
const Option options_end[],
- OptionParser *state,
- const Option **ret_option,
- const char **ret_arg) {
+ OptionParser *state) {
/* Check and initialize */
if (state->optind == 0) {
/* Handle non-option parameters */
for (;;) {
if (state->optind == state->argc)
- return 0;
+ goto finished;
if (streq(state->argv[state->optind], "--")) {
/* No more options. Move "--" before positional args so that
}
if (state->parsing_stopped)
- return 0;
+ goto finished;
if (state->argv[state->optind][0] == '-' &&
state->argv[state->optind][1] != '\0')
if (state->mode == OPTION_PARSER_STOP_AT_FIRST_NONOPTION) {
state->parsing_stopped = true;
- return 0;
+ goto finished;
}
if (state->mode == OPTION_PARSER_RETURN_POSITIONAL_ARGS) {
if (FLAGS_SET(option->flags, OPTION_STOPS_PARSING))
state->parsing_stopped = true;
- if (ret_option)
- /* Return the matched Option structure to allow the caller to "know" what was matched */
- *ret_option = option;
-
- if (ret_arg)
- *ret_arg = optval;
- else
- /* It's fine to omit ret_arg, but only if no options return a value. */
- assert(!optval);
-
+ state->opt = option;
+ state->arg = optval;
return option->id;
+
+ finished:
+ state->opt = NULL;
+ state->arg = NULL;
+ return 0;
}
char* option_parser_next_arg(const OptionParser *state) {
* 0 → we're not parsing short options. */
int positional_offset; /* Offset to where positional parameters are. After processing has been
* finished, all options and their args are to the left of this offset. */
+
+ /* The two variables below encompass the state of the last option_parse() call.
+ * Before parsing has commenced, and after it has finished, they will be NULL. */
+ const Option *opt; /* … the matched option or NULL */
+ const char *arg; /* … the argument or NULL */
} OptionParser;
int option_parse(
const Option options[],
const Option options_end[],
- OptionParser *state,
- const Option **ret_option,
- const char **ret_arg);
+ OptionParser *state);
/* Iterate over options. */
-#define FOREACH_OPTION_FULL(parser, opt, ret_o, ret_a, on_error) \
- for (int opt; (opt = option_parse(ALIGN_PTR(__start_SYSTEMD_OPTIONS), __stop_SYSTEMD_OPTIONS, parser, ret_o, ret_a)) != 0; ) \
- if (opt < 0) { \
- on_error; \
- break; \
+#define FOREACH_OPTION(c, state, on_error) \
+ for (int c; (c = option_parse(ALIGN_PTR(__start_SYSTEMD_OPTIONS), __stop_SYSTEMD_OPTIONS, state)) != 0; ) \
+ if (c < 0) { \
+ on_error; \
+ break; \
} else
-#define FOREACH_OPTION(parser, opt, ret_a, on_error) \
- FOREACH_OPTION_FULL(parser, opt, /* ret_o= */ NULL, ret_a, on_error)
-
char* option_parser_next_arg(const OptionParser *state);
char* option_parser_consume_next_arg(OptionParser *state);
/* The interface is: the verb must stay in argv[1]. Any extra positional arguments
* are warned about and ignored. See 4b5d8d0f22ae61ceb45a25391354ba53b43ee992. */
- OptionParser state = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_LOG_LEVEL:
- r = log_set_max_level_from_string(arg);
+ r = log_set_max_level_from_string(opts.arg);
if (r < 0)
- log_warning_errno(r, "Failed to parse log level %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse log level %s, ignoring: %m", opts.arg);
break;
OPTION_COMMON_LOG_TARGET:
- r = log_set_target_from_string(arg);
+ r = log_set_target_from_string(opts.arg);
if (r < 0)
- log_warning_errno(r, "Failed to parse log target %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse log target %s, ignoring: %m", opts.arg);
break;
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "log-color", "BOOL",
"Highlight important messages"):
- if (arg) {
- r = log_show_color_from_string(arg);
+ if (opts.arg) {
+ r = log_show_color_from_string(opts.arg);
if (r < 0)
- log_warning_errno(r, "Failed to parse log color setting %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse log color setting %s, ignoring: %m", opts.arg);
} else
log_show_color(true);
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "log-location", "BOOL",
"Include code location in messages"):
- if (arg) {
- r = log_show_location_from_string(arg);
+ if (opts.arg) {
+ r = log_show_location_from_string(opts.arg);
if (r < 0)
- log_warning_errno(r, "Failed to parse log location setting %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse log location setting %s, ignoring: %m", opts.arg);
} else
log_show_location(true);
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "log-time", "BOOL",
"Prefix messages with current time"):
- if (arg) {
- r = log_show_time_from_string(arg);
+ if (opts.arg) {
+ r = log_show_time_from_string(opts.arg);
if (r < 0)
- log_warning_errno(r, "Failed to parse log time setting %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse log time setting %s, ignoring: %m", opts.arg);
} else
log_show_time(true);
OPTION_LONG("exit-code", "N",
"Exit code for reboot/kexec"):
- r = safe_atou8(arg, &arg_exit_code);
+ r = safe_atou8(opts.arg, &arg_exit_code);
if (r < 0)
- log_warning_errno(r, "Failed to parse exit code %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse exit code %s, ignoring: %m", opts.arg);
break;
OPTION_LONG("timeout", "TIME",
"Overall shutdown timeout"):
- r = parse_sec(arg, &arg_timeout);
+ r = parse_sec(opts.arg, &arg_timeout);
if (r < 0)
- log_warning_errno(r, "Failed to parse shutdown timeout %s, ignoring: %m", arg);
+ log_warning_errno(r, "Failed to parse shutdown timeout %s, ignoring: %m", opts.arg);
break;
OPTION_POSITIONAL:
if (!arg_verb)
- arg_verb = arg;
+ arg_verb = opts.arg;
else
log_warning("Got extraneous argument, ignoring.");
break;
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* arg= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('l', "listen", "ADDR",
"Listen for raw connections at ADDR"):
- r = strv_extend(&arg_listen, arg);
+ r = strv_extend(&arg_listen, opts.arg);
if (r < 0)
return log_oom();
OPTION('E', "setenv", "NAME[=VALUE]",
"Pass an environment variable to children"): {}
OPTION_LONG("environment", "NAME[=VALUE]", /* help= */ NULL): /* legacy alias */
- r = strv_env_replace_strdup_passthrough(&arg_setenv, arg);
+ r = strv_env_replace_strdup_passthrough(&arg_setenv, opts.arg);
if (r < 0)
- return log_error_errno(r, "Cannot assign environment variable %s: %m", arg);
+ return log_error_errno(r, "Cannot assign environment variable %s: %m", opts.arg);
break;
OPTION_LONG("fdname", "NAME[:NAME...]",
"Specify names for file descriptors"): {
_cleanup_strv_free_ char **names = NULL;
- names = strv_split(arg, ":");
+ names = strv_split(opts.arg, ":");
if (!names)
return log_oom();
break;
}
- *remaining_args = option_parser_get_args(&state);
+ *remaining_args = option_parser_get_args(&opts);
if (strv_isempty(*remaining_args))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: command to execute is missing.",
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('c', "connections-max", "NUMBER",
"Set the maximum number of connections to be accepted"):
- r = safe_atou(arg, &arg_connections_max);
+ r = safe_atou(opts.arg, &arg_connections_max);
if (r < 0)
- return log_error_errno(r, "Failed to parse --connections-max= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --connections-max= argument: %s", opts.arg);
if (arg_connections_max < 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
OPTION_LONG("exit-idle-time", "TIME",
"Exit when without a connection for this duration"):
- r = parse_sec(arg, &arg_exit_idle_time);
+ r = parse_sec(opts.arg, &arg_exit_idle_time);
if (r < 0)
- return log_error_errno(r, "Failed to parse --exit-idle-time= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --exit-idle-time= argument: %s", opts.arg);
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
size_t n = strv_length(args);
if (n < 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not enough parameters.");
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg, *verb = NULL;
+ OptionParser opts = { argc, argv };
+ const char *verb = NULL;
int r;
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("make-vsock", NULL, /* help= */ NULL): {}
OPTION_LONG("rm-vsock", NULL, /* help= */ NULL):
- verb = opt->long_code;
+ verb = opts.opt->long_code;
break;
OPTION_LONG("issue-path", "PATH",
"Change path to /run/issue.d/50-ssh-vsock.issue"):
- if (empty_or_dash(arg)) {
+ if (empty_or_dash(opts.arg)) {
arg_issue_path = mfree(arg_issue_path);
arg_issue_stdout = true;
break;
}
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_issue_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_issue_path);
if (r < 0)
return r;
char **args;
if (verb) {
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid use of compat option --make-vsock/--rm-vsock.");
log_warning("Options --make-vsock/--rm-vsock have been replaced by make-vsock/rm-vsock verbs.");
args = strv_new(verb);
} else
- args = strv_copy(option_parser_get_args(&state));
+ args = strv_copy(option_parser_get_args(&opts));
if (!args)
return log_oom();
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('p', "bus-path", "PATH",
"Path to the bus address (default: " DEFAULT_SYSTEM_BUS_ADDRESS ")"):
- arg_bus_path = arg;
+ arg_bus_path = opts.arg;
break;
OPTION_COMMON_MACHINE:
- r = parse_machine_argument(arg, &arg_bus_path, &arg_transport);
+ r = parse_machine_argument(opts.arg, &arg_bus_path, &arg_transport);
if (r < 0)
return r;
break;
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_full_errno(arg_quiet ? LOG_DEBUG : LOG_ERR, SYNTHETIC_ERRNO(EINVAL),
"%s takes no arguments.",
program_invocation_short_name);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("nqn", "STRING",
"Select NQN (NVMe Qualified Name)"):
- if (!filename_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "NQN invalid: %s", arg);
+ if (!filename_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "NQN invalid: %s", opts.arg);
- if (free_and_strdup(&arg_nqn, arg) < 0)
+ if (free_and_strdup(&arg_nqn, opts.arg) < 0)
return log_oom();
break;
return 0;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (arg_all > 0) {
if (!strv_isempty(args))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expects no further arguments if --all/-a is specified.");
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG("prefix", "PATH",
"Only apply rules with the specified prefix"): {
- _cleanup_free_ char *normalized = strdup(arg);
+ _cleanup_free_ char *normalized = strdup(opts.arg);
if (!normalized)
return log_oom();
sysctl_normalize(normalized);
break;
}
- *remaining_args = option_parser_get_args(&state);
+ *remaining_args = option_parser_get_args(&opts);
if (arg_cat_flags != CAT_CONFIG_OFF && !strv_isempty(*remaining_args))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('C', "component", "NAME",
"Select component to update"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_component = mfree(arg_component);
break;
}
- r = component_name_valid(arg);
+ r = component_name_valid(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to determine if component name is valid: %m");
if (r == 0)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Component name invalid: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Component name invalid: %s", opts.arg);
- r = free_and_strdup_warn(&arg_component, arg);
+ r = free_and_strdup_warn(&arg_component, opts.arg);
if (r < 0)
return r;
OPTION_LONG("definitions", "DIR",
"Find transfer definitions in specified directory"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_definitions);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_definitions);
if (r < 0)
return r;
break;
OPTION_LONG("root", "PATH",
"Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH",
"Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY",
"Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("transfer-source", "PATH",
"Specify the directory to transfer sources from"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_transfer_source);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_transfer_source);
if (r < 0)
return r;
OPTION('m', "instances-max", "INT",
"How many instances to maintain"):
- r = safe_atou64(arg, &arg_instances_max);
+ r = safe_atou64(opts.arg, &arg_instances_max);
if (r < 0)
- return log_error_errno(r, "Failed to parse --instances-max= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --instances-max= parameter: %s", opts.arg);
break;
OPTION_LONG("sync", "BOOL",
"Controls whether to sync data to disk"):
- r = parse_boolean_argument("--sync=", arg, &arg_sync);
+ r = parse_boolean_argument("--sync=", opts.arg, &arg_sync);
if (r < 0)
return r;
break;
"Force signature verification on or off"): {
bool b;
- r = parse_boolean_argument("--verify=", arg, &b);
+ r = parse_boolean_argument("--verify=", opts.arg, &b);
if (r < 0)
return r;
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
if (arg_definitions && arg_component)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The --definitions= and --component= switches may not be combined.");
- *remaining_args = option_parser_get_args(&state);
+ *remaining_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_LONG("reboot", NULL, "Reboot after updating to newer version"):
OPTION_COMMON_HOST:
arg_transport = BUS_TRANSPORT_REMOTE;
- arg_host = arg;
+ arg_host = opts.arg;
break;
OPTION_COMMON_NO_PAGER:
return version();
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_CAT_CONFIG:
OPTION_GROUP("Options"): {}
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("replace", "PATH", "Treat arguments as replacement for PATH"):
- if (!path_is_absolute(arg))
+ if (!path_is_absolute(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"The argument to --replace= must be an absolute path.");
- if (!endswith(arg, ".conf"))
+ if (!endswith(opts.arg, ".conf"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"The argument to --replace= must have the extension '.conf'.");
- arg_replace = arg;
+ arg_replace = opts.arg;
break;
OPTION_LONG("dry-run", NULL, "Just print what would be done"):
break;
}
- char **args = option_parser_get_args(&state);
- size_t n_args = option_parser_get_n_args(&state);
+ char **args = option_parser_get_args(&opts);
+ size_t n_args = option_parser_get_n_args(&opts);
if (arg_replace && arg_cat_flags != CAT_CONFIG_OFF)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argv);
assert(ret_args);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
OPTION_LONG("root", "PATH", "Operate below specified root directory"):
- arg_root = arg;
+ arg_root = opts.arg;
break;
OPTION_LONG("open", NULL, "Open the resolved path"):
OPTION_LONG_DATA("step", NULL, CHASE_STEP, "Execute a single normalization step"): {}
OPTION_LONG_DATA("nofollow", NULL, CHASE_NOFOLLOW, "Do not follow the path's right-most component"): {}
OPTION_LONG_DATA("warn", NULL, CHASE_WARN, "Emit a warning on error"):
- arg_flags |= opt->data;
+ arg_flags |= opts.opt->data;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
if (strv_isempty(*ret_args))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "At least one argument is required.");
for (const Entry *e = entries; e && (e->long_code || e->short_code != 0); e++)
n_entries++;
- OptionParser state = { argc, argv, mode };
- const Option *opt;
- const char *arg;
- for (int c; (c = option_parse(options, options + n_options, &state, &opt, &arg)) != 0; ) {
+ OptionParser opts = { argc, argv, mode };
+ for (int c; (c = option_parse(options, options + n_options, &opts)) != 0; ) {
ASSERT_OK(c);
- ASSERT_NOT_NULL(opt);
+ ASSERT_NOT_NULL(opts.opt);
log_debug("%c %s: %s=%s",
- opt->short_code != 0 ? opt->short_code : ' ',
- opt->long_code ?: "",
- strnull(opt->metavar), strnull(arg));
+ opts.opt->short_code != 0 ? opts.opt->short_code : ' ',
+ opts.opt->long_code ?: "",
+ strnull(opts.opt->metavar), strnull(opts.arg));
ASSERT_LT(i, n_entries);
if (entries[i].long_code)
- ASSERT_TRUE(streq_ptr(opt->long_code, entries[i].long_code));
+ ASSERT_TRUE(streq_ptr(opts.opt->long_code, entries[i].long_code));
if (entries[i].short_code != 0)
- ASSERT_EQ(opt->short_code, entries[i].short_code);
- ASSERT_TRUE(streq_ptr(arg, entries[i].argument));
+ ASSERT_EQ(opts.opt->short_code, entries[i].short_code);
+ ASSERT_TRUE(streq_ptr(opts.arg, entries[i].argument));
i++;
}
ASSERT_EQ(i, n_entries);
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
ASSERT_TRUE(strv_equal(args, remaining));
ASSERT_STREQ(argv[0], saved_argv0);
- ASSERT_EQ(option_parser_get_n_args(&state), strv_length(remaining));
+ ASSERT_EQ(option_parser_get_n_args(&opts), strv_length(remaining));
}
static void test_option_invalid_one(
for (const Option *o = options; o->short_code != 0 || o->long_code; o++)
n_options++;
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
- int c = option_parse(options, options + n_options, &state, &opt, &arg);
+ int c = option_parse(options, options + n_options, &opts);
ASSERT_ERROR(c, EINVAL);
}
}
/* Test the OPTION, OPTION_LONG, OPTION_SHORT, OPTION_FULL, OPTION_GROUP macros
- * by using them in a FOREACH_OPTION_FULL switch, as they would be used in real code. */
+ * by using them in a FOREACH_OPTION switch, as they would be used in real code. */
static void test_macros_parse_one(
char **argv,
for (const Entry *e = entries; e && (e->long_code || e->short_code != 0); e++)
n_entries++;
- OptionParser state = { argc, argv, mode };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv, mode };
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, ASSERT_TRUE(false)) {
+ FOREACH_OPTION(c, &opts, assert_not_reached()) {
log_debug("%c %s: %s=%s",
- opt->short_code != 0 ? opt->short_code : ' ',
- opt->long_code ?: "",
- strnull(opt->metavar), strnull(arg));
+ opts.opt->short_code != 0 ? opts.opt->short_code : ' ',
+ opts.opt->long_code ?: "",
+ strnull(opts.opt->metavar), strnull(opts.arg));
ASSERT_LT(i, n_entries);
if (entries[i].long_code)
- ASSERT_TRUE(streq_ptr(opt->long_code, entries[i].long_code));
+ ASSERT_TRUE(streq_ptr(opts.opt->long_code, entries[i].long_code));
if (entries[i].short_code != 0)
- ASSERT_EQ(opt->short_code, entries[i].short_code);
- ASSERT_TRUE(streq_ptr(arg, entries[i].argument));
+ ASSERT_EQ(opts.opt->short_code, entries[i].short_code);
+ ASSERT_TRUE(streq_ptr(opts.arg, entries[i].argument));
if (streq_ptr(entries[i].long_code, "optional2"))
- ASSERT_EQ(opt->data, 666u);
+ ASSERT_EQ(opts.opt->data, 666u);
else
- ASSERT_EQ(opt->data, 0u);
+ ASSERT_EQ(opts.opt->data, 0u);
i++;
ASSERT_EQ(i, n_entries);
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
ASSERT_TRUE(strv_equal(args, remaining));
ASSERT_STREQ(argv[0], saved_argv0);
+ ASSERT_NULL(opts.opt);
+ ASSERT_NULL(opts.arg);
}
TEST(option_macros) {
char **argv = STRV_MAKE("arg0", "--user", "someuser", "pos1");
int argc = strv_length(argv);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
- ASSERT_OK_POSITIVE(option_parse(options, options + 3, &state, &opt, &arg));
- ASSERT_STREQ(opt->long_code, "user");
- ASSERT_NULL(arg);
- ASSERT_STREQ(option_parser_next_arg(&state), "someuser");
- ASSERT_STREQ(option_parser_consume_next_arg(&state), "someuser");
+ ASSERT_OK_POSITIVE(option_parse(options, options + 3, &opts));
+ ASSERT_STREQ(opts.opt->long_code, "user");
+ ASSERT_NULL(opts.arg);
+ ASSERT_STREQ(option_parser_next_arg(&opts), "someuser");
+ ASSERT_STREQ(option_parser_consume_next_arg(&opts), "someuser");
- ASSERT_EQ(option_parse(options, options + 3, &state, &opt, &arg), 0);
+ ASSERT_EQ(option_parse(options, options + 3, &opts), 0);
+ ASSERT_NULL(opts.opt);
+ ASSERT_NULL(opts.arg);
- ASSERT_TRUE(strv_equal(option_parser_get_args(&state), STRV_MAKE("pos1")));
+ ASSERT_TRUE(strv_equal(option_parser_get_args(&opts), STRV_MAKE("pos1")));
}
/* --user at end of args: no next arg, so scope mode */
char **argv = STRV_MAKE("arg0", "--user");
int argc = strv_length(argv);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
- ASSERT_OK_POSITIVE(option_parse(options, options + 3, &state, &opt, &arg));
- ASSERT_STREQ(opt->long_code, "user");
- ASSERT_NULL(arg);
- ASSERT_NULL(option_parser_next_arg(&state));
- ASSERT_NULL(option_parser_consume_next_arg(&state));
+ ASSERT_OK_POSITIVE(option_parse(options, options + 3, &opts));
+ ASSERT_STREQ(opts.opt->long_code, "user");
+ ASSERT_NULL(opts.arg);
+ ASSERT_NULL(option_parser_next_arg(&opts));
+ ASSERT_NULL(option_parser_consume_next_arg(&opts));
- ASSERT_EQ(option_parse(options, options + 3, &state, &opt, &arg), 0);
+ ASSERT_EQ(option_parse(options, options + 3, &opts), 0);
+ ASSERT_NULL(opts.opt);
+ ASSERT_NULL(opts.arg);
- ASSERT_TRUE(strv_isempty(option_parser_get_args(&state)));
+ ASSERT_TRUE(strv_isempty(option_parser_get_args(&opts)));
}
/* --user followed by -u (option): scope mode, -u gets its own processing */
char **argv = STRV_MAKE("arg0", "--user", "-u", "nobody");
int argc = strv_length(argv);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
- ASSERT_OK_POSITIVE(option_parse(options, options + 3, &state, &opt, &arg));
- ASSERT_STREQ(opt->long_code, "user");
- ASSERT_NULL(arg);
- ASSERT_STREQ(option_parser_next_arg(&state), "-u");
+ ASSERT_OK_POSITIVE(option_parse(options, options + 3, &opts));
+ ASSERT_STREQ(opts.opt->long_code, "user");
+ ASSERT_NULL(opts.arg);
+ ASSERT_STREQ(option_parser_next_arg(&opts), "-u");
- ASSERT_OK_POSITIVE(option_parse(options, options + 3, &state, &opt, &arg));
- ASSERT_STREQ(opt->long_code, "uid");
- ASSERT_STREQ(arg, "nobody");
- ASSERT_NULL(option_parser_next_arg(&state));
- ASSERT_NULL(option_parser_consume_next_arg(&state));
+ ASSERT_OK_POSITIVE(option_parse(options, options + 3, &opts));
+ ASSERT_STREQ(opts.opt->long_code, "uid");
+ ASSERT_STREQ(opts.arg, "nobody");
+ ASSERT_NULL(option_parser_next_arg(&opts));
+ ASSERT_NULL(option_parser_consume_next_arg(&opts));
- ASSERT_EQ(option_parse(options, options + 3, &state, &opt, &arg), 0);
+ ASSERT_EQ(option_parse(options, options + 3, &opts), 0);
+ ASSERT_NULL(opts.opt);
+ ASSERT_NULL(opts.arg);
- ASSERT_TRUE(strv_isempty(option_parser_get_args(&state)));
+ ASSERT_TRUE(strv_isempty(option_parser_get_args(&opts)));
}
/* "Functional test": --user followed by -u (option): scope mode, -u gets its own processing,
char **argv = STRV_MAKE("arg0", "--user", "-u", "nobody", "nogroup", "--user=nobody", "--user");
int argc = strv_length(argv);
- OptionParser state = { argc, argv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { argc, argv };
int scope_seen = 0;
int nobody_seen = 0;
- for (int c; (c = option_parse(options, options + 3, &state, &opt, &arg)) != 0; ) {
+ for (int c; (c = option_parse(options, options + 3, &opts)) != 0; ) {
ASSERT_OK(c);
- if (streq_ptr(opt->long_code, "user")) {
+ if (streq_ptr(opts.opt->long_code, "user")) {
+ const char *arg = opts.arg;
+
if (!arg) {
- const char *t = option_parser_next_arg(&state);
+ const char *t = option_parser_next_arg(&opts);
if (t && t[0] != '-')
- arg = option_parser_consume_next_arg(&state);
+ arg = option_parser_consume_next_arg(&opts);
}
if (arg) {
} else
scope_seen ++;
- } else if (streq_ptr(opt->long_code, "uid")) {
- ASSERT_STREQ(arg, "nobody");
+ } else if (streq_ptr(opts.opt->long_code, "uid")) {
+ ASSERT_STREQ(opts.arg, "nobody");
nobody_seen ++;
}
}
ASSERT_EQ(nobody_seen, 2);
ASSERT_EQ(scope_seen, 2);
- ASSERT_TRUE(strv_equal(option_parser_get_args(&state), STRV_MAKE("nogroup")));
+ ASSERT_TRUE(strv_equal(option_parser_get_args(&opts), STRV_MAKE("nogroup")));
+ ASSERT_NULL(opts.opt);
+ ASSERT_NULL(opts.arg);
}
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const Option *current;
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION_FULL(&state, c, ¤t, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
OPTION_COMMON_HOST:
arg_transport = BUS_TRANSPORT_REMOTE;
- arg_host = arg;
+ arg_host = opts.arg;
break;
OPTION_COMMON_MACHINE:
- r = parse_machine_argument(arg, &arg_host, &arg_transport);
+ r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
if (r < 0)
return r;
break;
OPTION('p', "property", "NAME", "Show only properties by this name"): {}
OPTION_SHORT('P', "NAME", "Equivalent to --value --property=NAME"):
- r = strv_extend(&arg_property, arg);
+ r = strv_extend(&arg_property, opts.arg);
if (r < 0)
return log_oom();
/* If the user asked for a particular property, show it to them, even if empty. */
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
- if (current->short_code == 'P')
+ if (opts.opt->short_code == 'P')
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
break;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert_se(argc >= 0);
assert_se(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION('r', "root", "PATH", "Operate on an alternate filesystem root"):
- arg_root = arg;
+ arg_root = opts.arg;
break;
}
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 0;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_LONG("create", NULL, "Create and adjust files and directories"):
break;
OPTION_LONG("prefix", "PATH", "Only apply rules with the specified prefix"):
- if (strv_extend(&arg_include_prefixes, arg) < 0)
+ if (strv_extend(&arg_include_prefixes, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("exclude-prefix", "PATH", "Ignore rules with the specified prefix"):
- if (strv_extend(&arg_exclude_prefixes, arg) < 0)
+ if (strv_extend(&arg_exclude_prefixes, opts.arg) < 0)
return log_oom();
break;
break;
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
- r = parse_image_policy_argument(arg, &arg_image_policy);
+ r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_LONG("replace", "PATH", "Treat arguments as replacement for PATH"):
- if (!path_is_absolute(arg))
+ if (!path_is_absolute(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"The argument to --replace= must be an absolute path.");
- if (!endswith(arg, ".conf"))
+ if (!endswith(opts.arg, ".conf"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"The argument to --replace= must have the extension '.conf'.");
- arg_replace = arg;
+ arg_replace = opts.arg;
break;
OPTION_LONG("dry-run", NULL, "Just print what would be done"):
break;
}
- char **args = option_parser_get_args(&state);
- size_t n_args = option_parser_get_n_args(&state);
+ char **args = option_parser_get_args(&opts);
+ size_t n_args = option_parser_get_n_args(&opts);
if (arg_operation == 0 && arg_cat_flags == CAT_CONFIG_OFF)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, /* ret_a= */ NULL, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- if (option_parser_get_n_args(&state) != 0)
+ if (option_parser_get_n_args(&opts) != 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program expects no arguments.");
return 1;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
OPTION_LONG("tpm2-device", "PATH", "Pick TPM2 device"):
- if (streq(arg, "list"))
+ if (streq(opts.arg, "list"))
return tpm2_list_devices(/* legend= */ true, /* quiet= */ false);
- if (free_and_strdup(&arg_tpm2_device, streq(arg, "auto") ? NULL : arg) < 0)
+ if (free_and_strdup(&arg_tpm2_device, streq(opts.arg, "auto") ? NULL : opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("early", "BOOL", "Store SRK public key in /run/ rather than /var/lib/"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to parse --early= argument: %s", arg);
+ return log_error_errno(r, "Failed to parse --early= argument: %s", opts.arg);
arg_early = r;
break;
break;
}
- if (option_parser_get_n_args(&state) != 0)
+ if (option_parser_get_n_args(&opts) != 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program expects no argument.");
return 1;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "console", "DEVICE",
"Ask question on /dev/console (or DEVICE if specified) instead of the current TTY"):
arg_console = true;
- if (arg) {
- if (isempty(arg))
+ if (opts.arg) {
+ if (isempty(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Empty console device path is not allowed.");
- r = free_and_strdup_warn(&arg_device, arg);
+ r = free_and_strdup_warn(&arg_device, opts.arg);
if (r < 0)
return r;
}
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"%s takes no arguments.", program_invocation_short_name);
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Need exactly one DEVICE argument.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Need exactly one DEVICE argument.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('F', "from-dump", "FILE",
"Read DMI information from a binary file"):
- arg_source_file = arg;
+ arg_source_file = opts.arg;
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program takes no arguments.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Error: unexpected argument.");
assert(argv);
assert(remaining_args);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- *remaining_args = option_parser_get_args(&state);
+ *remaining_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Need exactly one DEVICE argument.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
int r;
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION('d', "device", "PATH", "Device node for SG_IO commands"):
dev_specified = true;
- strscpy(maj_min_dev, MAX_PATH_LEN, arg);
+ strscpy(maj_min_dev, MAX_PATH_LEN, opts.arg);
break;
OPTION('f', "config", "PATH", "Location of config file"):
- strscpy(config_file, MAX_PATH_LEN, arg);
+ strscpy(config_file, MAX_PATH_LEN, opts.arg);
break;
OPTION('p', "page", "0x80|0x83|pre-spc3-83", "SCSI page"):
- r = parse_page_code(arg, &default_page_code);
+ r = parse_page_code(opts.arg, &default_page_code);
if (r < 0)
return r;
break;
OPTION('s', "sg-version", "3|4", "Use SGv3 or SGv4"):
- r = safe_atoi(arg, &sg_version);
+ r = safe_atoi(opts.arg, &sg_version);
if (r < 0)
- return log_error_errno(r, "Invalid SG version '%s'", arg);
+ return log_error_errno(r, "Invalid SG version '%s'", opts.arg);
if (!IN_SET(sg_version, 3, 4))
return log_error_errno(SYNTHETIC_ERRNO(ERANGE),
- "Unknown SG version '%s'", arg);
+ "Unknown SG version '%s'", opts.arg);
break;
OPTION('b', "denylisted", NULL, "Treat device as denylisted"): {}
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!strv_isempty(args) && !dev_specified) {
dev_specified = true;
strscpy(maj_min_dev, MAX_PATH_LEN, args[0]);
if (newargc > INT_MAX)
return log_oom(); /* Close enough :) */
- OptionParser state = { newargc, newargv };
- const Option *opt;
- const char *arg;
+ OptionParser opts = { newargc, newargv };
/* We reuse the option parser, but only a subset of the options is supported here.
* If any others are encountered, return an error. */
- FOREACH_OPTION_FULL(&state, c, &opt, &arg, /* on_error= */ return c)
- if (opt->short_code == 'b')
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
+ if (opts.opt->short_code == 'b')
*good_bad = 0;
- else if (opt->short_code == 'g')
+ else if (opts.opt->short_code == 'g')
*good_bad = 1;
- else if (opt->short_code == 'p') {
- r = parse_page_code(arg, page_code);
+ else if (opts.opt->short_code == 'p') {
+ r = parse_page_code(opts.arg, page_code);
if (r < 0)
return r;
} else
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Option %s not supported in the config file.",
- strnull(option_get_synopsis("", opt, "/", /* show_metavar=*/ false)));
+ strnull(option_get_synopsis("", opts.opt, "/", /* show_metavar=*/ false)));
return 0;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return version();
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Need exactly one DEVICE argument.");
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return version();
OPTION_LONG("root", "PATH", "Operate on root directory PATH"):
- r = parse_path_argument(arg, /* suppress_root= */ true, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ true, &arg_root);
if (r < 0)
return r;
break;
}
- if (option_parser_get_n_args(&state) > 0)
+ if (option_parser_get_n_args(&opts) > 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program takes no arguments.");
return 1;
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
return help();
return version();
OPTION_LONG("root", "PATH|auto", "Operate relative to the specified path"):
- if (streq(arg, "auto"))
+ if (streq(opts.arg, "auto"))
r = free_and_strdup_warn(&arg_root, in_initrd() ? "/sysroot" : NULL);
else {
- if (!path_is_absolute(arg))
+ if (!path_is_absolute(opts.arg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "--root= argument must be 'auto' or absolute path, got: %s", arg);
+ "--root= argument must be 'auto' or absolute path, got: %s", opts.arg);
- r = parse_path_argument(arg, /* suppress_root= */ true, &arg_root);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ true, &arg_root);
}
if (r < 0)
return r;
break;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (strv_length(args) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
break;
OPTION_COMMON_JSON:
- r = parse_json_argument(arg, &arg_json_format_flags);
+ r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
break;
OPTION_LONG("graceful", "ERROR", "Treat specified Varlink error as success"):
- r = varlink_idl_qualified_symbol_name_is_valid(arg);
+ r = varlink_idl_qualified_symbol_name_is_valid(opts.arg);
if (r < 0)
- return log_error_errno(r, "Failed to validate Varlink error name '%s': %m", arg);
+ return log_error_errno(r, "Failed to validate Varlink error name '%s': %m", opts.arg);
if (r == 0)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not a valid Varlink error name: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not a valid Varlink error name: %s", opts.arg);
- if (strv_extend(&arg_graceful, arg) < 0)
+ if (strv_extend(&arg_graceful, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("timeout", "SECS", "Maximum time to wait for method call completion"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_timeout = USEC_INFINITY;
break;
}
- r = parse_sec(arg, &arg_timeout);
+ r = parse_sec(opts.arg, &arg_timeout);
if (r < 0)
- return log_error_errno(r, "Failed to parse --timeout= parameter '%s': %m", arg);
+ return log_error_errno(r, "Failed to parse --timeout= parameter '%s': %m", opts.arg);
if (arg_timeout == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Timeout cannot be zero.");
return log_oom();
_cleanup_close_ int add_fd = -EBADF;
- if (STARTSWITH_SET(arg, "/", "./")) {
+ if (STARTSWITH_SET(opts.arg, "/", "./")) {
/* We usually expect a numeric fd spec, but as an extension let's treat this
* as a path to open in read-only mode in case this is clearly an absolute or
* relative path */
- add_fd = open(arg, O_CLOEXEC|O_RDONLY|O_NOCTTY);
+ add_fd = open(opts.arg, O_CLOEXEC|O_RDONLY|O_NOCTTY);
if (add_fd < 0)
- return log_error_errno(errno, "Failed to open '%s': %m", arg);
+ return log_error_errno(errno, "Failed to open '%s': %m", opts.arg);
} else {
- int parsed_fd = parse_fd(arg);
+ int parsed_fd = parse_fd(opts.arg);
if (parsed_fd < 0)
- return log_error_errno(parsed_fd, "Failed to parse --push-fd= parameter: %s", arg);
+ return log_error_errno(parsed_fd, "Failed to parse --push-fd= parameter: %s", opts.arg);
/* Make a copy, so that the same fd could be used multiple times in a reasonable
* way. This also validates the fd early */
strv_sort_uniq(arg_graceful);
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- const Option *current;
- const char *arg;
+ OptionParser opts = { argc, argv, OPTION_PARSER_STOP_AT_FIRST_NONOPTION };
- FOREACH_OPTION_FULL(&state, c, ¤t, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION_COMMON_HELP:
OPTION_GROUP("Image"): {}
OPTION('D', "directory", "PATH", "Root directory for the VM"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_directory);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_directory);
if (r < 0)
return r;
break;
break;
OPTION('i', "image", "FILE|DEVICE", "Root file system disk image or device for the VM"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_image);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-format", "FORMAT", "Specify disk image format (raw, qcow2; default: raw)"):
- arg_image_format = image_format_from_string(arg);
+ arg_image_format = image_format_from_string(opts.arg);
if (arg_image_format < 0)
return log_error_errno(arg_image_format,
- "Invalid image format: %s", arg);
+ "Invalid image format: %s", opts.arg);
break;
OPTION_LONG("image-disk-type", "TYPE",
"Specify disk type (virtio-blk, virtio-scsi, nvme, scsi-cd; default: virtio-blk)"):
- arg_image_disk_type = disk_type_from_string(arg);
+ arg_image_disk_type = disk_type_from_string(opts.arg);
if (arg_image_disk_type < 0)
return log_error_errno(arg_image_disk_type,
- "Invalid image disk type: %s", arg);
+ "Invalid image disk type: %s", opts.arg);
break;
OPTION_GROUP("Host Configuration"): {}
OPTION_LONG("cpus", "CPUS", "Configure number of CPUs in guest"): {}
OPTION_LONG("qemu-smp", "CPUS", /* help= */ NULL): /* Compat alias */
- r = free_and_strdup_warn(&arg_cpus, arg);
+ r = free_and_strdup_warn(&arg_cpus, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("ram", "BYTES[:MAXBYTES[:SLOTS]]",
"Configure guest's RAM size (and max/slots for hotplug)"): {}
OPTION_LONG("qemu-mem", "BYTES", /* help= */ NULL): /* Compat alias */
- r = parse_ram(arg);
+ r = parse_ram(opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("kvm", "BOOL", "Enable use of KVM"): {}
OPTION_LONG("qemu-kvm", "BOOL", /* help= */ NULL): /* Compat alias */
- r = parse_tristate_argument_with_auto("--kvm=", arg, &arg_kvm);
+ r = parse_tristate_argument_with_auto("--kvm=", opts.arg, &arg_kvm);
if (r < 0)
return r;
break;
OPTION_LONG("vsock", "BOOL", "Override autodetection of VSOCK support"): {}
OPTION_LONG("qemu-vsock", "BOOL", /* help= */ NULL): /* Compat alias */
- r = parse_tristate_argument_with_auto("--vsock=", arg, &arg_vsock);
+ r = parse_tristate_argument_with_auto("--vsock=", opts.arg, &arg_vsock);
if (r < 0)
return r;
break;
OPTION_LONG("vsock-cid", "CID", "Specify the CID to use for the guest's VSOCK support"):
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_vsock_cid = VMADDR_CID_ANY;
else {
unsigned cid;
- r = vsock_parse_cid(arg, &cid);
+ r = vsock_parse_cid(opts.arg, &cid);
if (r < 0)
- return log_error_errno(r, "Failed to parse --vsock-cid: %s", arg);
+ return log_error_errno(r, "Failed to parse --vsock-cid: %s", opts.arg);
if (!VSOCK_CID_IS_REGULAR(cid))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified CID is not regular, refusing: %u", cid);
break;
OPTION_LONG("tpm", "BOOL", "Enable use of a virtual TPM"):
- r = parse_tristate_argument_with_auto("--tpm=", arg, &arg_tpm);
+ r = parse_tristate_argument_with_auto("--tpm=", opts.arg, &arg_tpm);
if (r < 0)
return r;
break;
OPTION_LONG("tpm-state", "off|auto|PATH", "Where to store TPM state"):
- r = isempty(arg) ? false :
- streq(arg, "auto") ? true :
- parse_boolean(arg);
+ r = isempty(opts.arg) ? false :
+ streq(opts.arg, "auto") ? true :
+ parse_boolean(opts.arg);
if (r >= 0) {
arg_tpm_state_mode = r ? STATE_AUTO : STATE_OFF;
arg_tpm_state_path = mfree(arg_tpm_state_path);
break;
}
- if (!path_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid path in --tpm-state= parameter: %s", arg);
+ if (!path_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid path in --tpm-state= parameter: %s", opts.arg);
- if (!path_is_absolute(arg) && !startswith(arg, "./"))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path in --tpm-state= parameter must be absolute or start with './': %s", arg);
+ if (!path_is_absolute(opts.arg) && !startswith(opts.arg, "./"))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path in --tpm-state= parameter must be absolute or start with './': %s", opts.arg);
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_tpm_state_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_tpm_state_path);
if (r < 0)
return r;
break;
OPTION_LONG("efi-nvram-template", "PATH", "Set the path to the EFI NVRAM template file to use"):
- if (!isempty(arg) && !path_is_absolute(arg) && !startswith(arg, "./"))
+ if (!isempty(opts.arg) && !path_is_absolute(opts.arg) && !startswith(opts.arg, "./"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Absolute path or path starting with './' required.");
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_efi_nvram_template);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_efi_nvram_template);
if (r < 0)
return r;
break;
OPTION_LONG("efi-nvram-state", "off|auto|PATH", "Where to store EFI Variable NVRAM state"):
- r = isempty(arg) ? false :
- streq(arg, "auto") ? true :
- parse_boolean(arg);
+ r = isempty(opts.arg) ? false :
+ streq(opts.arg, "auto") ? true :
+ parse_boolean(opts.arg);
if (r >= 0) {
arg_efi_nvram_state_mode = r ? STATE_AUTO : STATE_OFF;
arg_efi_nvram_state_path = mfree(arg_efi_nvram_state_path);
break;
}
- if (!path_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid path in --efi-nvram-state= parameter: %s", arg);
+ if (!path_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid path in --efi-nvram-state= parameter: %s", opts.arg);
- if (!path_is_absolute(arg) && !startswith(arg, "./"))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path in --efi-nvram-state= parameter must be absolute or start with './': %s", arg);
+ if (!path_is_absolute(opts.arg) && !startswith(opts.arg, "./"))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path in --efi-nvram-state= parameter must be absolute or start with './': %s", opts.arg);
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_efi_nvram_state_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_efi_nvram_state_path);
if (r < 0)
return r;
break;
OPTION_LONG("linux", "PATH", "Specify the linux kernel for direct kernel boot"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_linux);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_linux);
if (r < 0)
return r;
break;
OPTION_LONG("initrd", "PATH", "Specify the initrd for direct kernel boot"): {
_cleanup_free_ char *initrd_path = NULL;
- r = parse_path_argument(arg, /* suppress_root= */ false, &initrd_path);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &initrd_path);
if (r < 0)
return r;
OPTION_LONG("secure-boot", "BOOL|auto", "Enable searching for firmware supporting SecureBoot"): {
int b;
- r = parse_tristate_argument_with_auto("--secure-boot=", arg, &b);
+ r = parse_tristate_argument_with_auto("--secure-boot=", opts.arg, &b);
if (r < 0)
return r;
OPTION_LONG("firmware", "auto|uefi|bios|none|PATH|list|describe",
"Select firmware to use, or a firmware definition file (or list/describe available)"): {
- if (isempty(arg) || streq(arg, "auto")) {
+ if (isempty(opts.arg) || streq(opts.arg, "auto")) {
arg_firmware = mfree(arg_firmware);
arg_firmware_type = _FIRMWARE_INVALID;
arg_firmware_describe = false;
break;
}
- if (streq(arg, "list")) {
+ if (streq(opts.arg, "list")) {
_cleanup_strv_free_ char **l = NULL;
r = list_ovmf_config(&l);
return 0;
}
- if (streq(arg, "describe")) {
+ if (streq(opts.arg, "describe")) {
/* Handled after argument parsing so that --firmware-features= is
* taken into account. */
arg_firmware = mfree(arg_firmware);
break;
}
- Firmware f = firmware_from_string(arg);
+ Firmware f = firmware_from_string(opts.arg);
if (f >= 0) {
arg_firmware = mfree(arg_firmware);
arg_firmware_type = f;
break;
}
- if (!path_is_absolute(arg) && !startswith(arg, "./"))
+ if (!path_is_absolute(opts.arg) && !startswith(opts.arg, "./"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Expected one of 'auto', 'uefi', 'bios', 'none', 'list', 'describe', or an absolute path or path starting with './', got: %s",
- arg);
+ opts.arg);
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_firmware);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_firmware);
if (r < 0)
return r;
OPTION_LONG("firmware-features", "FEATURE,...|list",
"Require/exclude specific firmware features"): {
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_firmware_features_include = set_free(arg_firmware_features_include);
arg_firmware_features_exclude = set_free(arg_firmware_features_exclude);
break;
}
- if (streq(arg, "list")) {
+ if (streq(opts.arg, "list")) {
_cleanup_strv_free_ char **l = NULL;
r = list_ovmf_firmware_features(&l);
return 0;
}
- _cleanup_strv_free_ char **features = strv_split(arg, ",");
+ _cleanup_strv_free_ char **features = strv_split(opts.arg, ",");
if (!features)
return log_oom();
}
OPTION_LONG("discard-disk", "BOOL", "Control processing of discard requests"):
- r = parse_boolean_argument("--discard-disk=", arg, &arg_discard_disk);
+ r = parse_boolean_argument("--discard-disk=", opts.arg, &arg_discard_disk);
if (r < 0)
return r;
break;
OPTION('G', "grow-image", "BYTES", "Grow image file to specified size in bytes"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_grow_image = 0;
break;
}
- r = parse_size(arg, 1024, &arg_grow_image);
+ r = parse_size(opts.arg, 1024, &arg_grow_image);
if (r < 0)
- return log_error_errno(r, "Failed to parse --grow-image= parameter: %s", arg);
+ return log_error_errno(r, "Failed to parse --grow-image= parameter: %s", opts.arg);
break;
OPTION_GROUP("Execution"): {}
OPTION('s', "smbios11", "STRING", "Pass an arbitrary SMBIOS Type #11 string to the VM"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_smbios11 = strv_free(arg_smbios11);
break;
}
- if (!utf8_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "SMBIOS Type 11 string is not UTF-8 clean, refusing: %s", arg);
+ if (!utf8_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "SMBIOS Type 11 string is not UTF-8 clean, refusing: %s", opts.arg);
- if (strv_extend(&arg_smbios11, arg) < 0)
+ if (strv_extend(&arg_smbios11, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("notify-ready", "BOOL", "Wait for ready notification from the VM"):
- r = parse_boolean_argument("--notify-ready=", arg, &arg_notify_ready);
+ r = parse_boolean_argument("--notify-ready=", opts.arg, &arg_notify_ready);
if (r < 0)
return r;
break;
OPTION_GROUP("System Identity"): {}
OPTION('M', "machine", "NAME", "Set the machine name for the VM"):
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_machine = mfree(arg_machine);
else {
- if (!hostname_is_valid(arg, 0))
+ if (!hostname_is_valid(opts.arg, 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Invalid machine name: %s", arg);
+ "Invalid machine name: %s", opts.arg);
- r = free_and_strdup(&arg_machine, arg);
+ r = free_and_strdup(&arg_machine, opts.arg);
if (r < 0)
return log_oom();
}
break;
OPTION_LONG("uuid", "UUID", "Set a specific machine UUID for the VM"):
- r = id128_from_string_nonzero(arg, &arg_uuid);
+ r = id128_from_string_nonzero(opts.arg, &arg_uuid);
if (r == -ENXIO)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Machine UUID may not be all zeroes.");
if (r < 0)
- return log_error_errno(r, "Invalid UUID: %s", arg);
+ return log_error_errno(r, "Invalid UUID: %s", opts.arg);
break;
OPTION_GROUP("Properties"): {}
OPTION('S', "slice", "SLICE", "Place the VM in the specified slice"): {
_cleanup_free_ char *mangled = NULL;
- r = unit_name_mangle_with_suffix(arg, /* operation= */ NULL, UNIT_NAME_MANGLE_WARN, ".slice", &mangled);
+ r = unit_name_mangle_with_suffix(opts.arg, /* operation= */ NULL, UNIT_NAME_MANGLE_WARN, ".slice", &mangled);
if (r < 0)
- return log_error_errno(r, "Failed to turn '%s' into unit name: %m", arg);
+ return log_error_errno(r, "Failed to turn '%s' into unit name: %m", opts.arg);
free_and_replace(arg_slice, mangled);
break;
}
OPTION_LONG("property", "NAME=VALUE", "Set scope unit property"):
- if (strv_extend(&arg_property, arg) < 0)
+ if (strv_extend(&arg_property, opts.arg) < 0)
return log_oom();
break;
OPTION_LONG("register", "BOOLEAN", "Register VM as machine"):
- r = parse_tristate_argument_with_auto("--register=", arg, &arg_register);
+ r = parse_tristate_argument_with_auto("--register=", opts.arg, &arg_register);
if (r < 0)
return r;
break;
OPTION_LONG("private-users", "UIDBASE[:NUIDS]",
"Configure the UID/GID range to map into the virtiofsd namespace"):
- r = parse_userns_uid_range(arg, &arg_uid_shift, &arg_uid_range);
+ r = parse_userns_uid_range(opts.arg, &arg_uid_shift, &arg_uid_range);
if (r < 0)
return r;
break;
OPTION_LONG("bind", "SOURCE[:TARGET]", "Mount a file or directory from the host into the VM"): {}
OPTION_LONG("bind-ro", "SOURCE[:TARGET]", "Mount a file or directory, but read-only"): {
- bool read_only = streq(current->long_code, "bind-ro");
- r = runtime_mount_parse(&arg_runtime_mounts, arg, read_only);
+ bool read_only = streq(opts.opt->long_code, "bind-ro");
+ r = runtime_mount_parse(&arg_runtime_mounts, opts.arg, read_only);
if (r < 0)
- return log_error_errno(r, "Failed to parse --%s= argument %s: %m", current->long_code, arg);
+ return log_error_errno(r, "Failed to parse --%s= argument %s: %m",
+ opts.opt->long_code, opts.arg);
break;
}
DiskType extra_disk_type = _DISK_TYPE_INVALID;
_cleanup_free_ char *drive_path = NULL;
- r = parse_disk_spec(arg, &format, &extra_disk_type, &drive_path);
+ r = parse_disk_spec(opts.arg, &format, &extra_disk_type, &drive_path);
if (r < 0)
return r;
}
OPTION_LONG("bind-user", "NAME", "Bind user from host to virtual machine"):
- if (!valid_user_group_name(arg, /* flags= */ 0))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid user name to bind: %s", arg);
+ if (!valid_user_group_name(opts.arg, /* flags= */ 0))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid user name to bind: %s", opts.arg);
- if (strv_extend(&arg_bind_user, arg) < 0)
+ if (strv_extend(&arg_bind_user, opts.arg) < 0)
return log_oom();
break;
"Configure the shell to use for --bind-user= users"): {
bool copy = false;
char *sh = NULL;
- r = parse_user_shell(arg, &sh, ©);
+ r = parse_user_shell(opts.arg, &sh, ©);
if (r == -ENOMEM)
return log_oom();
if (r < 0)
- return log_error_errno(r, "Invalid user shell to bind: %s", arg);
+ return log_error_errno(r, "Invalid user shell to bind: %s", opts.arg);
free_and_replace(arg_bind_user_shell, sh);
arg_bind_user_shell_copy = copy;
}
OPTION_LONG("bind-user-group", "GROUP", "Add an auxiliary group to --bind-user= users"):
- if (!valid_user_group_name(arg, /* flags= */ 0))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid bind user auxiliary group name: %s", arg);
+ if (!valid_user_group_name(opts.arg, /* flags= */ 0))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid bind user auxiliary group name: %s", opts.arg);
- if (strv_extend(&arg_bind_user_groups, arg) < 0)
+ if (strv_extend(&arg_bind_user_groups, opts.arg) < 0)
return log_oom();
break;
OPTION_GROUP("Integration"): {}
OPTION_LONG("forward-journal", "FILE|DIR", "Forward the VM's journal to the host"):
- r = parse_path_argument(arg, /* suppress_root= */ false, &arg_forward_journal);
+ r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_forward_journal);
if (r < 0)
return r;
break;
OPTION_LONG("forward-journal-max-use", "BYTES", "Maximum disk space for forwarded journal"):
- r = parse_size(arg, 1024, &arg_forward_journal_max_use);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_max_use);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-use= value: %s", optarg);
break;
OPTION_LONG("forward-journal-keep-free", "BYTES", "Minimum disk space to keep free"):
- r = parse_size(arg, 1024, &arg_forward_journal_keep_free);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_keep_free);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-keep-free= value: %s", optarg);
break;
OPTION_LONG("forward-journal-max-file-size", "BYTES", "Maximum size of individual journal files"):
- r = parse_size(arg, 1024, &arg_forward_journal_max_file_size);
+ r = parse_size(opts.arg, 1024, &arg_forward_journal_max_file_size);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-file-size= value: %s", optarg);
break;
OPTION_LONG("forward-journal-max-files", "N", "Maximum number of journal files to keep"):
- r = safe_atou64(arg, &arg_forward_journal_max_files);
+ r = safe_atou64(opts.arg, &arg_forward_journal_max_files);
if (r < 0)
return log_error_errno(r, "Failed to parse --forward-journal-max-files= value: %s", optarg);
break;
OPTION_LONG("pass-ssh-key", "BOOL", "Create an SSH key to access the VM"):
- r = parse_boolean_argument("--pass-ssh-key=", arg, &arg_pass_ssh_key);
+ r = parse_boolean_argument("--pass-ssh-key=", opts.arg, &arg_pass_ssh_key);
if (r < 0)
return r;
break;
OPTION_LONG("ssh-key-type", "TYPE", "Choose what type of SSH key to pass"):
- if (isempty(arg)) {
+ if (isempty(opts.arg)) {
arg_ssh_key_type = mfree(arg_ssh_key_type);
break;
}
- if (!string_is_safe(arg, STRING_ALLOW_GLOBS))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value for --ssh-key-type=: %s", arg);
+ if (!string_is_safe(opts.arg, STRING_ALLOW_GLOBS))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid value for --ssh-key-type=: %s", opts.arg);
- r = free_and_strdup_warn(&arg_ssh_key_type, arg);
+ r = free_and_strdup_warn(&arg_ssh_key_type, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("console", "MODE",
"Console mode (interactive, native, gui, read-only or headless)"):
- arg_console_mode = console_mode_from_string(arg);
+ arg_console_mode = console_mode_from_string(opts.arg);
if (arg_console_mode < 0)
- return log_error_errno(arg_console_mode, "Failed to parse specified console mode: %s", arg);
+ return log_error_errno(arg_console_mode, "Failed to parse specified console mode: %s", opts.arg);
break;
OPTION_LONG("console-transport", "TRANSPORT", "Console transport (virtio or serial)"):
- arg_console_transport = console_transport_from_string(arg);
+ arg_console_transport = console_transport_from_string(opts.arg);
if (arg_console_transport < 0)
- return log_error_errno(arg_console_transport, "Failed to parse specified console transport: %s", arg);
+ return log_error_errno(arg_console_transport, "Failed to parse specified console transport: %s", opts.arg);
break;
OPTION_LONG("qemu-gui", NULL, /* help= */ NULL): /* Compat alias */
break;
OPTION_LONG("background", "COLOR", "Set ANSI color for background"):
- r = parse_background_argument(arg, &arg_background);
+ r = parse_background_argument(opts.arg, &arg_background);
if (r < 0)
return r;
break;
OPTION_GROUP("Credentials"): {}
OPTION_LONG("set-credential", "ID:VALUE", "Pass a credential with literal value to the VM"):
- r = machine_credential_set(&arg_credentials, arg);
+ r = machine_credential_set(&arg_credentials, opts.arg);
if (r < 0)
return r;
break;
OPTION_LONG("load-credential", "ID:PATH",
"Load credential for the VM from file or AF_UNIX stream socket"):
- r = machine_credential_load(&arg_credentials, arg);
+ r = machine_credential_load(&arg_credentials, opts.arg);
if (r < 0)
return r;
break;
arg_uid_range = 0x10000;
}
- char **args = option_parser_get_args(&state);
+ char **args = option_parser_get_args(&opts);
if (!strv_isempty(args)) {
arg_kernel_cmdline_extra = strv_copy(args);
if (!arg_kernel_cmdline_extra)
assert(argc >= 0);
assert(argv);
- OptionParser state = { argc, argv };
- const char *arg;
+ OptionParser opts = { argc, argv };
- FOREACH_OPTION(&state, c, &arg, /* on_error= */ return c)
+ FOREACH_OPTION(c, &opts, /* on_error= */ return c)
switch (c) {
OPTION('B', "basename", "BASENAME", "Look for specified basename"):
- if (!filename_part_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid basename string: %s", arg);
+ if (!filename_part_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid basename string: %s", opts.arg);
- r = free_and_strdup_warn(&arg_filter_basename, arg);
+ r = free_and_strdup_warn(&arg_filter_basename, opts.arg);
if (r < 0)
return r;
break;
OPTION_SHORT('V', "VERSION", "Look for specified version"):
- if (!version_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid version string: %s", arg);
+ if (!version_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid version string: %s", opts.arg);
- r = free_and_strdup_warn(&arg_filter_version, arg);
+ r = free_and_strdup_warn(&arg_filter_version, opts.arg);
if (r < 0)
return r;
break;
OPTION_SHORT('A', "ARCH", "Look for specified architecture"):
- if (streq(arg, "native"))
+ if (streq(opts.arg, "native"))
arg_filter_architecture = native_architecture();
- else if (streq(arg, "secondary")) {
+ else if (streq(opts.arg, "secondary")) {
#ifdef ARCHITECTURE_SECONDARY
arg_filter_architecture = ARCHITECTURE_SECONDARY;
#else
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Local architecture has no secondary architecture.");
#endif
- } else if (streq(arg, "uname"))
+ } else if (streq(opts.arg, "uname"))
arg_filter_architecture = uname_architecture();
- else if (streq(arg, "auto"))
+ else if (streq(opts.arg, "auto"))
arg_filter_architecture = _ARCHITECTURE_INVALID;
else {
- arg_filter_architecture = architecture_from_string(arg);
+ arg_filter_architecture = architecture_from_string(opts.arg);
if (arg_filter_architecture < 0)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown architecture: %s", arg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown architecture: %s", opts.arg);
}
break;
OPTION('S', "suffix", "SUFFIX", "Look for specified suffix"):
- if (!filename_part_is_valid(arg))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid suffix string: %s", arg);
+ if (!filename_part_is_valid(opts.arg))
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid suffix string: %s", opts.arg);
- r = free_and_strdup_warn(&arg_filter_suffix, arg);
+ r = free_and_strdup_warn(&arg_filter_suffix, opts.arg);
if (r < 0)
return r;
break;
OPTION('t', "type", "TYPE", "Look for specified inode type"):
- if (isempty(arg))
+ if (isempty(opts.arg))
arg_filter_type_mask = 0;
else {
mode_t m;
- m = inode_type_from_string(arg);
+ m = inode_type_from_string(opts.arg);
if (m == MODE_INVALID)
- return log_error_errno(m, "Unknown inode type: %s", arg);
+ return log_error_errno(m, "Unknown inode type: %s", opts.arg);
arg_filter_type_mask |= UINT32_C(1) << IFTODT(m);
}
OPTION_LONG_FLAGS(OPTION_HELP_ENTRY, "print", "all",
"... print all of the above"):
- if (streq(arg, "arch")) /* accept abbreviation too */
+ if (streq(opts.arg, "arch")) /* accept abbreviation too */
arg_print = PRINT_ARCHITECTURE;
else
- arg_print = print_from_string(arg);
+ arg_print = print_from_string(opts.arg);
if (arg_print < 0)
- return log_error_errno(arg_print, "Unknown --print= argument: %s", arg);
+ return log_error_errno(arg_print, "Unknown --print= argument: %s", opts.arg);
break;
OPTION_LONG("resolve", "BOOL", "Canonicalize the result path"):
- r = parse_boolean(arg);
+ r = parse_boolean(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse --resolve= value: %m");
if (arg_print < 0)
arg_print = PRINT_PATH;
- *ret_args = option_parser_get_args(&state);
+ *ret_args = option_parser_get_args(&opts);
return 1;
}
projects / thirdparty / systemd.git / commitdiff
