../src/argconfig.c

Bug Summary

File:	.build-ci/../src/argconfig.c
Warning:	line 343, column 12 Potential leak of memory pointed to by 'name'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name argconfig.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -fcoverage-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -resource-dir /usr/bin/../lib/clang/22 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I nvme.p -I . -I .. -I src -I ../src -I ccan -I ../ccan -I libnvme/src -I ../libnvme/src -I /usr/include/json-c -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/bin/../lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/16/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu11 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-opt-analyze-headers -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-10-24-125112-639-1 -x c ../src/argconfig.c

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
* This file is part of nvme-cli.
* Copyright (c) 2014 PMC-Sierra, Inc.
* Copyright (c) 2026 SUSE Software Solutions
*
* Authors: Logan Gunthorpe <logang@deltatee.com>
*          Daniel Wagner <dwagner@suse.de>
*/

11#include <ctype.h>
12#include <errno(*__errno_location ()).h>
13#include <inttypes.h>
14#include <limits.h>
15#include <locale.h>
16#include <stdarg.h>
17#include <stdbool.h>
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <unistd.h>

23#include <libnvme.h>

25#include <shared/parse-util.h>
26#include <shared/string-util.h>
27#include <shared/suffix-util.h>
28#include <shared/wrap-util.h>

30#include "argconfig.h"
31#include "cleanup.h"

33static bool_Bool is_null_or_empty(const char *s)
34{
return !s || !*s;
36}

38static const char *append_usage_str = "";

40/*
* Options every command accepts, registered once instead of being added to
* each command's table. They are looked up before the command's own
* options, so a global option means the same for every command; a command
* must not use their names.
*/
46static struct argconfig_commandline_options *global_options;

48/* Forget the options given before, also those of included tables */
49static void argconfig_reset_seen(struct argconfig_commandline_options *s)
50{
for (; s->option; s++) {
if (s->config_type == CFG_INCLUDE)
	argconfig_reset_seen(s->default_value);
s->seen = false0;
}
56}

58/* None of the global options counts as given yet */
59void argconfig_set_global_options(struct argconfig_commandline_options *options)
60{
global_options = options;
if (options)
argconfig_reset_seen(options);
64}

66struct argconfig_commandline_options *argconfig_get_global_options(void)
67{
return global_options;
69}

71/* The entries of a root, see argconfig_root() */
72#define ARGCONFIG_ROOT_LEN3	3

74/*
* The options a command accepts: its table @options and the global
* options, each as an include with the heading of the help. The global
* options are included last, as root[1]. The table of the global options
* themselves includes nothing else.
*/
80static void argconfig_root(struct argconfig_commandline_options *root,
	   struct argconfig_commandline_options *options)
82{
struct argconfig_commandline_options r[ARGCONFIG_ROOT_LEN3] = {
OPT_INCLUDE(options, "Options"){"", 0, ((void*)0), CFG_INCLUDE, options, ARGCONFIG_ARG_NONE,
 "Options", 0, ((void*)0)},
OPT_INCLUDE(global_options, "Global options"){"", 0, ((void*)0), CFG_INCLUDE, global_options, ARGCONFIG_ARG_NONE
, "Global options", 0, ((void*)0)},
OPT_END(){ ((void*)0) }
};
struct argconfig_commandline_options end[] = { OPT_END(){ ((void*)0) } };

memcpy(root, r, sizeof(r));
if (!global_options || options == global_options)
memcpy(&root[1], end, sizeof(end));
93}

95void argconfig_append_usage(const char *str)
96{
append_usage_str = str;
98}

100/* "nvme" and "id ctrl" of the current command, for the usage errors */
101static const char *command_prog;
102static const char *command_path;
103/* argv[0] of the current parse, if no command is set */
104static const char *parse_argv0 = "";

106void argconfig_set_command(const char *prog, const char *path)
107{
command_prog = prog;
command_path = path;
110}

112static const char *command_name(void)
113{
return command_path ? command_path : parse_argv0;
115}

117static void print_label(const char *name)
118{
fprintf(stderrstderr, "%s%s:%s ", argconfig_esc(stderrstderr, ARGCONFIG_RED"\033[31m"), name,
argconfig_esc(stderrstderr, ARGCONFIG_RESET"\033[0m"));
121}

123/* "<command>: " before an error of the current command, if one runs */
124void argconfig_print_error_label(void)
125{
if (command_path)
print_label(command_path);
128}

130/* An error of the current command, or of nvme-cli before one runs */
131void argconfig_error(const char *fmt, ...)
132{
va_list ap;

print_label(command_name());
va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderrstderr, fmt, ap);
va_end(ap)__builtin_va_end(ap);
fprintf(stderrstderr, "\n");
140}

142/* The synopsis and where to find the help, after a usage error */
143void argconfig_print_usage(void)
144{
fprintf(stderrstderr, "Usage: %s\n", append_usage_str);
if (command_prog && command_path)
fprintf(stderrstderr, "Try '%s %s --help' for more information.\n",
	command_prog, command_path);
149}

151/* A usage error of the current command, followed by its usage */
152int argconfig_usage_error(const char *fmt, ...)
153{
va_list ap;

print_label(command_name());
va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderrstderr, fmt, ap);
va_end(ap)__builtin_va_end(ap);
fprintf(stderrstderr, "\n");
argconfig_print_usage();

return -EINVAL22;
164}

166/* The names an option accepts, below its description */
167static void show_value_names(FILE *out, const struct argconfig_opt_val *v)
168{
__cleanup_free__attribute__((cleanup(shr_freep))) char *names = NULL((void*)0);
size_t len = sizeof("\nNames:");
const struct argconfig_opt_val *n;
char *p;

if (!v || !v->str)
return;

for (n = v; n->str; n++)
len += strlen(n->str) + 2;

names = malloc(len);
if (!names)
return;

p = names + snprintf(names, len, "\nNames:");
for (n = v; n->str; n++)
p += snprintf(p, len - (p - names), " %s%s", n->str,
	      n[1].str ? "," : "");

shr_print_word_wrapped(names, 44, 44, out);
190}

192static void show_option(FILE *out,
	const struct argconfig_commandline_options *option)
194{
const char *meta = option->meta ? option->meta : "arg";
enum argconfig_argument arg = option->argument_type;
char buffer[0x1000];
size_t len = 0;

buffer[0] = '\0';
shr_snprintf_append(buffer, sizeof(buffer), &len, "  [ ");
if (option->option) {
shr_snprintf_append(buffer, sizeof(buffer), &len, " --%s",
		    option->option);
if (arg == ARGCONFIG_ARG_OPTIONAL)
	shr_snprintf_append(buffer, sizeof(buffer), &len,
			    "[=<%s>]", meta);
if (arg == ARGCONFIG_ARG_REQUIRED)
	shr_snprintf_append(buffer, sizeof(buffer), &len,
			    "=<%s>", meta);
if (option->short_option)
	shr_snprintf_append(buffer, sizeof(buffer), &len, ",");
}
if (option->short_option) {
shr_snprintf_append(buffer, sizeof(buffer), &len, " -%c",
		    option->short_option);
if (arg == ARGCONFIG_ARG_OPTIONAL)
	shr_snprintf_append(buffer, sizeof(buffer), &len,
			    " [<%s>]", meta);
if (arg == ARGCONFIG_ARG_REQUIRED)
	shr_snprintf_append(buffer, sizeof(buffer), &len,
			    " <%s>", meta);
}
shr_snprintf_append(buffer, sizeof(buffer), &len, " ] ");

fprintf(out, "%s", buffer);
if (option->help) {
shr_print_word_wrapped("--- ", 40, len, out);
shr_print_word_wrapped(option->help, 44, 44, out);
show_value_names(out, option->opt_val);
}
fprintf(out, "\n");
233}

235/*
* Escape sequences for bold and colors go only to a terminal, and not
* when NO_COLOR is set to a non-empty value (https://no-color.org/).
*/
239const char *argconfig_esc(FILE *out, const char *seq)
240{
const char *no_color = getenv("NO_COLOR");

if (!isatty(fileno(out)) || (no_color && *no_color))
return "";

return seq;
247}

249/* "WARNING:" on stderr, in yellow on a terminal */
250void argconfig_print_warning(void)
251{
fprintf(stderrstderr, "%sWARNING:%s", argconfig_esc(stderrstderr, ARGCONFIG_YELLOW"\033[33m"),
argconfig_esc(stderrstderr, ARGCONFIG_RESET"\033[0m"));
254}

256/* A heading, in bold on a terminal */
257void argconfig_print_heading(FILE *out, const char *fmt, const char *text)
258{
fputs(argconfig_esc(out, ARGCONFIG_BOLD"\033[1m"), out);
fprintf(out, fmt, text);
fputs(argconfig_esc(out, ARGCONFIG_RESET"\033[0m"), out);
262}

264/* A group header is printed before the first option which follows it */
265static void print_options(FILE *out, struct argconfig_commandline_options *s,
	  const char *header)
267{
bool_Bool header_printed = false0;

for (; s && s->option; s++) {
if (s->config_type == CFG_INCLUDE) {
	print_options(out, s->default_value, s->help);
	/* the own options after it get their heading again */
	header_printed = false0;
	continue;
}
if (s->config_type == CFG_GROUP_SEPARATOR) {
	header = s->help;
	header_printed = false0;
	continue;
}
if (!header_printed) {
	fputc('\n', out);
	argconfig_print_heading(out, "%s:", header);
	fputc('\n', out);
	header_printed = true1;
}
if (!s->deprecated)
	show_option(out, s);
}
291}

293static void show_help(FILE *out, const char *program_desc,
      struct argconfig_commandline_options *root)
295{
argconfig_print_heading(out, "Usage: %s", append_usage_str);
fputs("\n\n", out);

shr_print_word_wrapped(program_desc, 0, 0, out);
fputc('\n', out);

print_options(out, root, "Options");
303}

305static bool_Bool help_requested;

307/* True once argconfig_parse() printed the help -h or --help asked for */
308bool_Bool argconfig_help_requested(void)
309{
return help_requested;
311}

313static bool_Bool argconfig_is_string(enum argconfig_types type)
314{
return type == CFG_STRING || type == CFG_FILE || type == CFG_DIR;
316}

318/* @u is in the range of @s, if it has one */
319bool_Bool argconfig_in_range(const struct argconfig_commandline_options *s,
	uint64_t u)
321{
return !s->max || (u >= s->min && u <= s->max);
323}

325static struct argconfig_opt_val *
326argconfig_match_val(struct argconfig_opt_val *v, const char *str);

328/* The bits the names in the comma-separated list @arg stand for */
329static int argconfig_parse_enum_list(struct argconfig_commandline_options *s,
		     const char *arg, uint32_t *bits)
331{
__cleanup_free__attribute__((cleanup(shr_freep))) char *list = strdup(arg);
4
←
Memory is allocated→
struct argconfig_opt_val *v;
char *p = list, *name;

if (!list)
5
←
Assuming 'list' is non-null→
6
←
Taking false branch→
return -ENOMEM12;

*bits = 0;
while ((name = shr_strsep(&p, ",")) != NULL((void*)0)) {
v = s->opt_val ? argconfig_match_val(s->opt_val, name) : NULL((void*)0);
7
←
Loop condition is true.  Entering loop body→
8
←
Assuming field 'opt_val' is null→
9
←
'?' condition is false→
if (!v9.1
'v' is null
)
10
←
Taking true branch→
	return -EINVAL22;
11
←
Potential leak of memory pointed to by 'name'
*bits |= (uint32_t)v->val.int_val;
}

return 0;
348}

350/* An unsigned number up to @max, in the range of @s */
351static int argconfig_parse_u64(struct argconfig_commandline_options *s,
	       const char *arg, uint64_t max, uint64_t *u)
353{
int ret = shr_parse_u64(arg, max, u);

if (!ret && !argconfig_in_range(s, *u))
return -ERANGE34;

return ret;
360}

362static int argconfig_parse_type(struct argconfig_commandline_options *s,
		char *arg)
364{
void *value = s->default_value;
uint64_t u;
int64_t i;
double d;
int ret = 0;

/* only a string option can do without a value */
if (!arg && !argconfig_is_string(s->config_type) &&
1
Assuming 'arg' is non-null→
   s->config_type != CFG_FLAG && s->config_type != CFG_INCREMENT)
return -EINVAL22;

switch (s->config_type) {
2
←
Control jumps to 'case CFG_ENUM_LIST:'  at line 409→
case CFG_STRING:
case CFG_FILE:
case CFG_DIR:
*(char **)value = arg;
break;
case CFG_INT:
ret = shr_parse_s64(arg, INT_MIN(-2147483647 -1), INT_MAX2147483647, &i);
if (!ret)
	*(int *)value = i;
break;
case CFG_BYTE:
ret = argconfig_parse_u64(s, arg, UINT8_MAX(255), &u);
if (!ret)
	*(uint8_t *)value = u;
break;
case CFG_SHORT:
ret = argconfig_parse_u64(s, arg, UINT16_MAX(65535), &u);
if (!ret)
	*(uint16_t *)value = u;
break;
case CFG_POSITIVE:
ret = argconfig_parse_u64(s, arg, UINT32_MAX(4294967295U), &u);
if (!ret)
	*(uint32_t *)value = u;
break;
case CFG_INCREMENT:
*(int *)value += 1;
break;
case CFG_ENUM:
/* only the names, which argconfig_parse_val() looked up */
ret = -EINVAL22;
break;
case CFG_ENUM_LIST: {
uint32_t bits;

ret = argconfig_parse_enum_list(s, arg, &bits);
3
←
Calling 'argconfig_parse_enum_list'→
if (!ret)
	*(uint32_t *)value |= bits;
break;
}
case CFG_LONG:
ret = argconfig_parse_u64(s, arg, UINT64_MAX(18446744073709551615UL), &u);
if (!ret)
	*(uint64_t *)value = u;
break;
case CFG_LONG_SUFFIX: {
char *endptr;

/* the suffix parser takes whitespace and a sign */
if (!isdigit((unsigned char)*arg)((*__ctype_b_loc ())[(int) (((unsigned char)*arg))] & (unsigned
 short int) _ISdigit))
	return -EINVAL22;
ret = shr_suffix_binary_parse(arg, &endptr, &u);
if (!ret && !argconfig_in_range(s, u))
	ret = -ERANGE34;
if (!ret)
	*(uint64_t *)value = u;
break;
}
case CFG_DOUBLE:
ret = shr_parse_double(arg, &d);
if (!ret)
	*(double *)value = d;
break;
case CFG_FLAG:
*(bool_Bool *)value = true1;
break;
case CFG_GROUP_SEPARATOR:
case CFG_INCLUDE:
break;
}

return ret;
449}

451static void argconfig_set_opt_val(enum argconfig_types type, union argconfig_val *opt_val, void *val)
452{
switch (type) {
case CFG_FLAG:
*(bool_Bool *)val = opt_val->bool_val;
break;
case CFG_LONG_SUFFIX:
*(uint64_t *)val = opt_val->long_suffix;
break;
case CFG_POSITIVE:
*(uint32_t *)val = opt_val->positive;
break;
case CFG_INT:
case CFG_ENUM:
*(int *)val = opt_val->int_val;
break;
case CFG_LONG:
*(uint64_t *)val = opt_val->long_val;
break;
case CFG_DOUBLE:
*(double *)val = opt_val->double_val;
break;
case CFG_BYTE:
*(uint8_t *)val = opt_val->byte;
break;
case CFG_SHORT:
*(uint16_t *)val = opt_val->short_val;
break;
case CFG_INCREMENT:
*(int *)val = opt_val->increment;
break;
case CFG_STRING:
case CFG_FILE:
case CFG_DIR:
*(char **)val = opt_val->string;
break;
case CFG_ENUM_LIST:
case CFG_GROUP_SEPARATOR:
case CFG_INCLUDE:
break;
}
492}

494static struct argconfig_opt_val *
495argconfig_match_val(struct argconfig_opt_val *v, const char *str)
496{
size_t len = strlen(str);
struct argconfig_opt_val *match = NULL((void*)0);

/* an empty value is a prefix of every name */
if (!len)
return NULL((void*)0);

for (; v->str; v++) {
if (strncasecmp(str, v->str, len))
	continue;

if (len == strlen(v->str))
	return v;

if (match)
	return NULL((void*)0); /* multiple matches; input is ambiguous */

match = v;
}

return match;
518}

520/*
* Store the value which @str names in the value table of @s. False if
* the option has no value of that name.
*/
524bool_Bool argconfig_set_value_name(struct argconfig_commandline_options *s,
	      const char *str)
526{
struct argconfig_opt_val *v = s->opt_val;

if (v)
v = argconfig_match_val(v, str);
if (!v)
return false0;

argconfig_set_opt_val(v->type, &v->val, s->default_value);
return true1;
536}

538static int argconfig_parse_val(struct argconfig_commandline_options *s,
	       char *arg)
540{
/* the names of a list are looked up one by one */
if (arg && s->config_type != CFG_ENUM_LIST &&
   argconfig_set_value_name(s, arg))
return 0;

return argconfig_parse_type(s, arg);
547}

549/* The non-option arguments of the last successful argconfig_parse() */
550static struct {
char **argv;
int argc;
553} operands;

555int argconfig_nr_operands(void)
556{
return operands.argc;
558}

560char *argconfig_operand(int i)
561{
if (i < 0 || i >= operands.argc)
return NULL((void*)0);

return operands.argv[i];
566}

568/*
* The state of one parse. argv is not modified: the operands are collected
* in their own array, in the order they are given.
*/
572struct argconfig_parser {
int argc;
char **argv;
int ind;
/* the table of the command, the global options included */
struct argconfig_commandline_options root[ARGCONFIG_ROOT_LEN3];
/*
* Global options stop at the first operand, the subcommand. Their
* implicit -h, --help, -V and --version are recorded and the parse
* goes on.
*/
bool_Bool global;
bool_Bool help;
bool_Bool version;
char **operands;
int nr_operands;
588};

590/*
* Internal result of argconfig_parse_args(): an option was malformed. Like
* ARGCONFIG_HELP, it prints the help of a command.
*/
594#define ARGCONFIG_USAGE4	4

596/*
* The parse errors use the wording of glibc's getopt, which printed them
* before argconfig had its own parser.
*/
600static int argconfig_parse_error(struct argconfig_parser *p,
		 const char *fmt, ...)
602{
va_list ap;

print_label(command_name());
va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderrstderr, fmt, ap);
va_end(ap)__builtin_va_end(ap);
fprintf(stderrstderr, "\n");

return ARGCONFIG_USAGE4;
612}

614static struct argconfig_commandline_options *
615argconfig_find_long(struct argconfig_commandline_options *s,
    const char *name, size_t len)
617{
struct argconfig_commandline_options *o;

for (; s->option; s++) {
if (s->config_type == CFG_INCLUDE) {
	o = argconfig_find_long(s->default_value, name, len);
	if (o)
		return o;
	continue;
}
if (s->config_type == CFG_GROUP_SEPARATOR ||
    is_null_or_empty(s->option))
	continue;
if (strlen(s->option) == len && !strncmp(s->option, name, len))
	return s;
if (s->old_name && strlen(s->old_name) == len &&
    !strncmp(s->old_name, name, len))
	return s;
}

return NULL((void*)0);
638}

640static struct argconfig_commandline_options *
641argconfig_find_short(struct argconfig_commandline_options *s, char c)
642{
struct argconfig_commandline_options *o;

for (; s->option; s++) {
if (s->config_type == CFG_INCLUDE) {
	o = argconfig_find_short(s->default_value, c);
	if (o)
		return o;
	continue;
}
if (s->config_type == CFG_GROUP_SEPARATOR)
	continue;
if (s->short_option == c)
	return s;
}

return NULL((void*)0);
659}

661/*
* The option of @root with the long name @name, a global option first: a
* global option is the same for every command. &root[1] is the include
* of the global options alone.
*/
666static struct argconfig_commandline_options *
667argconfig_find_long_any(struct argconfig_commandline_options *root,
	const char *name, size_t len)
669{
struct argconfig_commandline_options *o;

o = argconfig_find_long(&root[1], name, len);

return o ? o : argconfig_find_long(root, name, len);
675}

677static struct argconfig_commandline_options *
678argconfig_find_short_any(struct argconfig_commandline_options *root, char c)
679{
struct argconfig_commandline_options *o;

o = argconfig_find_short(&root[1], c);

return o ? o : argconfig_find_short(root, c);
685}

687/* What a value of @s has to look like */
688static const char *argconfig_expected(struct argconfig_commandline_options *s)
689{
static char range[64];

if (s->max) {
snprintf(range, sizeof(range), "a number from %" PRIu64"l" "u"
	 " to %" PRIu64"l" "u", s->min, s->max);
return range;
}

switch (s->config_type) {
case CFG_BYTE:
return "a number from 0 to 255";
case CFG_SHORT:
return "a number from 0 to 65535";
case CFG_POSITIVE:
return "a number from 0 to 4294967295";
case CFG_LONG:
return "a number from 0 to 18446744073709551615";
case CFG_LONG_SUFFIX:
return "a size such as 4096 or 4Ki";
default:
return "a number";
}
712}

714/* @arg is no value of @s, given by its short name @c or its long name */
715static int argconfig_value_error(struct argconfig_commandline_options *s,
		 char c, const char *arg)
717{
__cleanup_free__attribute__((cleanup(shr_freep))) char *e = arg ? shr_escape(arg) : NULL((void*)0);
bool_Bool list = s->config_type == CFG_ENUM_LIST;
const struct argconfig_opt_val *v;
int n = 0;

print_label(command_name());
fprintf(stderrstderr, "invalid value '%s' for ", e ? e : "");
if (c)
fprintf(stderrstderr, "-%c", c);
else
fprintf(stderrstderr, "--%s", s->option);
fprintf(stderrstderr, ": expected ");
if (list)
fprintf(stderrstderr, "a comma-separated list of ");
else if (s->config_type != CFG_ENUM)
fprintf(stderrstderr, "%s%s", argconfig_expected(s),
	s->opt_val ? " or " : "");

/* A long list of names would drown the error, the help has them */
for (v = s->opt_val; v && v->str; v++)
n++;
if (n > 8)
fprintf(stderrstderr, "%sthe names in the help",
	list ? "" : "one of ");
for (v = s->opt_val; n <= 8 && v && v->str; v++)
fprintf(stderrstderr, "%s%s", v != s->opt_val ? ", " :
	list ? "" : "one of: ", v->str);
fprintf(stderrstderr, "\n");

/* "010" was octal once, say what to write instead */
if (arg && !list && s->config_type != CFG_ENUM &&
   shr_has_leading_zero(arg)) {
const char *d = arg;

while (d[0] == '0' && d[1])
	d++;
fprintf(stderrstderr,
	"a number must not start with 0: write %s, or 0x%s for hexadecimal\n",
	d, d);
}

return ARGCONFIG_USAGE4;
760}

762/* @s given by its short name @c, or by its long name without, and @arg */
763static int argconfig_apply(struct argconfig_commandline_options *s, char c,
	   char *arg)
765{
int ret;

if (s->deprecated && !s->seen) {
argconfig_print_warning();
if (c)
	fprintf(stderrstderr, " '-%c'", c);
else
	fprintf(stderrstderr, " '--%s'", s->option);
fprintf(stderrstderr,
	" is deprecated and will be removed in the next major version, use '%s' instead\n",
	s->deprecated);
}
s->seen = true1;

if (!s->default_value)
return 0;

ret = argconfig_parse_val(s, arg);
if (ret == -EINVAL22 || ret == -ERANGE34)
return argconfig_value_error(s, c, arg);

return ret;
788}

790/*
* A copy of the template table @tmpl, whose options store into the
* struct at @tmpl_base of @size bytes, bound to the struct of the same
* type at @base. Commands share the template and parse into their own
* struct. The caller frees the copy.
*/
796struct argconfig_commandline_options *
797argconfig_bind(const struct argconfig_commandline_options *tmpl,
      const void *tmpl_base, size_t size, void *base)
799{
struct argconfig_commandline_options *dst;
uintptr_t start = (uintptr_t)tmpl_base;
uintptr_t v;
size_t n = 0, i;

while (tmpl[n].option)
n++;

dst = calloc(n + 1, sizeof(*dst));
if (!dst)
return NULL((void*)0);
memcpy(dst, tmpl, (n + 1) * sizeof(*dst));

for (i = 0; i < n; i++) {
v = (uintptr_t)tmpl[i].default_value;
if (v >= start && v < start + size)
	dst[i].default_value = (char *)base + (v - start);
}

return dst;
820}

822/* The name of the enum value @val in the value table @v, or NULL */
823const char *argconfig_value_name(const struct argconfig_opt_val *v, int val)
824{
for (; v && v->str; v++) {
if (v->type == CFG_ENUM && v->val.int_val == val)
	return v->str;
}

return NULL((void*)0);
831}

833/* The value of a required argument which is not attached to the option */
834static char *argconfig_next_arg(struct argconfig_parser *p)
835{
if (p->ind + 1 >= p->argc)
return NULL((void*)0);

return p->argv[++p->ind];
840}

842/* "--name", "--name=value" or "--name value" */
843static int argconfig_parse_long(struct argconfig_parser *p, char *arg)
844{
struct argconfig_commandline_options *s;
char *name = arg + 2, *value = NULL((void*)0);
char *eq = strchr(name, '=')_Generic (0 ? (name) : (void *) 1, const void *: (const char *
) (strchr (name, '=')), default: strchr (name, '='));
size_t len = eq ? (size_t)(eq - name) : strlen(name);

s = argconfig_find_long_any(p->root, name, len);
if (!s) {
bool_Bool help = len == 4 && !strncmp(name, "help", 4);
bool_Bool version = len == 7 && !strncmp(name, "version", 7);

if (help && !p->global)
	return ARGCONFIG_HELP1;
if (!p->global || (!help && !version)) {
	__cleanup_free__attribute__((cleanup(shr_freep))) char *e = shr_escape(arg);

	return argconfig_parse_error(p,
		"unrecognized option '%s'", e ? e : "");
}
if (eq)
	return argconfig_parse_error(p,
		"option '--%.*s' doesn't allow an argument",
		(int)len, name);
p->help |= help;
p->version |= version;
return 0;
}

switch (s->argument_type) {
case ARGCONFIG_ARG_NONE:
if (eq)
	return argconfig_parse_error(p,
		"option '--%s' doesn't allow an argument",
		s->option);
break;
case ARGCONFIG_ARG_REQUIRED:
value = eq ? eq + 1 : argconfig_next_arg(p);
if (!value)
	return argconfig_parse_error(p,
		"option '--%s' requires an argument",
		s->option);
break;
case ARGCONFIG_ARG_OPTIONAL:
/* Only an attached value, "--name value" is an operand */
if (eq)
	value = eq + 1;
break;
}

if (s->old_name && !s->seen &&
   (strlen(s->option) != len || strncmp(s->option, name, len))) {
argconfig_print_warning();
fprintf(stderrstderr,
	" '--%s' is deprecated and will be removed in the next major version, use '--%s' instead\n",
	s->old_name, s->option);
}

return argconfig_apply(s, 0, value);
902}

904/* "-a", "-abc", "-ovalue", "-o value" */
905static int argconfig_parse_short(struct argconfig_parser *p, char *arg)
906{
struct argconfig_commandline_options *s;
char *c, *value;
int ret;

for (c = arg + 1; *c; c++) {
if (!p->global && (*c == 'h' || *c == '?'))
	return ARGCONFIG_HELP1;

s = argconfig_find_short_any(p->root, *c);
if (!s && p->global && (*c == 'h' || *c == 'V')) {
	p->help |= *c == 'h';
	p->version |= *c == 'V';
	continue;
}
if (!s) {
	char bad[2] = { *c, '\0' };
	__cleanup_free__attribute__((cleanup(shr_freep))) char *e = shr_escape(bad);

	return argconfig_parse_error(p,
		"invalid option -- '%s'", e ? e : "");
}

value = NULL((void*)0);
switch (s->argument_type) {
case ARGCONFIG_ARG_NONE:
	break;
case ARGCONFIG_ARG_REQUIRED:
	value = c[1] ? c + 1 : argconfig_next_arg(p);
	if (!value)
		return argconfig_parse_error(p,
			"option requires an argument -- '%c'",
			*c);
	break;
case ARGCONFIG_ARG_OPTIONAL:
	if (c[1])
		value = c + 1;
	break;
}

ret = argconfig_apply(s, *c, value);
if (ret || s->argument_type != ARGCONFIG_ARG_NONE)
	return ret;
}

return 0;
952}

954/*
* Options and operands may be given in any order, "--" ends the options.
* Returns 0, ARGCONFIG_HELP, ARGCONFIG_USAGE or a negative errno from the
* value conversion.
*/
959static int argconfig_parse_args(struct argconfig_parser *p)
960{
char *arg;
int ret;

/*
* The global options keep theirs: they may have been given before
* the command name.
*/
argconfig_reset_seen(p->root[0].default_value);

/* argv ends at argc or at a NULL, whichever comes first */
for (p->ind = 1; p->ind < p->argc && p->argv[p->ind]; p->ind++) {
arg = p->argv[p->ind];

if (!strcmp(arg, "--")) {
	p->ind++;
	if (p->global)
		return 0;
	while (p->ind < p->argc && p->argv[p->ind])
		p->operands[p->nr_operands++] =
			p->argv[p->ind++];
	return 0;
}

if (arg[0] != '-' || !arg[1]) {
	if (p->global)
		return 0;
	p->operands[p->nr_operands++] = arg;
	continue;
}

if (arg[1] == '-')
	ret = argconfig_parse_long(p, arg);
else
	ret = argconfig_parse_short(p, arg);
if (ret)
	return ret;
}

return 0;
1000}

1002static argconfig_parse_hook_fn argconfig_parse_hook;

1004void argconfig_set_parse_hook(argconfig_parse_hook_fn hook)
1005{
argconfig_parse_hook = hook;
1007}

1009static bool_Bool given_in(struct argconfig_commandline_options *s,
     const void *value)
1011{
bool_Bool given = false0;

for (; s && s->option; s++) {
if (s->config_type == CFG_INCLUDE)
	given |= given_in(s->default_value, value);
else
	given |= s->default_value == value && s->seen;
}

return given;
1022}

1024/* --verbose, or an alias of it such as --human-readable, was given */
1025static bool_Bool argconfig_check_verbose(struct argconfig_commandline_options *root)
1026{
struct argconfig_commandline_options *v;

v = argconfig_find_long_any(root, "verbose", strlen("verbose"));
if (!v || v->config_type != CFG_INCREMENT)
return false0;

return given_in(root, v->default_value);
1034}

1036int argconfig_parse(int argc, char *argv[], const char *program_desc,
    struct argconfig_commandline_options *options)
1038{
static char **operand_buf;
struct argconfig_parser p = {
.argc = argc,
.argv = argv,
};
int ret;

argconfig_root(p.root, options);
parse_argv0 = argc > 0 ? argv[0] : "";
free(operand_buf);
operand_buf = NULL((void*)0);
operands.argv = NULL((void*)0);
operands.argc = 0;

if (argconfig_parse_hook)
return argconfig_parse_hook(argc, argv, program_desc, p.root);

p.operands = calloc(argc > 0 ? argc : 1, sizeof(*p.operands));
if (!p.operands)
return -ENOMEM12;

ret = argconfig_parse_args(&p);
if (ret) {
/*
 * The help that was asked for goes to stdout, a usage error is
 * followed by the synopsis on stderr. The command stops
 * either way: it gets ARGCONFIG_HELP or an error.
 */
if (ret == ARGCONFIG_HELP1) {
	show_help(stdoutstdout, program_desc, p.root);
	help_requested = true1;
} else if (ret > 0) {
	argconfig_print_usage();
	ret = -EINVAL22;
}
free(p.operands);
} else {
operand_buf = p.operands;
operands.argv = p.operands;
operands.argc = p.nr_operands;
}

if (!argconfig_check_verbose(p.root))
setlocale(LC_ALL6, "C");

return ret;
1085}

1087/*
* Parse global (pre-subcommand) options from argc/argv. Stops at the first
* non-option argument (i.e. the subcommand name) so that subcommand-specific
* options are left in place for the subcommand dispatcher. After a successful
* call, *argind is the index of the first non-option argument (the
* subcommand), or argc if there is none.
*
* Unless the table has its own, -h, --help, -V and --version are accepted
* like a global option. Returns ARGCONFIG_HELP and ARGCONFIG_VERSION for
* them, 0 otherwise, or a negative errno on failure. @options may be NULL.
*/
1098int argconfig_parse_global(int argc, char *argv[],
	   struct argconfig_commandline_options *options,
	   int *argind)
1101{
static struct argconfig_commandline_options no_options[] = {
OPT_END(){ ((void*)0) }
};
struct argconfig_parser p = {
.argc = argc,
.argv = argv,
.global = true1,
};
int ret;

argconfig_root(p.root, options ? options : no_options);

parse_argv0 = argc > 0 ? argv[0] : "";
ret = argconfig_parse_args(&p);
*argind = p.ind;
if (ret)
return ret > 0 ? -EINVAL22 : ret;

return (p.help ? ARGCONFIG_HELP1 : 0) |
      (p.version ? ARGCONFIG_VERSION2 : 0);
1122}

1124/*
* True if an option which stores to @value was given, in the table or in
* the global options. Aliases share the variable, so any of them counts.
*/
1128bool_Bool argconfig_given(struct argconfig_commandline_options *s,
     const void *value)
1130{
struct argconfig_commandline_options root[ARGCONFIG_ROOT_LEN3];

if (!value)
return false0;
argconfig_root(root, s);

return given_in(root, value);
1138}