../plugins/utils/command-metadata.c

Bug Summary

File:	.build-ci/../plugins/utils/command-metadata.c
Warning:	line 509, column 10 Potential leak of memory pointed to by 'model'

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 command-metadata.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-09-23-073103-589-1 -x c ../plugins/utils/command-metadata.c

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
* Copyright (c) 2026 Micron Technology, Inc.
*
* Command/option metadata dump for nvme-cli.
*
* Builds an in-memory model of every command and its options, then writes it to
* stdout as JSON for the `dump-command-metadata` subcommand. The JSON is a
* machine-readable description of the CLI surface, intended for tooling such as
* shell-completion generators, documentation, and drift checks.
*
* The model is captured by walking the live plugin/command tree and, for each
* command, intercepting the options array it builds on its stack via NVME_ARGS.
* Capture installs a hook in argconfig_parse() (see argconfig_set_parse_hook):
* when a command calls into the parser, the hook copies the options array into
* the model and returns a sentinel so the command unwinds before opening any
* device.
*/

20#include <assert.h>
21#include <errno(*__errno_location ()).h>
22#include <fcntl.h>
23#include <getopt.h>
24#include <signal.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <unistd.h>
29#ifdef _WIN32
30#include <windows.h>
31#endif

33#include <shared/fs-util.h>

35#include "command-metadata.h"
36#include "nvme-json.h"
37#include "plugin.h"

39/*
* The whole command is JSON-only, so it is compiled out entirely without
* json-c support: the utils plugin does not register it and does not define
* its handler, so dump_command_metadata() is never referenced.
*/
44#ifdef CONFIG_JSONC

46/*
* Returned by the capture hook so argconfig_parse() unwinds before the
* command's fn opens a device.
*/
50#define METADATA_CAPTURE_SENTINEL(-125) (-ECANCELED125)

52/*
* Version of the emitted JSON schema, bumped on any breaking change to the
* output structure (renamed/removed keys, changed value semantics). Additive
* changes that keep existing keys stable do not require a bump. Consumers
* should reject a major version they do not understand.
*/
58#define COMMAND_METADATA_SCHEMA_VERSION1 1

60/*
* The command currently being captured; set by capture_command()
* before it invokes the command fn, read by metadata_capture_hook().
*/
64static struct command_metadata_command *command_metadata_cur_command;

66/*
* Capture OOM, reported out-of-band because the hook's return value is reserved
* for the parser-unwind sentinel; checked after each command fn returns.
*/
70static int command_metadata_capture_error;

72/*
* capture_saved_stderr_fd holds a dup of stderr from before the NUL redirect,
* so crash messages still reach the user.
*/
76static const char *capture_current_command;
77static int capture_saved_stderr_fd = -1;

79/*
* (void)write() does not suppress GCC's warn_unused_result under
* _FORTIFY_SOURCE; assigning to a discarded variable does.
*/
83static void write_raw(int fd, const char *buf, size_t len)
84{
ssize_t ret = write(fd, buf, len);
(void)ret;
87}

89/* strlen() is not async-signal-safe; measure inline for the crash handler. */
90static void write_str(int fd, const char *s)
91{
size_t len = 0;

if (!s)
return;

while (s[len])
len++;

write_raw(fd, s, len);
101}

103static void write_uint(int fd, unsigned int n)
104{
char buf[10];	/* enough for any 32-bit unsigned int */
int i = sizeof(buf);

do {
buf[--i] = '0' + (n % 10);
n /= 10;
} while (n && i);

write_raw(fd, buf + i, sizeof(buf) - i);
114}

116static void capture_crash_handler(int sig)
117{
int fd = capture_saved_stderr_fd >= 0 ? capture_saved_stderr_fd : STDERR_FILENO2;

write_str(fd, "dump-command-metadata: fatal: '");
write_str(fd, capture_current_command ? capture_current_command : "(unknown)");
write_str(fd, "' crashed during option capture (signal ");
write_uint(fd, sig);
write_str(fd, ")\n");

signal(sig, SIG_DFL((__sighandler_t) 0));
raise(sig);
128}

130/*
* On Windows, OS-level exceptions (stack overflow, access violations) bypass
* the C signal() mechanism entirely and terminate the process silently.
* SetUnhandledExceptionFilter intercepts these so we can print the same
* diagnostic before dying.
*/
136#ifdef _WIN32
137static void write_hex(int fd, unsigned int n)
138{
char buf[8];
int i = sizeof(buf);

do {
buf[--i] = "0123456789abcdef"[n & 0xf];
n >>= 4;
} while (n && i);

write_raw(fd, buf + i, sizeof(buf) - i);
148}

150static LONG WINAPI capture_exception_filter(EXCEPTION_POINTERS *ep)
151{
int fd = capture_saved_stderr_fd >= 0 ? capture_saved_stderr_fd : STDERR_FILENO2;

write_str(fd, "dump-command-metadata: fatal: '");
write_str(fd, capture_current_command ? capture_current_command : "(unknown)");
write_str(fd, "' crashed during option capture (exception 0x");
write_hex(fd, ep->ExceptionRecord->ExceptionCode);
write_str(fd, ")\n");

return EXCEPTION_CONTINUE_SEARCH;
161}

163static LPTOP_LEVEL_EXCEPTION_FILTER capture_prev_filter;
164#endif

166static void (*capture_prev_sigsegv)(int);
167static void (*capture_prev_sigabrt)(int);
168#ifdef SIGBUS7
169static void (*capture_prev_sigbus)(int);
170#endif

172/* Normalize SIG_ERR to SIG_DFL so restoration is always a valid disposition. */
173static void (*set_crash_handler(int sig))(int)
174{
void (*prev)(int) = signal(sig, capture_crash_handler);

return prev == SIG_ERR((__sighandler_t) -1) ? SIG_DFL((__sighandler_t) 0) : prev;
178}

180static void install_crash_handlers(void)
181{
capture_prev_sigsegv = set_crash_handler(SIGSEGV11);
capture_prev_sigabrt = set_crash_handler(SIGABRT6);
184#ifdef SIGBUS7
capture_prev_sigbus = set_crash_handler(SIGBUS7);
186#endif
187#ifdef _WIN32
capture_prev_filter = SetUnhandledExceptionFilter(capture_exception_filter);
189#endif
190}

192static void remove_crash_handlers(void)
193{
signal(SIGSEGV11, capture_prev_sigsegv);
signal(SIGABRT6, capture_prev_sigabrt);
196#ifdef SIGBUS7
signal(SIGBUS7, capture_prev_sigbus);
198#endif
199#ifdef _WIN32
SetUnhandledExceptionFilter(capture_prev_filter);
capture_prev_filter = NULL((void*)0);
202#endif
203}

205/* ------------------------------------------------------------------ */
206/* Pass 1: capture                                                    */
207/* ------------------------------------------------------------------ */

209static char *xstrdup(const char *s)
210{
return s ? strdup(s) : NULL((void*)0);
212}

214/*
* Deep-copy an opt_val table into *out. A NULL src is not an error: *out is set
* to NULL, the "no value table" sentinel consumers expect. Returns -ENOMEM on
* allocation failure so the caller can abort rather than silently drop values.
*/
219static int copy_opt_val(const struct argconfig_opt_val *src, const struct argconfig_opt_val **out)
220{
struct argconfig_opt_val *dst;
int n = 0, i;

*out = NULL((void*)0);
if (!src)
return 0;

for (; src[n].str; n++)
;

dst = calloc(n + 1, sizeof(*dst));
if (!dst)
return -ENOMEM12;

for (i = 0; i < n; i++) {
dst[i] = src[i];
/* src[i].str is non-NULL for i < n, so NULL here means OOM. */
dst[i].str = strdup(src[i].str);
if (!dst[i].str) {
	while (--i >= 0)
		free((char *)dst[i].str);
	free(dst);
	return -ENOMEM12;
}
}
dst[n].str = NULL((void*)0);

*out = dst;
return 0;
250}

252/*
* Duplicate a possibly-NULL string: NULL src succeeds (copies to NULL); a
* non-NULL src that fails to duplicate returns -ENOMEM.
*/
256static int dup_field(const char *src, const char **dst)
257{
*dst = xstrdup(src);
if (src && !*dst)
return -ENOMEM12;
return 0;
262}

264/* Free the deep-copied fields of one option entry (safe on a partial entry). */
265static void free_option_fields(struct command_metadata_option *o)
266{
free((char *)o->option);
free((char *)o->meta);
free((char *)o->help);
if (o->opt_val) {
const struct argconfig_opt_val *v;

for (v = o->opt_val; v->str; v++)
	free((char *)v->str);
free((void *)o->opt_val);
}
277}

279/*
* Deep-copy an options array into *out (a heap array of *n_out entries).
* Returns -ENOMEM on failure; the partial allocation is left for process exit
* to reclaim, as the model is never explicitly freed.
*/
284static int copy_options(const struct argconfig_commandline_options *opts,
	struct command_metadata_option **out, size_t *n_out)
286{
const struct argconfig_commandline_options *s;
struct command_metadata_option *dst;
size_t n = 0, i;

*out = NULL((void*)0);
*n_out = 0;

for (s = opts; s->option; s++)
n++;

if (!n)	/* calloc(0) may return NULL, indistinguishable from OOM */
return 0;

dst = calloc(n, sizeof(*dst));
if (!dst)
return -ENOMEM12;

/*
* Deep-copy: option/meta/help and the opt_val table are valid while the
* parser runs but may point at command-local storage that is freed once
* the command's fn returns, so duplicate rather than alias them.
*/
for (i = 0; i < n; i++) {
if (dup_field(opts[i].option, &dst[i].option) ||
    dup_field(opts[i].meta, &dst[i].meta) ||
    dup_field(opts[i].help, &dst[i].help) ||
    copy_opt_val(opts[i].opt_val, &dst[i].opt_val)) {
	size_t j;

	for (j = 0; j <= i; j++)
		free_option_fields(&dst[j]);
	free(dst);
	return -ENOMEM12;
}
dst[i].short_option = opts[i].short_option;
dst[i].config_type = opts[i].config_type;
dst[i].argument_type = opts[i].argument_type;
dst[i].hidden = opts[i].hidden;
}

*out = dst;
*n_out = n;
return 0;
330}

332/*
* argconfig_parse() hook installed by build_model(): copies the current
* command's options into the model, then returns the sentinel so the parser
* unwinds before the command opens a device.
*/
337static int metadata_capture_hook(int argc, char **argv, const char *program_desc,
		 struct argconfig_commandline_options *options)
339{
(void)argc;
(void)argv;
(void)program_desc;

if (command_metadata_cur_command && !command_metadata_cur_command->captured) {
int err = copy_options(options,
		&command_metadata_cur_command->options,
		&command_metadata_cur_command->num_options);
if (err)
	command_metadata_capture_error = err;
command_metadata_cur_command->captured = true1;
}

return METADATA_CAPTURE_SENTINEL(-125);
354}

356/* Returns 0 on success, or -ENOMEM if the capture hook failed to allocate. */
357static int capture_command(struct command_metadata_command *mc, struct command *cmd,
	   struct plugin *plugin)
359{
/*
* argv[1] is a placeholder device; the sentinel returns before it is
* ever opened, so it need not (and must not) name a real device.
*/
char *argv[] = { cmd->name, (char *)"metadata-dump-dummy-device", NULL((void*)0) };

mc->name = cmd->name;
mc->alias = cmd->alias;
mc->help = cmd->help;
mc->captured = false0;

/*
* Don't invoke the dump command itself: it would re-enter
* dump_command_metadata() and recurse forever. It has no
* completable options, so leave its options array empty.
*/
if (!strcmp(cmd->name, "dump-command-metadata"))
return 0;

command_metadata_capture_error = 0;
command_metadata_cur_command = mc;
capture_current_command = cmd->name;
(void)cmd->fn(2, argv, cmd, plugin);
capture_current_command = NULL((void*)0);
command_metadata_cur_command = NULL((void*)0);

/*
* If the hook never fired, the command returned before reaching the
* parser (e.g. gen-hostnqn) and has no completable options; its options
* array is simply left empty.
*/
return command_metadata_capture_error;
392}

394static size_t count_commands(struct command **commands)
395{
size_t n = 0;

while (commands && commands[n])
n++;

return n;
402}

404static size_t count_plugins(struct plugin *p)
405{
size_t n = 0;

for (; p; p = p->next)
n++;

return n;
412}

414static struct command_metadata_program *build_model(struct program *prog)
415{
struct command_metadata_program *model;
struct plugin *plugin;
int saved_stdout = -1, saved_stderr = -1, devnull;
int err = 0;
size_t pi;

model = calloc(1, sizeof(*model));
2
←
Memory is allocated→
if (!model)
3
←
Assuming 'model' is non-null→
4
←
Taking false branch→
return NULL((void*)0);

model->name = prog->name;
model->version = prog->version;
model->desc = prog->desc;
model->num_plugins = count_plugins(prog->extensions);
if (model->num_plugins4.1
Field 'num_plugins' is 2
) {
5
←
Taking true branch→
model->plugins = calloc(model->num_plugins, sizeof(*model->plugins));
if (!model->plugins) {
6
←
Assuming field 'plugins' is non-null→
7
←
Taking false branch→
	free(model);
	return NULL((void*)0);
}
}

/*
* Suppress stdout/stderr while invoking command fns: some commands
* may print before or during option capture, which would corrupt the
* JSON output.
*/
fflush(stdoutstdout);
fflush(stderrstderr);
devnull = open(shr_dev_null(), O_WRONLY01);
if (devnull7.1
'devnull' is < 0
 >= 0) {
8
←
Taking false branch→
saved_stdout = dup(STDOUT_FILENO1);
saved_stderr = dup(STDERR_FILENO2);
capture_saved_stderr_fd = saved_stderr;
if (saved_stdout >= 0)
	dup2(devnull, STDOUT_FILENO1);
if (saved_stderr >= 0)
	dup2(devnull, STDERR_FILENO2);
}

install_crash_handlers();
argconfig_set_parse_hook(metadata_capture_hook);

for (pi = 0, plugin = prog->extensions; plugin; plugin = plugin->next, pi++) {
9
←
Loop condition is true.  Entering loop body→
struct command_metadata_plugin *mp = &model->plugins[pi];
size_t ci;

mp->name = plugin->name;
mp->desc = plugin->desc;
mp->num_commands = count_commands(plugin->commands);
if (!mp->num_commands)
10
←
Assuming field 'num_commands' is not equal to 0→
11
←
Taking false branch→
	continue;
mp->commands = calloc(mp->num_commands, sizeof(*mp->commands));
if (!mp->commands) {
12
←
Assuming field 'commands' is null→
13
←
Taking true branch→
	mp->num_commands = 0;
	err = -ENOMEM12;
	break;
14
←
 Execution continues on line 485→
}

for (ci = 0; ci < mp->num_commands; ci++) {
	err = capture_command(&mp->commands[ci],
			plugin->commands[ci], plugin);
	if (err)
		break;
}
if (err)
	break;
}

argconfig_set_parse_hook(NULL((void*)0));
remove_crash_handlers();
capture_saved_stderr_fd = -1;

fflush(stdoutstdout);
fflush(stderrstderr);
if (saved_stdout14.1
'saved_stdout' is < 0
 >= 0) {
15
←
Taking false branch→
dup2(saved_stdout, STDOUT_FILENO1);
shr_close(saved_stdout);
}
if (saved_stderr15.1
'saved_stderr' is < 0
 >= 0) {
16
←
Taking false branch→
dup2(saved_stderr, STDERR_FILENO2);
shr_close(saved_stderr);
}
if (devnull16.1
'devnull' is < 0
 >= 0)
17
←
Taking false branch→
shr_close(devnull);

/*
* An allocation failure while capturing would leave an incomplete model
* that looks complete in the emitted JSON; fail the dump instead. The
* partial model is left for process exit to reclaim (it is never freed
* on the success path either).
*/
if (err17.1
'err' is -12
)
18
←
Taking true branch→
return NULL((void*)0);
19
←
Potential leak of memory pointed to by 'model'

return model;
512}

514/* ------------------------------------------------------------------ */
515/* Model helpers shared by emitters                                   */
516/* ------------------------------------------------------------------ */

518static bool_Bool opt_is_separator(const struct command_metadata_option *o)
519{
return o->config_type == CFG_GROUP_SEPARATOR;
521}

523static bool_Bool opt_is_global_separator(const struct command_metadata_option *o)
524{
return opt_is_separator(o) && o->help && !strcmp(o->help, "Global options");
526}

528/* "none" / "required" / "optional" — how the option consumes its argument. */
529static const char *opt_argument(const struct command_metadata_option *o)
530{
switch (o->argument_type) {
case optional_argument2:
return "optional";
case no_argument0:
return "none";
default:
return "required";
}
539}

541static bool_Bool opt_takes_value(const struct command_metadata_option *o)
542{
return o->argument_type != no_argument0;
544}

546/*
* True for an option that should be emitted: a real, named, non-separator
* option. Hidden options are emitted too (tagged "hidden" in the output) so
* the dump describes the full set of accepted options; consumers that only
* want user-facing options (e.g. completion generators) filter on that tag.
*/
552static bool_Bool opt_is_emittable(const struct command_metadata_option *o)
553{
return !opt_is_separator(o) && o->option && o->option[0];
555}

557/* ------------------------------------------------------------------ */
558/* Pass 2: JSON                                                       */
559/* ------------------------------------------------------------------ */

561/*
* The value set for an option, when the generator can derive it. Returns a
* json array of strings, or NULL if the option has no known value set. The
* caller owns the returned array.
*
* output-format is special-cased because its values are not represented via an
* opt_val table; keep the hard-coded list below in sync with
* validate_output_format() / DESC_OUTPUT_FORMAT. Since the whole command is
* compiled out without json-c, "json" is always a valid value here. Every
* other value set comes from the option's opt_val table, which is the set the
* parser actually enforces; options whose value is unconstrained (e.g. any
* OPT_UINT such as output-format-version) have no values array.
*/
574static struct json_object *json_option_values(const struct command_metadata_option *o)
575{
const struct argconfig_opt_val *v;
struct json_object *vals;

if (!strcmp(o->option, "output-format")) {
vals = json_create_array()json_object_new_array();
json_array_add_value_string(vals, "normal");
json_array_add_value_string(vals, "json");
json_array_add_value_string(vals, "binary");
json_array_add_value_string(vals, "tabular");
return vals;
}
if (!o->opt_val)
return NULL((void*)0);

vals = json_create_array()json_object_new_array();
for (v = o->opt_val; v->str; v++)
json_array_add_value_string(vals, v->str);
return vals;
594}

596/* Build one option as a json object and add it to the given array. */
597static void json_option(struct json_object *arr, const struct command_metadata_option *o,
	bool_Bool global)
599{
struct json_object *jo, *vals;
char shortbuf[2] = { o->short_option, '\0' };

if (!opt_is_emittable(o))
return;

jo = json_create_object()json_object_new_object();
json_object_add_value_string(jo, "long", o->option);
if (o->short_option)
json_object_add_value_string(jo, "short", shortbuf);
json_object_add_value_string(jo, "argument", opt_argument(o));
if (o->meta && opt_takes_value(o))
json_object_add_value_string(jo, "metavar", o->meta);
if (o->help)
json_object_add_value_string(jo, "description", o->help);
if (global)
json_object_add_value_bool(jo, "global", true)json_object_object_add(jo, "global", json_object_new_boolean(
1));
if (o->hidden)
json_object_add_value_bool(jo, "hidden", true)json_object_object_add(jo, "hidden", json_object_new_boolean(
1));

vals = json_option_values(o);
if (vals)
json_object_add_value_array(jo, "values", vals)json_object_object_add(jo, "values", vals);

json_array_add_value_object(arr, jo)json_object_array_add(arr, jo);
625}

627/* Build one command as a json object: name, alias, description, and options. */
628static struct json_object *json_command(const struct command_metadata_command *c)
629{
struct json_object *jc, *opts;
bool_Bool global = false0;
size_t i;

jc = json_create_object()json_object_new_object();
json_object_add_value_string(jc, "name", c->name);
if (c->alias)
json_object_add_value_string(jc, "alias", c->alias);
if (c->help)
json_object_add_value_string(jc, "description", c->help);

opts = json_create_array()json_object_new_array();
for (i = 0; i < c->num_options; i++) {
/*
 * Options after the "Global options" separator are the shared
 * NVME_ARGS globals; flag them so generators can group them.
 */
if (opt_is_global_separator(&c->options[i])) {
	global = true1;
	continue;
}
json_option(opts, &c->options[i], global);
}
json_object_add_value_array(jc, "options", opts)json_object_object_add(jc, "options", opts);

return jc;
656}

658/* Build one named plugin as a json object: name, description, commands. */
659static struct json_object *json_plugin(const struct command_metadata_plugin *p)
660{
struct json_object *jp, *cmds;
size_t i;

jp = json_create_object()json_object_new_object();
assert(p->name)((void) sizeof (__assert_single_arg (p->name)), __extension__
 ({ if (p->name) ; else __assert_fail ("p->name", "../plugins/utils/command-metadata.c"
, 665, __extension__ __PRETTY_FUNCTION__); }));	/* builtin (NULL-name) is emitted inline by json_program() */
json_object_add_value_string(jp, "name", p->name);
if (p->desc)
json_object_add_value_string(jp, "description", p->desc);

cmds = json_create_array()json_object_new_array();
for (i = 0; i < p->num_commands; i++)
json_array_add_value_object(cmds, json_command(&p->commands[i]))json_object_array_add(cmds, json_command(&p->commands[
i]));
json_object_add_value_array(jp, "commands", cmds)json_object_object_add(jp, "commands", cmds);

return jp;
676}

678static void json_program(const struct command_metadata_program *m)
679{
struct json_object *root, *builtin, *plugins;
size_t i;

root = json_create_object()json_object_new_object();
json_object_add_value_int(root, "schema_version",json_object_object_add(root, "schema_version", json_object_new_int
(1))
		  COMMAND_METADATA_SCHEMA_VERSION)json_object_object_add(root, "schema_version", json_object_new_int
(1));
json_object_add_value_string(root, "name", m->name);
if (m->version)
json_object_add_value_string(root, "version", m->version);
if (m->desc)
json_object_add_value_string(root, "description", m->desc);

/*
* Builtin (top-level) commands live in their own array; named plugins
* go under "plugins" so generators can build the dispatch nesting.
*/
builtin = json_create_array()json_object_new_array();
plugins = json_create_array()json_object_new_array();
for (i = 0; i < m->num_plugins; i++) {
const struct command_metadata_plugin *p = &m->plugins[i];
size_t j;

if (!p->name) {
	for (j = 0; j < p->num_commands; j++)
		json_array_add_value_object(builtin,json_object_array_add(builtin, json_command(&p->commands
[j]))
			json_command(&p->commands[j]))json_object_array_add(builtin, json_command(&p->commands
[j]));
} else {
	json_array_add_value_object(plugins, json_plugin(p))json_object_array_add(plugins, json_plugin(p));
}
}
json_object_add_value_array(root, "commands", builtin)json_object_object_add(root, "commands", builtin);
json_object_add_value_array(root, "plugins", plugins)json_object_object_add(root, "plugins", plugins);

json_print_object(root, NULL)printf("%s", json_object_to_json_string_ext(root, (1 <<
 1) | (1 << 4)));
printf("\n");
json_free_object(root)json_object_put(root);
716}

718/* ------------------------------------------------------------------ */
719/* Entry point                                                        */
720/* ------------------------------------------------------------------ */

722int dump_command_metadata(struct program *prog)
723{
struct command_metadata_program *model;

model = build_model(prog);
1
Calling 'build_model'→
if (!model)
return -ENOMEM12;

json_program(model);

free(model->plugins);
free(model);
return 0;
735}

737#endif /* CONFIG_JSONC */