tree-wide: change option_parse() to return option and arg via internal state (#41833)

src/ac-power/ac-power.c

@@ -41,10 +41,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -61,7 +60,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/ask-password/ask-password.c

@@ -73,10 +73,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -85,13 +84,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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,
@@ -99,15 +98,15 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -117,7 +116,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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"):
@@ -133,11 +132,11 @@ static int parse_argv(int argc, char *argv[]) {
                         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"):
@@ -146,7 +145,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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"):
@@ -172,7 +171,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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, " ");

src/battery-check/battery-check.c

@@ -81,9 +81,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -93,7 +93,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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);

src/binfmt/binfmt.c

@@ -139,10 +139,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -167,7 +166,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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),

src/bless-boot/bless-boot.c

@@ -79,10 +79,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -91,13 +90,13 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 }
 

src/bless-boot/boot-check-no-failures.c

@@ -44,9 +44,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:

src/bootctl/bootctl.c

@@ -416,10 +416,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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"): {}
@@ -464,53 +463,53 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 
@@ -519,7 +518,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -540,17 +539,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
 
@@ -559,7 +558,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -570,23 +569,23 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -597,20 +596,20 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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)
@@ -618,13 +617,13 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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)
@@ -632,7 +631,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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),

src/cgls/cgls.c

@@ -69,11 +69,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -97,7 +96,7 @@ static int parse_argv(int argc, char *argv[]) {
                                                 "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;
 
@@ -108,17 +107,17 @@ static int parse_argv(int argc, char *argv[]) {
                                                 "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;
 
@@ -128,10 +127,10 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -147,11 +146,11 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
                 }
@@ -160,7 +159,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 }

src/cgtop/cgtop.c

@@ -719,11 +719,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -734,11 +733,11 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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"):
@@ -767,12 +766,12 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -786,7 +785,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -794,19 +793,19 @@ static int parse_argv(int argc, char *argv[]) {
                         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"):
@@ -819,22 +818,22 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 }

src/core/executor.c

@@ -62,10 +62,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -75,39 +74,39 @@ static int parse_argv(int argc, char *argv[]) {
                         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);

src/creds/creds.c

@@ -823,11 +823,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -845,7 +844,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -856,19 +855,19 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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");
 
@@ -877,7 +876,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -888,45 +887,45 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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");
 
@@ -943,23 +942,23 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -967,14 +966,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -985,12 +984,12 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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,
@@ -1001,7 +1000,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                                                 /* 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;
 
@@ -1053,7 +1052,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
 }
 

src/cryptenroll/cryptenroll.c

@@ -276,11 +276,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -301,7 +300,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -314,7 +313,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
 
@@ -331,8 +330,8 @@ static int parse_argv(int argc, char *argv[]) {
 
                         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();
                         }
@@ -352,8 +351,8 @@ static int parse_argv(int argc, char *argv[]) {
 
                         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();
                         }
@@ -389,22 +388,22 @@ static int parse_argv(int argc, char *argv[]) {
                             "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();
                         }
@@ -420,15 +419,15 @@ static int parse_argv(int argc, char *argv[]) {
                             "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();
                         }
@@ -440,28 +439,28 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -469,7 +468,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -477,7 +476,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -489,15 +488,15 @@ static int parse_argv(int argc, char *argv[]) {
                             "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();
                         }
@@ -513,7 +512,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
 
@@ -522,14 +521,14 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -537,13 +536,13 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -552,21 +551,21 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -574,13 +573,13 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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),

src/cryptsetup/cryptsetup.c

@@ -2505,10 +2505,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -2518,7 +2517,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return version();
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/delta/delta.c

@@ -517,11 +517,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -535,7 +534,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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.");
@@ -544,14 +543,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 }
 

src/detect-virt/detect-virt.c

@@ -53,10 +53,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -95,7 +94,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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);

src/dissect/dissect.c

@@ -230,11 +230,9 @@ static int parse_argv(int argc, char *argv[]) {
         assert(argc >= 0);
         assert(argv);
 
-        OptionParser state = { argc, argv };
-        const Option *current;
-        const char *arg;
+        OptionParser opts = { argc, argv };
 
-        FOREACH_OPTION_FULL(&state, c, &current, &arg, /* on_error= */ return c)
+        FOREACH_OPTION(c, &opts, /* on_error= */ return c)
                 switch (c) {
 
                 OPTION_COMMON_NO_PAGER:
@@ -260,15 +258,15 @@ static int parse_argv(int argc, char *argv[]) {
                 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"
@@ -276,7 +274,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
@@ -290,18 +288,18 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
@@ -317,20 +315,20 @@ static int parse_argv(int argc, char *argv[]) {
                         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);
@@ -341,44 +339,44 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -391,13 +389,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -420,9 +418,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -430,7 +428,7 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -518,7 +516,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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) {
 

src/escape/escape-tool.c

@@ -56,10 +56,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -69,20 +68,20 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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"):
@@ -103,7 +102,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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.");
 
@@ -131,7 +130,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
 }
 

src/factory-reset/factory-reset-tool.c

@@ -70,10 +70,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -96,7 +95,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         if (r > 0)
                 arg_varlink = true;
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/firstboot/firstboot.c

@@ -1267,11 +1267,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -1281,61 +1280,61 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -1349,13 +1348,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -1365,15 +1364,15 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -1381,13 +1380,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -1462,21 +1461,21 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/growfs/growfs.c

@@ -160,10 +160,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -177,12 +176,12 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 }

src/hibernate-resume/hibernate-resume.c

@@ -55,10 +55,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -73,11 +72,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 }
 

src/hostname/hostnamectl.c

@@ -765,10 +765,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -782,11 +781,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -804,7 +803,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -814,7 +813,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/hwdb/hwdb.c

@@ -81,10 +81,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -99,7 +98,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
 
                 OPTION('r', "root", "PATH", "Alternative root path in the filesystem"):
-                        arg_root = arg;
+                        arg_root = opts.arg;
                         break;
 
                 OPTION_LONG("usr", NULL,
@@ -108,7 +107,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/id128/id128.c

@@ -237,10 +237,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -258,7 +257,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -279,11 +278,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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"):
@@ -291,7 +290,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/imds/imds-tool.c

@@ -82,10 +82,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -98,32 +97,32 @@ static int parse_argv(int argc, char *argv[]) {
                        "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;
@@ -131,7 +130,7 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -147,8 +146,8 @@ static int parse_argv(int argc, char *argv[]) {
                         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)

src/imds/imdsd.c

@@ -2249,10 +2249,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -2262,30 +2261,30 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -2295,32 +2294,32 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -2330,12 +2329,12 @@ static int parse_argv(int argc, char *argv[]) {
                         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");
 
@@ -2351,139 +2350,139 @@ static int parse_argv(int argc, char *argv[]) {
                 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();
 
@@ -2512,8 +2511,8 @@ static int parse_argv(int argc, char *argv[]) {
         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)

src/import/export.c

@@ -238,10 +238,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -251,17 +250,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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"):
@@ -276,7 +275,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/import/import-fs.c

@@ -313,11 +313,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -331,7 +330,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -346,29 +345,29 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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"):
@@ -386,7 +385,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 }
 

src/import/import.c

@@ -317,10 +317,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -334,7 +333,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -349,7 +348,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -357,7 +356,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -365,14 +364,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -381,11 +380,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -394,11 +393,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -406,9 +405,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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"):
@@ -438,7 +437,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/import/importctl.c

@@ -1113,10 +1113,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -1139,11 +1138,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -1166,7 +1165,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -1179,21 +1178,21 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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"):
@@ -1202,9 +1201,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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"):
@@ -1225,9 +1224,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -1239,7 +1238,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/import/pull.c

@@ -364,10 +364,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -381,7 +380,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -390,7 +389,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                             "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;
@@ -398,10 +397,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                                 /* 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);
@@ -418,7 +417,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 }
 
                 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;
 
@@ -427,7 +426,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -440,7 +439,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 
@@ -448,7 +447,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -466,7 +465,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -474,7 +473,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -482,14 +481,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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);
@@ -498,11 +497,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -511,11 +510,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -523,16 +522,16 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -577,7 +576,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/journal-remote/journal-gatewayd.c

@@ -1118,11 +1118,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -1136,7 +1135,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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);
@@ -1150,7 +1149,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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);
@@ -1165,7 +1164,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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);
@@ -1191,19 +1190,19 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");
 

src/journal-remote/journal-remote-main.c

@@ -905,10 +905,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -918,19 +917,19 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -940,11 +939,11 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
                         }
@@ -955,24 +954,24 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
@@ -980,7 +979,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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
@@ -989,34 +988,34 @@ static int parse_argv(int argc, char *argv[]) {
                         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);
@@ -1034,31 +1033,31 @@ static int parse_argv(int argc, char *argv[]) {
                         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();
 

src/journal/bsod.c

@@ -247,11 +247,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -265,13 +264,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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);

src/journal/cat.c

@@ -59,11 +59,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -73,11 +72,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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.");
@@ -85,7 +84,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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.");
@@ -93,18 +92,18 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 }
 

src/keyutil/keyutil.c

@@ -87,11 +87,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -101,14 +100,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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)
@@ -116,14 +115,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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)
@@ -131,24 +130,24 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -157,7 +156,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/libsystemd-network/test-ndisc-send.c

@@ -78,88 +78,87 @@ static int parse_argv(int argc, char *argv[]) {
         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;
@@ -167,21 +166,21 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
@@ -190,7 +189,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -198,7 +197,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -206,14 +205,14 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -223,7 +222,7 @@ static int parse_argv(int argc, char *argv[]) {
                         _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");
 
@@ -235,7 +234,7 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;

src/libsystemd/sd-journal/test-journal-append.c

@@ -151,10 +151,9 @@ int main(int argc, char *argv[]) {
 
         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: {
@@ -180,27 +179,27 @@ int main(int argc, char *argv[]) {
                             "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;
@@ -215,7 +214,7 @@ int main(int argc, char *argv[]) {
                 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");
 

src/libudev/test-libudev.c

@@ -428,10 +428,9 @@ static int parse_args(int argc, char *argv[], const char **syspath, const char *
         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:
@@ -442,11 +441,11 @@ static int parse_args(int argc, char *argv[], const char **syspath, const char *
                         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"):

src/login/inhibit.c

@@ -200,11 +200,10 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -226,7 +225,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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;
@@ -236,21 +235,21 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                             "(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"):
@@ -258,7 +257,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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;

src/machine-id-setup/machine-id-setup-main.c

@@ -75,11 +75,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -95,19 +94,19 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -117,7 +116,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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");
 

src/measure/measure-tool.c

@@ -136,12 +136,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -163,7 +161,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                             "Specify a boot phase to sign for"): {
                         char *n;
 
-                        n = normalize_phase(arg);
+                        n = normalize_phase(opts.arg);
                         if (!n)
                                 return log_oom();
 
@@ -182,9 +180,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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();
@@ -196,11 +194,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                             "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();
                         }
@@ -210,7 +208,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 }
 
                 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;
 
@@ -218,7 +216,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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)
@@ -228,21 +226,21 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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)
@@ -250,7 +248,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -262,7 +260,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 
@@ -301,9 +299,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                                  "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;
@@ -349,7 +347,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
         log_debug("Measuring boot phases: %s", j);
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/modules-load/modules-load.c

@@ -359,9 +359,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -371,7 +371,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return version();
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/mute-console/mute-console.c

@@ -60,11 +60,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -74,13 +73,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/network/generator/network-generator-main.c

@@ -172,10 +172,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -186,11 +185,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 }
 

src/notify/notify.c

@@ -153,10 +153,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -184,28 +183,28 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                             "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"):
@@ -223,9 +222,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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 */
@@ -259,10 +258,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 }
 
                 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;
@@ -278,7 +277,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
         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) {
 

src/nspawn/nspawn.c

@@ -602,11 +602,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -630,19 +628,19 @@ static int parse_argv(int argc, char *argv[]) {
                          * 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;
@@ -668,7 +666,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -676,7 +674,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -690,27 +688,27 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -721,17 +719,17 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
                         }
@@ -741,11 +739,11 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
@@ -757,15 +755,15 @@ static int parse_argv(int argc, char *argv[]) {
                         _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);
@@ -774,16 +772,16 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
 
@@ -808,13 +806,13 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
@@ -828,38 +826,38 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -868,31 +866,31 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -901,7 +899,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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();
 
@@ -911,12 +909,12 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -930,7 +928,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -938,12 +936,12 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -954,9 +952,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -979,7 +977,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -988,7 +986,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -997,7 +995,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1013,19 +1011,19 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1037,7 +1035,7 @@ static int parse_argv(int argc, char *argv[]) {
                             "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();
 
@@ -1054,7 +1052,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1062,11 +1060,11 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -1077,11 +1075,11 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -1092,7 +1090,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -1102,7 +1100,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1113,8 +1111,8 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -1139,21 +1137,21 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 OPTION_LONG("restrict-address-families", "LIST", "Restrict socket address families to the given allowlist"):
-                        r = parse_address_families(optarg, &arg_restrict_address_families, &arg_restrict_address_families_is_allowlist);
+                        r = parse_address_families(opts.arg, &arg_restrict_address_families, &arg_restrict_address_families_is_allowlist);
                         if (r < 0)
-                                return log_error_errno(r, "Failed to parse --restrict-address-families= argument: %s", optarg);
+                                return log_error_errno(r, "Failed to parse --restrict-address-families= argument: %s", opts.arg);
 
                         arg_settings_mask |= SETTING_RESTRICT_ADDRESS_FAMILIES;
                         break;
 
                 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"): {}
@@ -1163,15 +1161,15 @@ static int parse_argv(int argc, char *argv[]) {
                         _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();
 
@@ -1194,9 +1192,9 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -1204,9 +1202,9 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -1214,42 +1212,42 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
 
@@ -1260,33 +1258,33 @@ static int parse_argv(int argc, char *argv[]) {
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-use= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-keep-free= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-file-size= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-files= value: %s", opts.arg);
                         break;
 
                 OPTION_GROUP("Mounts"): {}
@@ -1295,26 +1293,26 @@ static int parse_argv(int argc, char *argv[]) {
                             "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;
 
@@ -1322,19 +1320,19 @@ static int parse_argv(int argc, char *argv[]) {
                             "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;
@@ -1343,11 +1341,11 @@ static int parse_argv(int argc, char *argv[]) {
                             "Configure the shell to use for --bind-user= users"): {
                         bool copy = false;
                         char *sh = NULL;
-                        r = parse_user_shell(arg, &sh, &copy);
+                        r = parse_user_shell(opts.arg, &sh, &copy);
                         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;
@@ -1357,9 +1355,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -1367,12 +1365,12 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -1382,7 +1380,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -1391,7 +1389,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1399,7 +1397,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -1413,24 +1411,24 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -1444,7 +1442,7 @@ static int parse_argv(int argc, char *argv[]) {
                 }
         }
 
-        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);

src/oom/oomctl.c

@@ -91,10 +91,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_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:
@@ -108,7 +107,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/oom/oomd.c

@@ -51,10 +51,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -72,12 +71,12 @@ static int parse_argv(int argc, char *argv[]) {
                             "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.");
 

src/path/path-tool.c

@@ -204,10 +204,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -217,7 +216,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return version();
 
                 OPTION_LONG("suffix", "SUFFIX", "Suffix to append to paths"):
-                        arg_suffix = arg;
+                        arg_suffix = opts.arg;
                         break;
 
                 OPTION_COMMON_NO_PAGER:
@@ -225,7 +224,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/pcrextend/pcrextend.c

@@ -81,11 +81,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -101,9 +100,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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();
@@ -112,23 +111,23 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 }
 
                 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;
@@ -136,11 +135,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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();
                         }
@@ -156,7 +155,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -177,12 +176,12 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
                 }
 
@@ -208,7 +207,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return r;
         }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/pcrlock/pcrlock.c

@@ -5189,12 +5189,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -5208,7 +5207,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -5220,21 +5219,21 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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,
@@ -5248,7 +5247,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                             "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;
 
@@ -5266,15 +5265,15 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                         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();
 
@@ -5282,11 +5281,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                                 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();
                         }
@@ -5303,17 +5302,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
                         }
@@ -5323,10 +5322,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
                         }
@@ -5341,7 +5340,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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;
@@ -5372,7 +5371,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 arg_pager_flags |= PAGER_DISABLE;
         }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/ptyfwd/ptyfwd-tool.c

@@ -62,11 +62,10 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -84,22 +83,22 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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;
 }
 

src/random-seed/random-seed-tool.c

@@ -349,11 +349,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -363,7 +362,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 

src/repart/repart.c

@@ -9684,12 +9684,11 @@ static int parse_argv(int argc, char *argv[]) {
         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"): {}
@@ -9712,41 +9711,41 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9754,9 +9753,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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.");
 
@@ -9764,9 +9763,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -9775,15 +9774,15 @@ static int parse_argv(int argc, char *argv[]) {
                             "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)
@@ -9802,15 +9801,15 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
                         }
@@ -9819,7 +9818,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9830,14 +9829,14 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9847,7 +9846,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -9862,14 +9861,14 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9879,7 +9878,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -9887,7 +9886,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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)
@@ -9906,14 +9905,14 @@ static int parse_argv(int argc, char *argv[]) {
                 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)
@@ -9921,14 +9920,14 @@ static int parse_argv(int argc, char *argv[]) {
                         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)
@@ -9939,7 +9938,7 @@ static int parse_argv(int argc, char *argv[]) {
                             "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;
@@ -9948,7 +9947,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -9957,11 +9956,11 @@ static int parse_argv(int argc, char *argv[]) {
                             "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();
                         }
@@ -9973,7 +9972,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9981,15 +9980,15 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -9997,7 +9996,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10006,7 +10005,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -10014,7 +10013,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10029,7 +10028,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
 
@@ -10043,7 +10042,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
 
@@ -10053,7 +10052,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10061,7 +10060,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10069,7 +10068,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10079,7 +10078,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -10088,7 +10087,7 @@ static int parse_argv(int argc, char *argv[]) {
                             "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;
 
@@ -10102,10 +10101,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -10133,26 +10132,26 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -10161,7 +10160,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10169,10 +10168,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10180,10 +10179,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
 
@@ -10191,17 +10190,17 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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.");
 
@@ -10281,7 +10280,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;

src/report/report-basic-server.c

@@ -57,9 +57,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -68,7 +68,7 @@ static int parse_argv(int argc, char *argv[]) {
                         return version();
                 }
 
-        if (state.optind < argc)
+        if (opts.optind < argc)
                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                        "This program takes no arguments.");
 

src/report/report.c

@@ -985,10 +985,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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();
@@ -1013,7 +1012,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -1024,49 +1023,49 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
                 }
@@ -1074,7 +1073,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/sbsign/sbsign.c

@@ -93,11 +93,10 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -108,21 +107,21 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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)
@@ -130,7 +129,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -138,7 +137,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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)
@@ -151,14 +150,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -174,7 +173,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/shared/options.c

@@ -70,9 +70,7 @@ static int partial_match_error(
 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) {
@@ -96,7 +94,7 @@ int option_parse(
                 /* 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
@@ -106,7 +104,7 @@ int option_parse(
                         }
 
                         if (state->parsing_stopped)
-                                return 0;
+                                goto finished;
 
                         if (state->argv[state->optind][0] == '-' &&
                             state->argv[state->optind][1] != '\0')
@@ -115,7 +113,7 @@ int option_parse(
 
                         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) {
@@ -254,17 +252,14 @@ int option_parse(
         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) {

src/shared/options.h

@@ -59,52 +59,71 @@ typedef struct Option {
 #define OPTION_POSITIONAL OPTION_FULL(OPTION_POSITIONAL_ENTRY, /* sc= */ 0, "(positional)", /* mv= */ NULL, /* h= */ NULL)
 #define OPTION_HELP_VERBATIM(lc, h) OPTION_FULL(OPTION_HELP_ENTRY_VERBATIM, /* sc= */ 0, lc, /* mv= */ NULL, h)
 
-#define OPTION_COMMON_HELP \
+#define OPTION_COMMON_HELP                                              \
         OPTION('h', "help", NULL, "Show this help")
-#define OPTION_COMMON_VERSION \
+
+#define OPTION_COMMON_VERSION                                           \
         OPTION_LONG("version", NULL, "Show package version")
-#define OPTION_COMMON_NO_PAGER \
+
+#define OPTION_COMMON_NO_PAGER                                          \
         OPTION_LONG("no-pager", NULL, "Do not start a pager")
-#define OPTION_COMMON_NO_LEGEND \
+
+#define OPTION_COMMON_NO_LEGEND                                         \
         OPTION_LONG("no-legend", NULL, "Do not show headers and footers")
-#define OPTION_COMMON_LOG_LEVEL \
-        OPTION_LONG("log-level", "LEVEL", \
+
+#define OPTION_COMMON_LOG_LEVEL                                         \
+        OPTION_LONG("log-level", "LEVEL",                               \
                     "Set log level (debug, info, notice, warning, err, crit, alert, emerg)")
-#define OPTION_COMMON_LOG_TARGET \
-        OPTION_LONG("log-target", "TARGET", \
+
+#define OPTION_COMMON_LOG_TARGET                                        \
+        OPTION_LONG("log-target", "TARGET",                             \
                     "Set log target (console, journal, journal-or-kmsg, kmsg, null)")
-#define OPTION_COMMON_LOG_COLOR \
+
+#define OPTION_COMMON_LOG_COLOR                                         \
         OPTION_LONG("log-color", "BOOL", "Highlight important messages")
-#define OPTION_COMMON_LOG_LOCATION \
+
+#define OPTION_COMMON_LOG_LOCATION                                      \
         OPTION_LONG("log-location", "BOOL", "Include code location in messages")
-#define OPTION_COMMON_LOG_TIME \
+
+#define OPTION_COMMON_LOG_TIME                                          \
         OPTION_LONG("log-time", "BOOL", "Prefix messages with current time")
-#define OPTION_COMMON_CAT_CONFIG \
+
+#define OPTION_COMMON_CAT_CONFIG                                        \
         OPTION_LONG("cat-config", NULL, "Show configuration files")
-#define OPTION_COMMON_TLDR \
+
+#define OPTION_COMMON_TLDR                                              \
         OPTION_LONG("tldr", NULL, "Show non-comment parts of configuration")
-#define OPTION_COMMON_NO_ASK_PASSWORD \
+
+#define OPTION_COMMON_NO_ASK_PASSWORD                                   \
         OPTION_LONG("no-ask-password", NULL, "Do not prompt for password")
-#define OPTION_COMMON_HOST \
+
+#define OPTION_COMMON_HOST                                              \
         OPTION('H', "host", "[USER@]HOST", "Operate on remote host")
-#define OPTION_COMMON_MACHINE \
+
+#define OPTION_COMMON_MACHINE                                           \
         OPTION('M', "machine", "CONTAINER", "Operate on local container")
-#define OPTION_COMMON_JSON \
+
+#define OPTION_COMMON_JSON                                              \
         OPTION_LONG("json", "FORMAT", "Generate JSON output (pretty, short, or off)")
-#define OPTION_COMMON_LOWERCASE_J \
-        OPTION_SHORT('j', NULL, \
+
+#define OPTION_COMMON_LOWERCASE_J                                       \
+        OPTION_SHORT('j', NULL,                                         \
                      "Equivalent to --json=pretty (on TTY) or --json=short (otherwise)")
-#define OPTION_COMMON_PRIVATE_KEY(purpose) \
+
+#define OPTION_COMMON_PRIVATE_KEY(purpose)                              \
         OPTION_LONG("private-key", "PATH|URI", purpose)
-#define OPTION_COMMON_PRIVATE_KEY_SOURCE \
-        OPTION_LONG("private-key-source", "SOURCE", \
-                    "Specify how to use the private key " \
+
+#define OPTION_COMMON_PRIVATE_KEY_SOURCE                                \
+        OPTION_LONG("private-key-source", "SOURCE",                     \
+                    "Specify how to use the private key "               \
                     "(file, provider:PROVIDER, engine:ENGINE)")
-#define OPTION_COMMON_CERTIFICATE(purpose) \
-        OPTION_LONG("certificate", "PATH|URI", purpose \
+
+#define OPTION_COMMON_CERTIFICATE(purpose)                              \
+        OPTION_LONG("certificate", "PATH|URI", purpose                  \
                     ", or a provider-specific designation if --certificate-source= is used")
-#define OPTION_COMMON_CERTIFICATE_SOURCE \
-        OPTION_LONG("certificate-source", "SOURCE", \
+
+#define OPTION_COMMON_CERTIFICATE_SOURCE                                \
+        OPTION_LONG("certificate-source", "SOURCE",                     \
                     "Specify how to interpret the certificate from --certificate=. " \
                     "Allows the certificate to be loaded from an OpenSSL provider " \
                     "(file, provider:PROVIDER)")
@@ -147,26 +166,26 @@ typedef struct OptionParser {
                                        * 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);
 

src/shutdown/shutdown.c

@@ -63,33 +63,32 @@ static int parse_argv(int argc, char *argv[]) {
         /* 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);
 
@@ -97,10 +96,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
 
@@ -108,10 +107,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
 
@@ -119,23 +118,23 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;

src/sleep/sleep.c

@@ -729,9 +729,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -741,7 +741,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return version();
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/socket-activate/socket-activate.c

@@ -355,11 +355,10 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -370,7 +369,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
 
                 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();
 
@@ -402,16 +401,16 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                 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();
 
@@ -443,7 +442,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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.",

src/socket-proxy/socket-proxyd.c

@@ -420,11 +420,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -435,9 +434,9 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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),
@@ -447,13 +446,13 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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.");

src/ssh-generator/ssh-issue.c

@@ -159,12 +159,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -175,18 +174,18 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 
@@ -202,12 +201,12 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
         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();
 

src/stdio-bridge/stdio-bridge.c

@@ -46,11 +46,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -69,11 +68,11 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -83,7 +82,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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);

src/storagetm/storagetm.c

@@ -77,11 +77,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -92,10 +91,10 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -113,7 +112,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");

src/sysctl/sysctl.c

@@ -360,10 +360,9 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -384,7 +383,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
 
                 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);
@@ -416,7 +415,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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),

src/sysupdate/sysupdate.c

@@ -1862,11 +1862,10 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -1880,18 +1879,18 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
 
                 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;
 
@@ -1899,35 +1898,35 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
 
                 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;
 
@@ -1935,15 +1934,15 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
 
                 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;
@@ -1952,7 +1951,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                             "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;
 
@@ -1979,7 +1978,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         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;
 
@@ -1995,7 +1994,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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;
 }
 

src/sysupdate/updatectl.c

@@ -1687,10 +1687,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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"):
@@ -1707,7 +1706,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 OPTION_COMMON_HOST:
                         arg_transport = BUS_TRANSPORT_REMOTE;
-                        arg_host = arg;
+                        arg_host = opts.arg;
                         break;
 
                 OPTION_COMMON_NO_PAGER:
@@ -1727,7 +1726,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         return version();
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/sysusers/sysusers.c

@@ -2101,10 +2101,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -2124,32 +2123,32 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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"):
@@ -2165,8 +2164,8 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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),

src/test/test-chase-manual.c

@@ -37,18 +37,16 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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"):
@@ -64,11 +62,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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.");
 

src/test/test-options.c

@@ -32,34 +32,32 @@ static void test_option_parse_one(
         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(
@@ -78,11 +76,9 @@ 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);
 }
 
@@ -736,7 +732,7 @@ TEST(option_optional_arg) {
 }
 
 /* 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,
@@ -756,27 +752,25 @@ static void test_macros_parse_one(
         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++;
 
@@ -828,9 +822,11 @@ static void test_macros_parse_one(
 
         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) {
@@ -1202,19 +1198,19 @@ TEST(option_optional_arg_consume) {
                 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 */
@@ -1222,19 +1218,19 @@ TEST(option_optional_arg_consume) {
                 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 */
@@ -1242,24 +1238,24 @@ TEST(option_optional_arg_consume) {
                 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,
@@ -1268,20 +1264,20 @@ TEST(option_optional_arg_consume) {
                 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) {
@@ -1290,15 +1286,17 @@ TEST(option_optional_arg_consume) {
                                 } 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);
         }
 }
 

src/timedate/timedatectl.c

@@ -947,11 +947,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         assert(argc >= 0);
         assert(argv);
 
-        OptionParser state = { argc, argv };
-        const Option *current;
-        const char *arg;
+        OptionParser opts = { argc, argv };
 
-        FOREACH_OPTION_FULL(&state, c, &current, &arg, /* on_error= */ return c)
+        FOREACH_OPTION(c, &opts, /* on_error= */ return c)
                 switch (c) {
                 OPTION_COMMON_HELP:
                         return help();
@@ -969,11 +967,11 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
@@ -988,14 +986,14 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
                 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;
 
@@ -1008,7 +1006,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         break;
                 }
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/tmpfiles/test-offline-passwd.c

@@ -43,18 +43,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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;
 }
 

src/tmpfiles/tmpfiles.c

@@ -4187,10 +4187,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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"):
@@ -4240,12 +4239,12 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -4256,13 +4255,13 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
 
@@ -4273,20 +4272,20 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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"):
@@ -4302,8 +4301,8 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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),

src/tpm2-setup/tpm2-clear.c

@@ -50,9 +50,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -66,7 +66,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/tpm2-setup/tpm2-setup.c

@@ -76,10 +76,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -89,17 +88,17 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -109,7 +108,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/tty-ask-password-agent/tty-ask-password-agent.c

@@ -472,11 +472,10 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -509,19 +508,19 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
 

src/udev/ata_id/ata_id.c

@@ -377,10 +377,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -395,7 +394,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");
 

src/udev/cdrom_id/cdrom_id.c

@@ -918,10 +918,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -953,7 +952,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");
 

src/udev/dmi_memory_id/dmi_memory_id.c

@@ -662,10 +662,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -676,11 +675,11 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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.");
 

src/udev/fido_id/fido_id.c

@@ -47,10 +47,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -60,7 +59,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");
 

src/udev/iocost/iocost.c

@@ -84,10 +84,9 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
         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:
@@ -97,7 +96,7 @@ static int parse_argv(int argc, char *argv[], char ***remaining_args) {
                         return version();
                 }
 
-        *remaining_args = option_parser_get_args(&state);
+        *remaining_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/udev/mtd_probe/mtd_probe.c

@@ -54,10 +54,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -67,7 +66,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");
 

src/udev/scsi_id/scsi_id.c

@@ -225,11 +225,10 @@ static int set_options(int argc, char **argv, char *maj_min_dev) {
         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:
@@ -240,26 +239,26 @@ static int set_options(int argc, char **argv, char *maj_min_dev) {
 
                 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"): {}
@@ -287,7 +286,7 @@ static int set_options(int argc, char **argv, char *maj_min_dev) {
                         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]);
@@ -315,26 +314,24 @@ static int per_dev_options(struct scsi_id_device *dev_scsi, int *good_bad, enum
         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;
 }

src/udev/v4l_id/v4l_id.c

@@ -41,10 +41,9 @@ static int parse_argv(int argc, char *argv[]) {
         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:
@@ -54,7 +53,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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.");

src/update-done/update-done.c

@@ -96,10 +96,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -108,13 +107,13 @@ static int parse_argv(int argc, char *argv[]) {
                         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;

src/validatefs/validatefs.c

@@ -64,10 +64,9 @@ static int parse_argv(int argc, char *argv[]) {
         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();
@@ -76,21 +75,21 @@ static int parse_argv(int argc, char *argv[]) {
                         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),

src/varlinkctl/varlinkctl.c

@@ -124,10 +124,9 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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:
@@ -165,7 +164,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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;
@@ -179,25 +178,25 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                         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.");
@@ -223,17 +222,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                                 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 */
@@ -253,7 +252,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
 
         strv_sort_uniq(arg_graceful);
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }
 

src/vmspawn/vmspawn.c

@@ -325,11 +325,9 @@ static int parse_argv(int argc, char *argv[]) {
         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, &current, &arg, /* on_error= */ return c)
+        FOREACH_OPTION(c, &opts, /* on_error= */ return c)
                 switch (c) {
 
                 OPTION_COMMON_HELP:
@@ -361,7 +359,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -371,31 +369,31 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -403,34 +401,34 @@ static int parse_argv(int argc, char *argv[]) {
                 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);
 
@@ -439,28 +437,28 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -468,31 +466,31 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -500,14 +498,14 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -528,7 +526,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
 
@@ -545,14 +543,14 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -567,7 +565,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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);
@@ -577,7 +575,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
@@ -585,12 +583,12 @@ static int parse_argv(int argc, char *argv[]) {
                                 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;
 
@@ -601,13 +599,13 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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);
@@ -622,7 +620,7 @@ static int parse_argv(int argc, char *argv[]) {
                                 return 0;
                         }
 
-                        _cleanup_strv_free_ char **features = strv_split(arg, ",");
+                        _cleanup_strv_free_ char **features = strv_split(opts.arg, ",");
                         if (!features)
                                 return log_oom();
 
@@ -636,39 +634,39 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
@@ -676,25 +674,25 @@ static int parse_argv(int argc, char *argv[]) {
                 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"): {}
@@ -702,21 +700,21 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -730,7 +728,7 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
@@ -739,10 +737,11 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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;
                 }
 
@@ -751,7 +750,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
 
@@ -767,10 +766,10 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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;
 
@@ -778,11 +777,11 @@ static int parse_argv(int argc, char *argv[]) {
                             "Configure the shell to use for --bind-user= users"): {
                         bool copy = false;
                         char *sh = NULL;
-                        r = parse_user_shell(arg, &sh, &copy);
+                        r = parse_user_shell(opts.arg, &sh, &copy);
                         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;
@@ -790,61 +789,61 @@ static int parse_argv(int argc, char *argv[]) {
                 }
 
                 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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-use= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-keep-free= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-file-size= value: %s", opts.arg);
                         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);
+                                return log_error_errno(r, "Failed to parse --forward-journal-max-files= value: %s", opts.arg);
                         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;
@@ -853,15 +852,15 @@ static int parse_argv(int argc, char *argv[]) {
 
                 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 */
@@ -869,7 +868,7 @@ static int parse_argv(int argc, char *argv[]) {
                         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;
@@ -877,14 +876,14 @@ static int parse_argv(int argc, char *argv[]) {
                 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;
@@ -931,7 +930,7 @@ static int parse_argv(int argc, char *argv[]) {
                 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)

src/vpick/vpick-tool.c

@@ -99,71 +99,70 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         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);
                         }
@@ -193,17 +192,17 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
                 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");
 
@@ -214,7 +213,7 @@ static int parse_argv(int argc, char *argv[], char ***ret_args) {
         if (arg_print < 0)
                 arg_print = PRINT_PATH;
 
-        *ret_args = option_parser_get_args(&state);
+        *ret_args = option_parser_get_args(&opts);
         return 1;
 }