../libnvme/src/nvme/fabrics.c

Bug Summary

File:	.build-ci/../libnvme/src/nvme/fabrics.c
Warning:	line 543, column 9 Potential leak of memory pointed to by 'hnqn'
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 fabrics.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 pic -pic-level 2 -fhalf-no-semantic-interposition -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 libnvme/src/libnvme3.so.1.0.0.p -I libnvme/src -I ../libnvme/src -I ccan -I ../ccan -I . -I .. -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 -fvisibility=hidden -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 ../libnvme/src/nvme/fabrics.c
1// SPDX-License-Identifier: LGPL-2.1-or-later
2/*
* This file is part of libnvme.
* Copyright (c) 2020 Western Digital Corporation or its affiliates.
*
* Authors: Keith Busch <keith.busch@wdc.com>
* 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
*/

10#include <dirent.h>
11#include <errno(*__errno_location ()).h>
12#include <fcntl.h>
13#include <fnmatch.h>
14#include <ifaddrs.h>
15#include <inttypes.h>
16#include <limits.h>
17#include <stdbool.h>
18#include <stddef.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22#include <strings.h>
23#include <unistd.h>

25#include <arpa/inet.h>
26#include <linux1/if_ether.h>
27#include <net/if.h>
28#include <netpacket/packet.h>
29#include <sys/param.h>
30#include <sys/stat.h>
31#include <sys/types.h>

33#include <ccan/array_size/array_size.h>
34#include <ccan/endian/endian.h>
35#include <ccan/list/list.h>
36#include <ccan/str/str.h>

38#include <shared/array-util.h>
39#include <shared/compiler-attributes-util.h>
40#include <shared/machine-id-util.h>
41#include <shared/net-util.h>
42#include <shared/nqn-util.h>
43#include <shared/string-util.h>
44#include <shared/uuid-util.h>

46#include <libnvme.h>

48#include "cleanup.h"
49#include "cleanup-linux.h"
50#include "config-ini.h"
51#include "private.h"
52#include "private-fabrics.h"

54const char *nvmf_dev = "/dev/nvme-fabrics";

56static inline void free_uri(struct libnvmf_uri **uri)
57{
libnvmf_uri_free(*uri);
59}
60#define __cleanup_uri__attribute__((cleanup(free_uri))) __cleanup(free_uri)__attribute__((cleanup(free_uri)))

62static struct libnvme_ctrl_params ctrl_params_copy(
const struct libnvme_ctrl_params *src)
64{
struct libnvme_ctrl_params params = *src;

params.host_iface = NULL((void*)0);
return params;
69}

71static struct libnvme_ctrl_params ctrl_params_dup(
const struct libnvme_ctrl_params *src)
73{
struct libnvme_ctrl_params params = *src;

params.host_iface = shr_xstrdup(src->host_iface);
return params;
78}

80static inline void cleanup_ctrl_params(struct libnvme_ctrl_params *params)
81{
free((char *)params->host_iface);
83}
84#define __cleanup_ctrl_params__attribute__((cleanup(cleanup_ctrl_params))) __cleanup(cleanup_ctrl_params)__attribute__((cleanup(cleanup_ctrl_params)))

86const char *arg_str(const char * const *strings,
size_t array_size, size_t idx)
88{
if (idx < array_size && strings[idx])
return strings[idx];
return "unrecognized";
92}

94#define NVMF_HOSTID_SIZE37	37

96#define NVMF_HOSTNQN_FILE"/usr/local/etc" "/nvme/hostnqn"	SYSCONFDIR"/usr/local/etc" "/nvme/hostnqn"
97#define NVMF_HOSTID_FILE"/usr/local/etc" "/nvme/hostid"	SYSCONFDIR"/usr/local/etc" "/nvme/hostid"

99static int uuid_from_device_tree(struct libnvme_global_ctx *ctx,
		 char *system_uuid)
101{
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int f = -1;
ssize_t len;

f = open(libnvme_uuid_ibm_filename(ctx), O_RDONLY00);
if (f < 0)
return -ENXIO6;

memset(system_uuid, 0, NVME_UUID_LEN_STRING37);
len = read(f, system_uuid, NVME_UUID_LEN_STRING37 - 1);
if (len < 0)
return -ENXIO6;

return strlen(system_uuid) ? 0 : -ENXIO6;
115}

117/*
* See System Management BIOS (SMBIOS) Reference Specification
* https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.2.0.pdf
*/
121#define DMI_SYSTEM_INFORMATION1	1

123static bool_Bool is_dmi_uuid_valid(const char *buf, size_t len)
124{
int i;

/* UUID bytes are from byte 8 to 23 */
if (len < 24)
return false0;

/* Test it's a invalid UUID with all zeros */
for (i = 8; i < 24; i++) {
if (buf[i])
	break;
}
if (i == 24)
return false0;

return true1;
140}

142static int read_file(char *filename, char *buf, size_t size)
143{
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int f = -1;
int len;

f = open(filename, O_RDONLY00);
if (f < 0)
return -errno(*__errno_location ());
len = read(f, buf, size - 1);
if (len < 0)
return -errno(*__errno_location ());
buf[len] = 0;

return len;
156}

158static int uuid_from_dmi_entries(struct libnvme_global_ctx *ctx,
		 char *system_uuid)
160{
__cleanup_dir__attribute__((cleanup(cleanup_dir))) DIR *d = NULL((void*)0);
const char *entries_dir = libnvme_dmi_entries_dir(ctx);
char filename[PATH_MAX4096];
struct dirent *de;
char buf[513] = {0};
int len, type;

system_uuid[0] = '\0';
d = opendir(entries_dir);
if (!d)
return -ENXIO6;
while ((de = readdir(d))) {
if (de->d_name[0] == '.')
	continue;
snprintf(filename, sizeof(filename), "%s/%s/type", entries_dir,
	 de->d_name);
len = read_file(filename, buf, sizeof(buf));
if (len <= 0)
	continue;
if (sscanf(buf, "%d", &type) != 1)
	continue;
if (type != DMI_SYSTEM_INFORMATION1)
	continue;
snprintf(filename, sizeof(filename), "%s/%s/raw", entries_dir,
	 de->d_name);
len = read_file(filename, buf, sizeof(buf));
if (len <= 0)
	continue;

if (!is_dmi_uuid_valid(buf, len))
	continue;

/* Sigh. https://en.wikipedia.org/wiki/Overengineering */
/* DMTF SMBIOS 3.0 Section 7.2.1 System UUID */
sprintf(system_uuid,
	"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
	"%02x%02x%02x%02x%02x%02x",
	(uint8_t)buf[8 + 3], (uint8_t)buf[8 + 2],
	(uint8_t)buf[8 + 1], (uint8_t)buf[8 + 0],
	(uint8_t)buf[8 + 5], (uint8_t)buf[8 + 4],
	(uint8_t)buf[8 + 7], (uint8_t)buf[8 + 6],
	(uint8_t)buf[8 + 8], (uint8_t)buf[8 + 9],
	(uint8_t)buf[8 + 10], (uint8_t)buf[8 + 11],
	(uint8_t)buf[8 + 12], (uint8_t)buf[8 + 13],
	(uint8_t)buf[8 + 14], (uint8_t)buf[8 + 15]);
break;
}
return strlen(system_uuid) ? 0 : -ENXIO6;
209}

211/**
* uuid_from_product_uuid() - Get system UUID from product_uuid
* @ctx: Global context, for the sysfs path.
* @system_uuid: Where to save the system UUID.
*
* Return: 0 on success, -ENXIO otherwise.
*/
218static int uuid_from_product_uuid(struct libnvme_global_ctx *ctx,
		  char *system_uuid)
220{
__cleanup_file__attribute__((cleanup(shr_cleanup_file))) FILE *stream = NULL((void*)0);

stream = fopen(libnvme_dmi_product_uuid_filename(ctx), "re");
if (!stream)
return -ENXIO6;

system_uuid[0] = '\0';

/* The kernel is handling the byte swapping according DMTF
* SMBIOS 3.0 Section 7.2.1 System UUID */

/*
* Expect exactly:
* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
*/
if (!fgets(system_uuid, NVME_UUID_LEN_STRING37, stream))
return -ENXIO6;

if (strlen(system_uuid) != NVME_UUID_LEN_STRING37 - 1)
return -ENXIO6;

if (system_uuid[8]  != '-' || system_uuid[13] != '-' ||
   system_uuid[18] != '-' || system_uuid[23] != '-')
return -ENXIO6;

system_uuid[NVME_UUID_LEN_STRING37 - 1] = '\0';

return 0;
249}

251/**
* uuid_from_machine_id() - Derive a system UUID from the local machine ID
* @ctx: Global context, for the file path.
* @system_uuid: Where to save the system UUID.
*
* The machine ID identifies an installation rather than the hardware, so it
* is less stable than DMI or the device tree. It is still deterministic, and
* unlike them it is readable without privileges.
*
* Return: 0 on success, negative errno otherwise.
*/
262static int uuid_from_machine_id(struct libnvme_global_ctx *ctx,
		char *system_uuid)
264{
/*
* Fixed application ID for nvme-cli's use of the local machine ID.
* Chosen once, at random, and part of the derivation: changing it
* changes the host identifier of every machine that has no DMI or
* device tree UUID.
*/
static const unsigned char app_id[SHR_UUID_LEN16] = {
0x85, 0x3c, 0x32, 0x20, 0xca, 0x64, 0x4d, 0xad,
0xa0, 0x6f, 0x1d, 0xc7, 0x52, 0xe3, 0x22, 0x63
};
unsigned char uuid[NVME_UUID_LEN16];
int ret;

ret = shr_machine_id_app_specific(libnvme_machine_id_filename(ctx),
			  app_id, uuid);
if (ret)
return ret;

libnvme_uuid_to_string(uuid, system_uuid);

return 0;
286}

288/**
* uuid_from_dmi() - read system UUID
* @ctx: Global context, for the sysfs paths.
* @system_uuid: buffer for the UUID
*
* The system UUID can be read from two different locations:
*
*     1) /sys/class/dmi/id/product_uuid
*     2) /sys/firmware/dmi/entries
*
* Note that the second location is not present on Debian-based systems.
*
* Return: 0 on success, negative errno otherwise.
*/
302static int uuid_from_dmi(struct libnvme_global_ctx *ctx, char *system_uuid)
303{
int ret = uuid_from_product_uuid(ctx, system_uuid);
if (ret != 0)
ret = uuid_from_dmi_entries(ctx, system_uuid);
return ret;
308}

310/*
* Virtual machines and some firmware report a placeholder instead of a real
* identifier. Every machine reporting the same placeholder would end up with
* the same host identifier.
*
* shr_hostid_valid() rejects the all-zeros UUID. The all-ones UUID is the
* other common placeholder, but it is a legitimate value to configure by
* hand, so it is refused here rather than in the shared validator.
*/
319static bool_Bool hostid_source_usable(const char *system_uuid)
320{
return shr_hostid_valid(system_uuid) &&
      !shr_streqcase0(system_uuid,
	       "ffffffff-ffff-ffff-ffff-ffffffffffff");
324}

326__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostid(struct libnvme_global_ctx *ctx)
327{
/*
* Ordered from most to least stable. The firmware sources describe
* the hardware and survive a reinstall; the machine ID describes the
* installation and does not.
*/
static const struct {
const char *name;
int (*get)(struct libnvme_global_ctx *ctx, char *system_uuid);
} hostid_sources[] = {
{ "DMI",         uuid_from_dmi },
{ "device tree", uuid_from_device_tree },
{ "machine ID",  uuid_from_machine_id },
};
char uuid_str[NVME_UUID_LEN_STRING37];
unsigned char uuid[NVME_UUID_LEN16];
size_t i;

if (!ctx)
return NULL((void*)0);

for (i = 0; i < ARRAY_SIZE(hostid_sources)(sizeof(hostid_sources) / sizeof((hostid_sources)[0]) + 0); i++) {
if (hostid_sources[i].get(ctx, uuid_str))
	continue;

if (!hostid_source_usable(uuid_str)) {
	libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s reports an unusable host identifier '%s'\n"
, hostid_sources[i].name, uuid_str)
		    "%s reports an unusable host identifier '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s reports an unusable host identifier '%s'\n"
, hostid_sources[i].name, uuid_str)
		    hostid_sources[i].name, uuid_str)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s reports an unusable host identifier '%s'\n"
, hostid_sources[i].name, uuid_str);
	continue;
}

libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "host identifier taken from %s\n"
, hostid_sources[i].name)
	    "host identifier taken from %s\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "host identifier taken from %s\n"
, hostid_sources[i].name)
	    hostid_sources[i].name)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "host identifier taken from %s\n"
, hostid_sources[i].name);

return strdup(uuid_str);
}

libnvme_msg(ctx, LIBNVME_LOG_WARN,__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "no stable host identifier available, using a random one\n"
)
    "no stable host identifier available, using a random one\n")__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "no stable host identifier available, using a random one\n"
);

if (libnvme_random_uuid(uuid) < 0)
memset(uuid, 0, NVME_UUID_LEN16);
libnvme_uuid_to_string(uuid, uuid_str);

return strdup(uuid_str);
374}

376__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostnqn_from_hostid(
		struct libnvme_global_ctx *ctx, char *hostid)
378{
char *hid = NULL((void*)0);
char *hostnqn;
int ret;

if (!ctx)
return NULL((void*)0);

if (!hostid) {
hostid = hid = libnvmf_generate_hostid(ctx);
if (!hostid)
	return NULL((void*)0);
}

ret = asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", hostid);
free(hid);

return (ret < 0) ? NULL((void*)0) : hostnqn;
396}

398__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostnqn(struct libnvme_global_ctx *ctx)
399{
return libnvmf_generate_hostnqn_from_hostid(ctx, NULL((void*)0));
401}

403static char *nvmf_read_file(const char *f, int len)
404{
char buf[len];
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int fd = -1;
int ret;

fd = open(f, O_RDONLY00);
if (fd < 0)
return NULL((void*)0);

memset(buf, 0, len);
ret = read(fd, buf, len - 1);

if (ret < 0 || !strlen(buf))
return NULL((void*)0);
return strndup(buf, strcspn(buf, "\n"));
419}

421__shr_public__attribute__((visibility("default"))) char *libnvmf_read_hostnqn(struct libnvme_global_ctx *ctx)
422{
char *val;

if (!ctx)
return NULL((void*)0);

if (shr_nqn_valid(ctx->hostnqn))
return strdup(ctx->hostnqn);

val = nvmf_read_file(NVMF_HOSTNQN_FILE"/usr/local/etc" "/nvme/hostnqn", NVMF_NQN_SIZE223);
if (shr_nqn_valid(val))
return val;

if (val) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host NQN\n"
, "/usr/local/etc" "/nvme/hostnqn")
	    "%s does not contain a valid host NQN\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host NQN\n"
, "/usr/local/etc" "/nvme/hostnqn")
	    NVMF_HOSTNQN_FILE)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host NQN\n"
, "/usr/local/etc" "/nvme/hostnqn");
free(val);
}

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

445__shr_public__attribute__((visibility("default"))) char *libnvmf_read_hostid(struct libnvme_global_ctx *ctx)
446{
char *val;

if (!ctx)
return NULL((void*)0);

if (shr_hostid_valid(ctx->hostid))
return strdup(ctx->hostid);

val = nvmf_read_file(NVMF_HOSTID_FILE"/usr/local/etc" "/nvme/hostid", NVMF_HOSTID_SIZE37);
if (shr_hostid_valid(val))
return val;

if (val) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host identifier\n"
, "/usr/local/etc" "/nvme/hostid")
	    "%s does not contain a valid host identifier\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host identifier\n"
, "/usr/local/etc" "/nvme/hostid")
	    NVMF_HOSTID_FILE)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s does not contain a valid host identifier\n"
, "/usr/local/etc" "/nvme/hostid");
free(val);
}

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

469__shr_public__attribute__((visibility("default"))) int libnvmf_host_get_ids(struct libnvme_global_ctx *ctx,
      const char *hostnqn_arg, const char *hostid_arg,
      char **hostnqn, char **hostid)
472{
__cleanup_free__attribute__((cleanup(shr_freep))) char *nqn = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *hid = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *hnqn = NULL((void*)0);
struct libnvme_host *h;

if (!ctx)
1
Assuming 'ctx' is non-null→
2
←
Taking false branch→
return -EINVAL22;

/* command line argumments */
if (hostid_arg)
3
←
Assuming 'hostid_arg' is non-null→
4
←
Taking true branch→
hid = strdup(hostid_arg);
if (hostnqn_arg)
5
←
Assuming 'hostnqn_arg' is non-null→
6
←
Taking true branch→
hnqn = strdup(hostnqn_arg);
7
←
Memory is allocated→

/* first host already resolved in ctx->hosts, if any */
h = libnvme_first_host(ctx);
if (h) {
8
←
Assuming 'h' is null→
9
←
Taking false branch→
if (!hid)
	hid = shr_xstrdup(libnvme_host_get_hostid(h));
if (!hnqn)
	hnqn = shr_xstrdup(libnvme_host_get_hostnqn(h));
}

/* /etc/nvme/hostid and/or /etc/nvme/hostnqn */
if (!hid)
10
←
Assuming 'hid' is non-null→
11
←
Taking false branch→
hid = libnvmf_read_hostid(ctx);
if (!hnqn)
12
←
Assuming 'hnqn' is non-null→
hnqn = libnvmf_read_hostnqn(ctx);

/* incomplete configuration, thus derive hostid from hostnqn */
if (!hid12.1
'hid' is non-null
 && hnqn)
hid = libnvme_hostid_from_hostnqn(hnqn);

/*
* fallback to use either DMI information or device-tree. If all
* fails generate one
*/
if (!hid12.2
'hid' is non-null
) {
13
←
Taking false branch→
hid = libnvmf_generate_hostid(ctx);
if (!hid)
	return -ENOMEM12;

libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "warning: using auto generated hostid and hostnqn\n"
)
	 "warning: using auto generated hostid and hostnqn\n")__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "warning: using auto generated hostid and hostnqn\n"
);
}

/* incomplete configuration, thus derive hostnqn from hostid */
if (!hnqn13.1
'hnqn' is non-null
) {
14
←
Taking false branch→
hnqn = libnvmf_generate_hostnqn_from_hostid(ctx, hid);
if (!hnqn)
	return -ENOMEM12;
}

/* sanity checks */
nqn = libnvme_hostid_from_hostnqn(hnqn);
if (nqn && strcmp(nqn, hid)) {
15
←
Assuming 'nqn' is null→
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "warning: use hostid '%s' which does not match uuid in hostnqn '%s'\n"
, hid, hnqn)
	 "warning: use hostid '%s' which does not match uuid in hostnqn '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "warning: use hostid '%s' which does not match uuid in hostnqn '%s'\n"
, hid, hnqn)
	 hid, hnqn)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "warning: use hostid '%s' which does not match uuid in hostnqn '%s'\n"
, hid, hnqn);
}

if (hostid) {
16
←
Assuming 'hostid' is null→
17
←
Taking false branch→
*hostid = hid;
hid = NULL((void*)0);
}
if (hostnqn) {
18
←
Assuming 'hostnqn' is null→
19
←
Taking false branch→
*hostnqn = hnqn;
hnqn = NULL((void*)0);
}

return 0;
20
←
Potential leak of memory pointed to by 'hnqn'
544}

546int _libnvmf_persistent_from_str(const char *str, enum libnvmf_persistent *val)
547{
if (!str || !val)
return -EINVAL22;

if (!strcasecmp(str, "no"))
*val = LIBNVMF_PERSISTENT_NO;
else if (!strcasecmp(str, "auto"))
*val = LIBNVMF_PERSISTENT_AUTO;
else if (!strcasecmp(str, "force"))
*val = LIBNVMF_PERSISTENT_FORCE;
else
return -EINVAL22;

return 0;
561}

563/**
* libnvmf_context_set_persistent() - Set the discovery controller
* persistence mode.
* @fctx: The &struct libnvmf_context instance to update.
* @persistent: One of "no", "auto", "force" (case-insensitive).
*
* Return: 0 on success, -EINVAL if @persistent matches none of the
* accepted values.
*/
572__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_persistent(struct libnvmf_context *fctx,
const char *persistent)
574{
if (!fctx)
return -EINVAL22;

return _libnvmf_persistent_from_str(persistent, &fctx->persistent);
579}

581/**
* libnvmf_context_get_persistent() - Get the discovery controller
* persistence mode.
* @fctx: The &struct libnvmf_context instance to query.
*
* Return: "no", "auto", or "force" if explicitly configured; NULL if not
* (behaves the same as "no" when applied to a live connection, or if
* @fctx is NULL).
*/
590__shr_public__attribute__((visibility("default"))) const char *libnvmf_context_get_persistent(
const struct libnvmf_context *fctx)
592{
if (!fctx)
return NULL((void*)0);

switch (fctx->persistent) {
case LIBNVMF_PERSISTENT_NO:
return "no";
case LIBNVMF_PERSISTENT_AUTO:
return "auto";
case LIBNVMF_PERSISTENT_FORCE:
return "force";
case LIBNVMF_PERSISTENT_UNSET:
default:
return NULL((void*)0);
}
607}

609const char * const trtypes[] = {
[NVMF_TRTYPE_RDMA]	= "rdma",
[NVMF_TRTYPE_FC]	= "fc",
[NVMF_TRTYPE_TCP]	= "tcp",
[NVMF_TRTYPE_LOOP]	= "loop",
614};

616__shr_public__attribute__((visibility("default"))) const char *libnvmf_trtype_str(__u8 trtype)
617{
return arg_str(trtypes, ARRAY_SIZE(trtypes)(sizeof(trtypes) / sizeof((trtypes)[0]) + 0), trtype);
619}

621static const char * const adrfams[] = {
[NVMF_ADDR_FAMILY_PCI]	= "pci",
[NVMF_ADDR_FAMILY_IP4]	= "ipv4",
[NVMF_ADDR_FAMILY_IP6]	= "ipv6",
[NVMF_ADDR_FAMILY_IB]	= "infiniband",
[NVMF_ADDR_FAMILY_FC]	= "fibre-channel",
627};

629__shr_public__attribute__((visibility("default"))) const char *libnvmf_adrfam_str(__u8 adrfam)
630{
return arg_str(adrfams, ARRAY_SIZE(adrfams)(sizeof(adrfams) / sizeof((adrfams)[0]) + 0), adrfam);
632}

634static const char * const subtypes[] = {
[NVME_NQN_DISC]		= "discovery subsystem referral",
[NVME_NQN_NVME]		= "nvme subsystem",
[NVME_NQN_CURR]		= "current discovery subsystem",
638};

640__shr_public__attribute__((visibility("default"))) const char *libnvmf_subtype_str(__u8 subtype)
641{
return arg_str(subtypes, ARRAY_SIZE(subtypes)(sizeof(subtypes) / sizeof((subtypes)[0]) + 0), subtype);
643}

645static const char * const treqs[] = {
[NVMF_TREQ_NOT_SPECIFIED]	= "not specified",
[NVMF_TREQ_REQUIRED]		= "required",
[NVMF_TREQ_NOT_REQUIRED]	= "not required",
[NVMF_TREQ_NOT_SPECIFIED |
NVMF_TREQ_DISABLE_SQFLOW]	= "not specified, "
		"sq flow control disable supported",
[NVMF_TREQ_REQUIRED |
NVMF_TREQ_DISABLE_SQFLOW]	= "required, "
		"sq flow control disable supported",
[NVMF_TREQ_NOT_REQUIRED |
NVMF_TREQ_DISABLE_SQFLOW]	= "not required, "
		"sq flow control disable supported",
658};

660__shr_public__attribute__((visibility("default"))) const char *libnvmf_treq_str(__u8 treq)
661{
return arg_str(treqs, ARRAY_SIZE(treqs)(sizeof(treqs) / sizeof((treqs)[0]) + 0), treq);
663}

665static const char * const eflags_strings[] = {
[NVMF_DISC_EFLAGS_NONE]		= "none",
[NVMF_DISC_EFLAGS_EPCSD]	= "explicit discovery connections",
[NVMF_DISC_EFLAGS_DUPRETINFO]	= "duplicate discovery information",
[NVMF_DISC_EFLAGS_EPCSD |
NVMF_DISC_EFLAGS_DUPRETINFO]	= "explicit discovery connections, "
			  "duplicate discovery information",
[NVMF_DISC_EFLAGS_NCC]		= "no cdc connectivity",
[NVMF_DISC_EFLAGS_EPCSD |
NVMF_DISC_EFLAGS_NCC]		= "explicit discovery connections, "
			  "no cdc connectivity",
[NVMF_DISC_EFLAGS_DUPRETINFO |
NVMF_DISC_EFLAGS_NCC]		= "duplicate discovery information, "
			  "no cdc connectivity",
[NVMF_DISC_EFLAGS_EPCSD |
NVMF_DISC_EFLAGS_DUPRETINFO |
NVMF_DISC_EFLAGS_NCC]		= "explicit discovery connections, "
			  "duplicate discovery information, "
			  "no cdc connectivity",
684};

686__shr_public__attribute__((visibility("default"))) const char *libnvmf_eflags_str(__u16 eflags)
687{
return arg_str(eflags_strings, ARRAY_SIZE(eflags_strings)(sizeof(eflags_strings) / sizeof((eflags_strings)[0]) + 0), eflags);
689}

691static const char * const sectypes[] = {
[NVMF_TCP_SECTYPE_NONE]		= "none",
[NVMF_TCP_SECTYPE_TLS]		= "tls",
[NVMF_TCP_SECTYPE_TLS13]	= "tls13",
695};

697__shr_public__attribute__((visibility("default"))) const char *libnvmf_sectype_str(__u8 sectype)
698{
return arg_str(sectypes, ARRAY_SIZE(sectypes)(sizeof(sectypes) / sizeof((sectypes)[0]) + 0), sectype);
700}

702static const char * const prtypes[] = {
[NVMF_RDMA_PRTYPE_NOT_SPECIFIED]	= "not specified",
[NVMF_RDMA_PRTYPE_IB]			= "infiniband",
[NVMF_RDMA_PRTYPE_ROCE]			= "roce",
[NVMF_RDMA_PRTYPE_ROCEV2]		= "roce-v2",
[NVMF_RDMA_PRTYPE_IWARP]		= "iwarp",
708};

710__shr_public__attribute__((visibility("default"))) const char *libnvmf_prtype_str(__u8 prtype)
711{
return arg_str(prtypes, ARRAY_SIZE(prtypes)(sizeof(prtypes) / sizeof((prtypes)[0]) + 0), prtype);
713}

715static const char * const qptypes[] = {
[NVMF_RDMA_QPTYPE_CONNECTED]	= "connected",
[NVMF_RDMA_QPTYPE_DATAGRAM]	= "datagram",
718};

720__shr_public__attribute__((visibility("default"))) const char *libnvmf_qptype_str(__u8 qptype)
721{
return arg_str(qptypes, ARRAY_SIZE(qptypes)(sizeof(qptypes) / sizeof((qptypes)[0]) + 0), qptype);
723}

725static const char * const cms[] = {
[NVMF_RDMA_CMS_RDMA_CM]	= "rdma-cm",
727};

729__shr_public__attribute__((visibility("default"))) const char *libnvmf_cms_str(__u8 cm)
730{
return arg_str(cms, ARRAY_SIZE(cms)(sizeof(cms) / sizeof((cms)[0]) + 0), cm);
732}

734void libnvmf_default_config(struct libnvme_fabrics_config *cfg)
735{
cfg->tos = -1;
cfg->ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO600;
738}

740__shr_public__attribute__((visibility("default"))) int libnvmf_context_create(struct libnvme_global_ctx *ctx,
bool_Bool (*decide_retry)(struct libnvmf_context *fctx, int err,
	void *user_data),
void (*connected)(struct libnvmf_context *fctx,
	struct libnvme_ctrl *c, void *user_data),
void (*already_connected)(struct libnvmf_context *fctx,
	struct libnvme_host *host, const char *subsysnqn,
	const char *transport, const char *traddr,
	const char *trsvcid, void *user_data),
void *user_data, struct libnvmf_context **fctxp)
750{
struct libnvmf_context *fctx;

fctx = calloc(1, sizeof(*fctx));
if (!fctx)
return -ENOMEM12;

fctx->ctx = ctx;

libnvmf_default_config(&fctx->ctrl_params.cfg);

fctx->hooks.decide_retry = decide_retry;
fctx->hooks.connected = connected;
fctx->hooks.already_connected = already_connected;

fctx->hooks.user_data = user_data;

*fctxp = fctx;
return 0;
769}

771/* The TLS key may be the PSK itself, in the interchange format. */
772static void free_tls_key(char *tls_key)
773{
if (!tls_key)
return;
explicit_bzero(tls_key, strlen(tls_key));
free(tls_key);
778}

780__shr_public__attribute__((visibility("default"))) void libnvmf_context_free(struct libnvmf_context *fctx)
781{
if (!fctx)
return;

free(fctx->nbft_path);
free(fctx->hostnqn);
free(fctx->hostid);
free_tls_key(fctx->tls_key);
free(fctx);
790}

792__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_discovery_hooks(
struct libnvmf_context *fctx,
void (*discovery_log)(struct libnvmf_context *fctx,
	const struct nvmf_discovery_log *log,
	uint64_t numrec, void *user_data))
797{
fctx->hooks.discovery_log = discovery_log;

return 0;
801}



805__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_connection(
struct libnvmf_context *fctx, const char *subsysnqn,
const char *transport, const char *traddr, const char *trsvcid,
const char *host_traddr, const char *host_iface)
809{
fctx->ctrl_params.subsysnqn = subsysnqn;
fctx->ctrl_params.transport = transport;
fctx->ctrl_params.traddr = traddr;
fctx->ctrl_params.trsvcid = trsvcid;
fctx->ctrl_params.host_traddr = host_traddr;
fctx->ctrl_params.host_iface = host_iface;

return 0;
818}

820static const char *hostid_from_hostnqn(const char *hostnqn)
821{
const char *match;

if (!hostnqn)
return NULL((void*)0);

match = strstr(hostnqn, "uuid:")_Generic (0 ? (hostnqn) : (void *) 1, const void *: (const char
 *) (strstr (hostnqn, "uuid:")), default: strstr (hostnqn, "uuid:"
));
if (!match)
return NULL((void*)0);

return match + strlen("uuid:");
832}

834__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_hostnqn(struct libnvmf_context *fctx,
const char *hostnqn, const char *hostid)
836{
char *hnqn;
char *hid;

if (!hostnqn)
return -EINVAL22;

hnqn = strdup(hostnqn);
if (!hnqn)
return -ENOMEM12;

if (!hostid)
hostid = hostid_from_hostnqn(hostnqn);

if (!hostid) {
free(hnqn);
return -EINVAL22;
}

hid = strdup(hostid);
if (!hid) {
free(hnqn);
return -ENOMEM12;
}

free(fctx->hostnqn);
free(fctx->hostid);
fctx->hostnqn = hnqn;
fctx->hostid = hid;

return 0;
867}

869__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_connection_from_tid(
struct libnvmf_context *fctx, const struct libnvmf_tid *tid)
871{
if (!fctx || !tid)
return -EINVAL22;

fctx->ctrl_params.subsysnqn = tid->subsysnqn;
fctx->ctrl_params.transport = tid->transport;
fctx->ctrl_params.traddr = tid->traddr;
fctx->ctrl_params.trsvcid = tid->trsvcid;
fctx->ctrl_params.host_traddr = tid->host_traddr;
fctx->ctrl_params.host_iface = tid->host_iface;

return libnvmf_context_set_hostnqn(fctx, tid->hostnqn, tid->hostid);
883}

885__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_crypto(struct libnvmf_context *fctx,
const char *hostkey, const char *ctrlkey,
const char *keyring, const char *tls_key,
const char *tls_key_identity)
889{
int err;

fctx->hostkey = hostkey;
fctx->ctrlkey = ctrlkey;
fctx->keyring = keyring;
fctx->tls_key_identity = tls_key_identity;

if (!tls_key)
return 0;

if (!strncmp(tls_key, "pin:", 4)) {
unsigned char *raw_secret = NULL((void*)0);
char *encoded_key = NULL((void*)0);
int key_len = 32;

err = libnvmf_create_raw_secret(fctx->ctx, tls_key,
	key_len, &raw_secret);
if (err)
	return err;

err = libnvmf_export_tls_key(fctx->ctx, raw_secret,
	key_len, &encoded_key);
explicit_bzero(raw_secret, key_len);
free(raw_secret);
if (err)
	return err;

free_tls_key(fctx->tls_key);
fctx->tls_key = encoded_key;
return 0;
}

free_tls_key(fctx->tls_key);
fctx->tls_key = strdup(tls_key);
return 0;
925}

927__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_device(
struct libnvmf_context *fctx, const char *device)
929{
fctx->device = device;

return 0;
933}

935__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_devid_file(
struct libnvmf_context *fctx, const char *devid_file)
937{
fctx->devid_file = devid_file;

return 0;
941}

943/*
* O_NOFOLLOW guards the one hazard the caller can't see: a symlink at the
* final path component. O_TRUNC is deliberately absent -- a name recorded
* by an earlier successful connect must survive a failed one.
*
* Return: an open fd, or -errno.
*/
950static int open_devid_file(struct libnvmf_context *fctx)
951{
int fd;

fd = open(fctx->devid_file,
O_WRONLY01 | O_CREAT0100 | O_CLOEXEC02000000 | O_NOFOLLOW0400000, 0644);
if (fd < 0) {
libnvme_msg(fctx->ctx, LIBNVME_LOG_ERR,__libnvme_msg(fctx->ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)))
	"failed to open devid-file %s: %s\n",__libnvme_msg(fctx->ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)))
	fctx->devid_file, libnvme_strerror(errno))__libnvme_msg(fctx->ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)));
return -errno(*__errno_location ());
}

return fd;
964}

966static void write_devid_file(struct libnvmf_context *fctx, int fd,
struct libnvme_ctrl *c)
968{
if (fd < 0 || !c)
return;

if (ftruncate(fd, 0) < 0 ||
   dprintf(fd, "%s\n", libnvme_ctrl_get_name(c)) < 0)
libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN,__libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN, ((void*)0), "failed to write devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)))
	"failed to write devid-file %s: %s\n",__libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN, ((void*)0), "failed to write devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)))
	fctx->devid_file, libnvme_strerror(errno))__libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN, ((void*)0), "failed to write devid-file %s: %s\n"
, fctx->devid_file, libnvme_strerror((*__errno_location ()
)));
977}

979__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_io_queues(
struct libnvmf_context *fctx, int nr_io_queues,
int nr_write_queues, int nr_poll_queues,
int queue_size, bool_Bool disable_sqflow)
983{
fctx->ctrl_params.cfg.nr_io_queues = nr_io_queues;
fctx->ctrl_params.cfg.nr_write_queues = nr_write_queues;
fctx->ctrl_params.cfg.nr_poll_queues = nr_poll_queues;
fctx->ctrl_params.cfg.queue_size = queue_size;
fctx->ctrl_params.cfg.disable_sqflow = disable_sqflow;

return 0;
991}

993__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_reconnect_policy(
struct libnvmf_context *fctx, int ctrl_loss_tmo,
int reconnect_delay, int fast_io_fail_tmo)
996{
fctx->ctrl_params.cfg.ctrl_loss_tmo = ctrl_loss_tmo;
fctx->ctrl_params.cfg.reconnect_delay = reconnect_delay;
fctx->ctrl_params.cfg.fast_io_fail_tmo = fast_io_fail_tmo;

return 0;
1002}

1004/*
* Derived from Linux's supported options (the opt_tokens table)
* when the mechanism to report supported options was added (f18ee3d988157).
* Not all of these options may actually be supported,
* but we retain the old behavior of passing all that might be.
*/
1010static const struct libnvme_fabric_options default_supported_options = {
.ctrl_loss_tmo = true1,
.data_digest = true1,
.disable_sqflow = true1,
.discovery = true1,
.duplicate_connect = true1,
.fast_io_fail_tmo = true1,
.hdr_digest = true1,
.host_iface = true1,
.host_traddr = true1,
.hostid = true1,
.hostnqn = true1,
.keep_alive_tmo = true1,
.nqn = true1,
.nr_io_queues = true1,
.nr_poll_queues = true1,
.nr_write_queues = true1,
.queue_size = true1,
.reconnect_delay = true1,
.tos = true1,
.traddr = true1,
.transport = true1,
.trsvcid = true1,
1033};

1035#define MERGE_CFG_OPTION(c, n, o, d)if ((c)->o == d) (c)->o = (n)->o			\
if ((c)->o == d) (c)->o = (n)->o
1037static void merge_config(struct libnvme_ctrl *c,
const struct libnvme_fabrics_config *cfg)
1039{
MERGE_CFG_OPTION(&c->cfg, cfg, nr_io_queues, 0)if ((&c->cfg)->nr_io_queues == 0) (&c->cfg)->
nr_io_queues = (cfg)->nr_io_queues;
MERGE_CFG_OPTION(&c->cfg, cfg, nr_write_queues, 0)if ((&c->cfg)->nr_write_queues == 0) (&c->cfg
)->nr_write_queues = (cfg)->nr_write_queues;
MERGE_CFG_OPTION(&c->cfg, cfg, nr_poll_queues, 0)if ((&c->cfg)->nr_poll_queues == 0) (&c->cfg
)->nr_poll_queues = (cfg)->nr_poll_queues;
MERGE_CFG_OPTION(&c->cfg, cfg, queue_size, 0)if ((&c->cfg)->queue_size == 0) (&c->cfg)->
queue_size = (cfg)->queue_size;
MERGE_CFG_OPTION(&c->cfg, cfg, keep_alive_tmo, 0)if ((&c->cfg)->keep_alive_tmo == 0) (&c->cfg
)->keep_alive_tmo = (cfg)->keep_alive_tmo;
MERGE_CFG_OPTION(&c->cfg, cfg, reconnect_delay, 0)if ((&c->cfg)->reconnect_delay == 0) (&c->cfg
)->reconnect_delay = (cfg)->reconnect_delay;
MERGE_CFG_OPTION(&c->cfg, cfg, ctrl_loss_tmo,if ((&c->cfg)->ctrl_loss_tmo == 600) (&c->cfg
)->ctrl_loss_tmo = (cfg)->ctrl_loss_tmo
	  NVMF_DEF_CTRL_LOSS_TMO)if ((&c->cfg)->ctrl_loss_tmo == 600) (&c->cfg
)->ctrl_loss_tmo = (cfg)->ctrl_loss_tmo;
MERGE_CFG_OPTION(&c->cfg, cfg, fast_io_fail_tmo, 0)if ((&c->cfg)->fast_io_fail_tmo == 0) (&c->cfg
)->fast_io_fail_tmo = (cfg)->fast_io_fail_tmo;
MERGE_CFG_OPTION(&c->cfg, cfg, tos, -1)if ((&c->cfg)->tos == -1) (&c->cfg)->tos =
 (cfg)->tos;
MERGE_CFG_OPTION(&c->cfg, cfg, keyring_id, 0)if ((&c->cfg)->keyring_id == 0) (&c->cfg)->
keyring_id = (cfg)->keyring_id;
MERGE_CFG_OPTION(&c->cfg, cfg, tls_key_id, 0)if ((&c->cfg)->tls_key_id == 0) (&c->cfg)->
tls_key_id = (cfg)->tls_key_id;
MERGE_CFG_OPTION(&c->cfg, cfg, tls_configured_key_id, 0)if ((&c->cfg)->tls_configured_key_id == 0) (&c->
cfg)->tls_configured_key_id = (cfg)->tls_configured_key_id;
MERGE_CFG_OPTION(&c->cfg, cfg, duplicate_connect, false)if ((&c->cfg)->duplicate_connect == 0) (&c->
cfg)->duplicate_connect = (cfg)->duplicate_connect;
MERGE_CFG_OPTION(&c->cfg, cfg, disable_sqflow, false)if ((&c->cfg)->disable_sqflow == 0) (&c->cfg
)->disable_sqflow = (cfg)->disable_sqflow;
MERGE_CFG_OPTION(&c->cfg, cfg, hdr_digest, false)if ((&c->cfg)->hdr_digest == 0) (&c->cfg)->
hdr_digest = (cfg)->hdr_digest;
MERGE_CFG_OPTION(&c->cfg, cfg, data_digest, false)if ((&c->cfg)->data_digest == 0) (&c->cfg)->
data_digest = (cfg)->data_digest;
MERGE_CFG_OPTION(&c->cfg, cfg, tls, false)if ((&c->cfg)->tls == 0) (&c->cfg)->tls =
 (cfg)->tls;
MERGE_CFG_OPTION(&c->cfg, cfg, concat, false)if ((&c->cfg)->concat == 0) (&c->cfg)->concat
 = (cfg)->concat;
1059}

1061/*
* Like merge_config(): fill in only what @c does not have. The host and
* controller keys are one pair, so a host key on @c keeps fc's
* controller key out.
*/
1066static void ctrl_merge_keys(struct libnvme_ctrl *c,
const struct libnvme_ctrl *fc)
1068{
const char *key;

if (libnvme_ctrl_get_kxchap_host_key(c, &key, NULL((void*)0)) &&
   !libnvme_ctrl_get_kxchap_host_key(fc, &key, NULL((void*)0))) {
libnvme_ctrl_set_kxchap_host_key(c, key);
if (!libnvme_ctrl_get_kxchap_ctrl_key(fc, &key, NULL((void*)0)))
	libnvme_ctrl_set_kxchap_ctrl_key(c, key);
}
if (libnvme_ctrl_get_keyring(c, &key, NULL((void*)0)) &&
   !libnvme_ctrl_get_keyring(fc, &key, NULL((void*)0)))
libnvme_ctrl_set_keyring(c, key);
if (!libnvme_ctrl_get_tls_key_identity(c)) {
key = libnvme_ctrl_get_tls_key_identity(fc);
if (key)
	libnvme_ctrl_set_tls_key_identity(c, key);
}
if (!libnvme_ctrl_get_tls_key(c)) {
key = libnvme_ctrl_get_tls_key(fc);
if (key)
	libnvme_ctrl_set_tls_key(c, key);
}
1090}

1092#define UPDATE_CFG_OPTION(c, n, o, d)if ((n)->o != d) (c)->o = (n)->o			\
if ((n)->o != d) (c)->o = (n)->o
1094static void update_config(struct libnvme_ctrl *c,
const struct libnvme_fabrics_config *cfg)
1096{
UPDATE_CFG_OPTION(&c->cfg, cfg, nr_io_queues, 0)if ((cfg)->nr_io_queues != 0) (&c->cfg)->nr_io_queues
 = (cfg)->nr_io_queues;
UPDATE_CFG_OPTION(&c->cfg, cfg, nr_write_queues, 0)if ((cfg)->nr_write_queues != 0) (&c->cfg)->nr_write_queues
 = (cfg)->nr_write_queues;
UPDATE_CFG_OPTION(&c->cfg, cfg, nr_poll_queues, 0)if ((cfg)->nr_poll_queues != 0) (&c->cfg)->nr_poll_queues
 = (cfg)->nr_poll_queues;
UPDATE_CFG_OPTION(&c->cfg, cfg, queue_size, 0)if ((cfg)->queue_size != 0) (&c->cfg)->queue_size
 = (cfg)->queue_size;
UPDATE_CFG_OPTION(&c->cfg, cfg, keep_alive_tmo, 0)if ((cfg)->keep_alive_tmo != 0) (&c->cfg)->keep_alive_tmo
 = (cfg)->keep_alive_tmo;
UPDATE_CFG_OPTION(&c->cfg, cfg, reconnect_delay, 0)if ((cfg)->reconnect_delay != 0) (&c->cfg)->reconnect_delay
 = (cfg)->reconnect_delay;
UPDATE_CFG_OPTION(&c->cfg, cfg, ctrl_loss_tmo,if ((cfg)->ctrl_loss_tmo != 600) (&c->cfg)->ctrl_loss_tmo
 = (cfg)->ctrl_loss_tmo
	  NVMF_DEF_CTRL_LOSS_TMO)if ((cfg)->ctrl_loss_tmo != 600) (&c->cfg)->ctrl_loss_tmo
 = (cfg)->ctrl_loss_tmo;
UPDATE_CFG_OPTION(&c->cfg, cfg, fast_io_fail_tmo, 0)if ((cfg)->fast_io_fail_tmo != 0) (&c->cfg)->fast_io_fail_tmo
 = (cfg)->fast_io_fail_tmo;
UPDATE_CFG_OPTION(&c->cfg, cfg, tos, -1)if ((cfg)->tos != -1) (&c->cfg)->tos = (cfg)->
tos;
UPDATE_CFG_OPTION(&c->cfg, cfg, keyring_id, 0)if ((cfg)->keyring_id != 0) (&c->cfg)->keyring_id
 = (cfg)->keyring_id;
UPDATE_CFG_OPTION(&c->cfg, cfg, tls_key_id, 0)if ((cfg)->tls_key_id != 0) (&c->cfg)->tls_key_id
 = (cfg)->tls_key_id;
UPDATE_CFG_OPTION(&c->cfg, cfg, tls_configured_key_id, 0)if ((cfg)->tls_configured_key_id != 0) (&c->cfg)->
tls_configured_key_id = (cfg)->tls_configured_key_id;
UPDATE_CFG_OPTION(&c->cfg, cfg, duplicate_connect, false)if ((cfg)->duplicate_connect != 0) (&c->cfg)->duplicate_connect
 = (cfg)->duplicate_connect;
UPDATE_CFG_OPTION(&c->cfg, cfg, disable_sqflow, false)if ((cfg)->disable_sqflow != 0) (&c->cfg)->disable_sqflow
 = (cfg)->disable_sqflow;
UPDATE_CFG_OPTION(&c->cfg, cfg, hdr_digest, false)if ((cfg)->hdr_digest != 0) (&c->cfg)->hdr_digest
 = (cfg)->hdr_digest;
UPDATE_CFG_OPTION(&c->cfg, cfg, data_digest, false)if ((cfg)->data_digest != 0) (&c->cfg)->data_digest
 = (cfg)->data_digest;
UPDATE_CFG_OPTION(&c->cfg, cfg, tls, false)if ((cfg)->tls != 0) (&c->cfg)->tls = (cfg)->
tls;
UPDATE_CFG_OPTION(&c->cfg, cfg, concat, false)if ((cfg)->concat != 0) (&c->cfg)->concat = (cfg
)->concat;
1116}

1118static int __add_bool_argument(char **argstr, char *tok, bool_Bool arg)
1119{
char *nstr;

if (!arg)
return 0;
if (asprintf(&nstr, "%s,%s", *argstr, tok) < 0) {
return -ENOMEM12;
}
free(*argstr);
*argstr = nstr;

return 0;
1131}

1133static int __add_hex_argument(char **argstr, char *tok, int arg, bool_Bool allow_zero)
1134{
char *nstr;

if (arg < 0 || (!arg && !allow_zero))
return 0;
if (asprintf(&nstr, "%s,%s=0x%08x", *argstr, tok, arg) < 0) {
return -ENOMEM12;
}
free(*argstr);
*argstr = nstr;

return 0;
1146}

1148static int __add_int_argument(char **argstr, char *tok, int arg, bool_Bool allow_zero)
1149{
char *nstr;

if (arg < 0 || (!arg && !allow_zero))
return 0;
if (asprintf(&nstr, "%s,%s=%d", *argstr, tok, arg) < 0) {
return -ENOMEM12;
}
free(*argstr);
*argstr = nstr;

return 0;
1161}

1163static int __add_int_or_minus_one_argument(char **argstr, char *tok, int arg)
1164{
char *nstr;

if (arg < -1)
return 0;
if (asprintf(&nstr, "%s,%s=%d", *argstr, tok, arg) < 0) {
return -ENOMEM12;
}
free(*argstr);
*argstr = nstr;

return 0;
1176}

1178static int __add_argument(char **argstr, const char *tok, const char *arg)
1179{
char *nstr;

if (!arg || arg[0] == '\0' || !strcmp(arg, "none"))
return 0;
if (asprintf(&nstr, "%s,%s=%s", *argstr, tok, arg) < 0) {
return -ENOMEM12;
}
free(*argstr);
*argstr = nstr;

return 0;
1191}

1193static int __nvmf_supported_options(struct libnvme_global_ctx *ctx);
1194#define nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })					\
1195({									\
!__nvmf_supported_options(ctx) && ctx->options->tok;		\
1197})

1199#define add_bool_argument(ctx, argstr, tok, arg)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tok; })) { ret = __add_bool_argument(argstr,
 "tok", arg); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, (
(void*)0), "option \"%s\" ignored\n", "tok"); ret = 0; } ret;
 })			\
1200({									\
int ret;							\
if (nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })) {				\
ret = __add_bool_argument(argstr,			\
			  stringify(tok)"tok",		\
			  arg);				\
} else {							\
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,				\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 "option \"%s\" ignored\n",			\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 stringify(tok))__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok");				\
ret = 0;						\
}								\
ret;								\
1213})

1215#define add_hex_argument(ctx, argstr, tok, arg, allow_zero)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tok; })) { ret = __add_hex_argument(argstr, "tok"
, arg, allow_zero); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tok"); ret = 0; } ret
; })		\
1216({									\
int ret;							\
if (nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })) {				\
ret = __add_hex_argument(argstr,			\
			stringify(tok)"tok",			\
			arg,				\
			allow_zero);			\
} else {							\
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,				\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 "option \"%s\" ignored\n",			\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 stringify(tok))__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok");				\
ret = 0;						\
}								\
ret;								\
1230})

1232#define add_int_argument(ctx, argstr, tok, arg, allow_zero)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tok; })) { ret = __add_int_argument(argstr, "tok"
, arg, allow_zero); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tok"); ret = 0; } ret
; })		\
1233({									\
int ret;							\
if (nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })) {				\
ret = __add_int_argument(argstr,			\
			stringify(tok)"tok",			\
			arg,				\
			allow_zero);			\
} else {							\
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,				\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 "option \"%s\" ignored\n",			\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 stringify(tok))__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok");				\
ret = 0;						\
}								\
ret;								\
1247})

1249#define add_int_or_minus_one_argument(ctx, argstr, tok, arg)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tok; })) { ret = __add_int_or_minus_one_argument
(argstr, "tok", arg); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tok"); ret = 0; } ret
; })		\
1250({									\
int ret;							\
if (nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })) {				\
ret = __add_int_or_minus_one_argument(argstr,		\
				     stringify(tok)"tok",	\
				     arg);		\
} else {							\
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,				\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 "option \"%s\" ignored\n",			\__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 stringify(tok))__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "tok");				\
ret = 0;						\
}								\
ret;								\
1263})

1265#define add_argument(ctx, argstr, tok, arg)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tok; })) { ret = __add_argument(argstr, "tok"
, arg); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*
)0), "option \"%s\" ignored\n", "tok"); ret = 0; } ret; })				\
1266({									\
int ret;							\
if (nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })) {				\
ret = __add_argument(argstr,				\
		     stringify(tok)"tok",			\
		     arg);				\
} else {							\
libnvme_msg(ctx, LIBNVME_LOG_WARN,				\__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 "option \"%s\" ignored\n",			\__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "tok")
	 stringify(tok))__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "tok");				\
ret = 0;						\
}								\
ret;								\
1279})

1281static int inet4_pton(const char *src, uint16_t port,
      struct sockaddr_storage *addr)
1283{
struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;

if (strlen(src) > INET_ADDRSTRLEN16)
return -EINVAL22;

if (inet_pton(AF_INET2, src, &addr4->sin_addr.s_addr) <= 0)
return -EINVAL22;

addr4->sin_family = AF_INET2;
addr4->sin_port = htons(port)__bswap_16 (port);

return 0;
1296}

1298static int inet6_pton(struct libnvme_global_ctx *ctx, const char *src, uint16_t port,
      struct sockaddr_storage *addr)
1300{
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
const char *scope = NULL((void*)0);
char *p;

__cleanup_free__attribute__((cleanup(shr_freep))) char *tmp = strdup(src);
if (!tmp) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "cannot copy: %s\n", src)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "cannot copy: %s\n"
, src);
return -ENOMEM12;
}

p = strchr(tmp, '%')_Generic (0 ? (tmp) : (void *) 1, const void *: (const char *
) (strchr (tmp, '%')), default: strchr (tmp, '%'));
if (p) {
*p = '\0';
scope = src + (p - tmp) + 1;
}

if (inet_pton(AF_INET610, tmp, &addr6->sin6_addr) != 1)
return -EINVAL22;

if (IN6_IS_ADDR_LINKLOCAL(&addr6->sin6_addr)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (&addr6->sin6_addr); (__a->__in6_u.__u6_addr32[
0] & __bswap_32 (0xffc00000)) == __bswap_32 (0xfe800000);
 })) && scope) {
addr6->sin6_scope_id = if_nametoindex(scope);
if (addr6->sin6_scope_id == 0) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "can't find iface index for: %s (%m)\n"
, scope)
		 "can't find iface index for: %s (%m)\n", scope)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "can't find iface index for: %s (%m)\n"
, scope);
	return -EINVAL22;
}
}

addr6->sin6_family = AF_INET610;
addr6->sin6_port = htons(port)__bswap_16 (port);
return 0;
1332}

1334/**
* inet_pton_with_scope - convert an IPv4/IPv6 to socket address
* @ctx: Global context
* @af: address family, AF_INET, AF_INET6 or AF_UNSPEC for either
* @src: the start of the address string
* @trsvcid: transport service identifier
* @addr: output socket address
*
* Return 0 on success, errno otherwise.
*/
1344static int inet_pton_with_scope(struct libnvme_global_ctx *ctx, int af,
		const char *src, const char * trsvcid,
		struct sockaddr_storage *addr)
1347{
int      ret  = -EINVAL22;
uint16_t port = 0;

if (trsvcid) {
unsigned long long tmp = strtoull(trsvcid, NULL((void*)0), 0);
port = (uint16_t)tmp;
if (tmp != port) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR, "trsvcid out of range: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "trsvcid out of range: %s\n"
, trsvcid)
		 trsvcid)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "trsvcid out of range: %s\n"
, trsvcid);
	return -ERANGE34;
}
} else {
port = 0;
}

switch (af) {
case AF_INET2:
ret = inet4_pton(src, port, addr);
break;
case AF_INET610:
ret = inet6_pton(ctx, src, port, addr);
break;
case AF_UNSPEC0:
ret = inet4_pton(src, port, addr);
if (ret)
	ret = inet6_pton(ctx, src, port, addr);
break;
default:
libnvme_msg(ctx, LIBNVME_LOG_ERR, "unexpected address family %d\n", af)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "unexpected address family %d\n"
, af);
}

return ret;
1380}

1382bool_Bool traddr_is_hostname(struct libnvme_global_ctx *ctx,
const char *transport, const char *traddr)
1384{
if (!traddr || !transport)
return false0;
if (!strcmp(traddr, "none"))
return false0;
if (strcmp(transport, "tcp") && strcmp(transport, "rdma"))
return false0;

return !libnvmf_traddr_is_numeric(traddr);
1393}

1395/*
* Reject a hostname traddr/host_traddr and canonicalize a numeric one,
* routing the check through the TID constructor so the tree keeps one
* definition of acceptable and canonical addressing.  Resolving a
* hostname is the caller's job, not libnvme's, so the connect paths
* simply refuse one instead of resolving it.
*/
1402static int nvmf_sanitize_addrs(struct libnvme_global_ctx *ctx, struct libnvme_ctrl *c)
1403{
struct libnvmf_tid *tid;
const char *canon;
char *dup;
int rc;

if (traddr_is_hostname(ctx, c->transport, c->traddr)) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr)
	"traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr)
	c->traddr)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr);
return -ENVME_CONNECT_TRADDR;
}

if (traddr_is_hostname(ctx, c->transport, c->host_traddr)) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host-traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->host_traddr)
	"host-traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host-traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->host_traddr)
	c->host_traddr)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host-traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->host_traddr);
return -ENVME_CONNECT_TRADDR;
}

rc = libnvmf_tid_from_fields(c->transport, c->traddr, c->trsvcid,
	NULL((void*)0), c->host_traddr, c->host_iface, NULL((void*)0), NULL((void*)0), &tid);
if (rc)
return rc;

canon = libnvmf_tid_get_traddr(tid);
if (canon) {
dup = strdup(canon);
if (!dup) {
	libnvmf_tid_free(tid);
	return -ENOMEM12;
}
free(c->traddr);
c->traddr = dup;
}

canon = libnvmf_tid_get_host_traddr(tid);
if (canon) {
dup = strdup(canon);
if (!dup) {
	libnvmf_tid_free(tid);
	return -ENOMEM12;
}
free(c->host_traddr);
c->host_traddr = dup;
}

libnvmf_tid_free(tid);

return 0;
1453}

1455static int build_options(struct libnvme_host *h, struct libnvme_ctrl *c, char **argstr)
1456{
const char *transport = libnvme_ctrl_get_transport(c);
const char *hostnqn, *hostid, *hostkey, *ctrlkey = NULL((void*)0);
bool_Bool discover = false0, discovery_nqn = false0;
struct libnvme_global_ctx *ctx = h->ctx;
long keyring_id = 0;
long key_id = 0;
int ret;

if (!transport) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "need a transport (-t) argument\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "need a transport (-t) argument\n"
);
return -ENVME_CONNECT_TARG;
}

if (strncmp(transport, "loop", 4)) {
if (!libnvme_ctrl_get_traddr(c)) {
	libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "need a address (-a) argument\n")__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "need a address (-a) argument\n"
);
	return -ENVME_CONNECT_AARG;
}
}

/* always specify nqn as first arg - this will init the string */
if (asprintf(argstr, "nqn=%s",
     libnvme_ctrl_get_subsysnqn(c)) < 0) {
return -ENOMEM12;
}

if (!strcmp(libnvme_ctrl_get_subsysnqn(c), NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery")) {
libnvme_ctrl_set_discovery_ctrl(c, true1);
libnvme_ctrl_set_unique_discovery_ctrl(c, false0);
discovery_nqn = true1;
}

if (libnvme_ctrl_get_discovery_ctrl(c))
discover = true1;

hostnqn = libnvme_host_get_hostnqn(h);
hostid = libnvme_host_get_hostid(h);
libnvme_ctrl_get_kxchap_host_key(c, &hostkey, NULL((void*)0));
if (!hostkey)
hostkey = libnvme_host_get_kxchap_host_key(h);

if (hostkey)
libnvme_ctrl_get_kxchap_ctrl_key(c, &ctrlkey, NULL((void*)0));

if (c->cfg.tls && c->cfg.concat) {
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "cannot specify --tls and --concat together\n")__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "cannot specify --tls and --concat together\n"
);
return -ENVME_CONNECT_INVAL;
}

if (c->cfg.concat && !hostkey) {
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "required argument [--kxchap-secret | -S] not specified with --concat\n")__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "required argument [--kxchap-secret | -S] not specified with --concat\n"
);
return -ENVME_CONNECT_INVAL;
}

if (c->cfg.tls) {
ret = __libnvmf_import_keys_from_config(h, c,
	&keyring_id, &key_id);
if (ret)
	return ret;

if (key_id == 0) {
	if (c->cfg.tls_configured_key_id)
		key_id = c->cfg.tls_configured_key_id;
	else
		key_id = c->cfg.tls_key_id;
}
}

if (add_argument(ctx, argstr, transport, transport)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->transport; })) { ret = __add_argument(argstr
, "transport", transport); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "transport"); ret = 0
; } ret; }) ||
   add_argument(ctx, argstr, traddr,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->traddr; })) { ret = __add_argument(argstr, "traddr"
, libnvme_ctrl_get_traddr(c)); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "traddr"); ret = 0; }
 ret; })
	 libnvme_ctrl_get_traddr(c))({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->traddr; })) { ret = __add_argument(argstr, "traddr"
, libnvme_ctrl_get_traddr(c)); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "traddr"); ret = 0; }
 ret; }) ||
   add_argument(ctx, argstr, host_traddr,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->host_traddr; })) { ret = __add_argument(argstr
, "host_traddr", libnvme_ctrl_get_host_traddr(c)); } else { __libnvme_msg
(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "host_traddr"); ret = 0; } ret; })
	 libnvme_ctrl_get_host_traddr(c))({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->host_traddr; })) { ret = __add_argument(argstr
, "host_traddr", libnvme_ctrl_get_host_traddr(c)); } else { __libnvme_msg
(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "host_traddr"); ret = 0; } ret; }) ||
   add_argument(ctx, argstr, host_iface,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->host_iface; })) { ret = __add_argument(argstr
, "host_iface", libnvme_ctrl_get_host_iface(c)); } else { __libnvme_msg
(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "host_iface"); ret = 0; } ret; })
	 libnvme_ctrl_get_host_iface(c))({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->host_iface; })) { ret = __add_argument(argstr
, "host_iface", libnvme_ctrl_get_host_iface(c)); } else { __libnvme_msg
(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "host_iface"); ret = 0; } ret; }) ||
   add_argument(ctx, argstr, trsvcid,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->trsvcid; })) { ret = __add_argument(argstr, "trsvcid"
, libnvme_ctrl_get_trsvcid(c)); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "trsvcid"); ret = 0;
 } ret; })
	 libnvme_ctrl_get_trsvcid(c))({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->trsvcid; })) { ret = __add_argument(argstr, "trsvcid"
, libnvme_ctrl_get_trsvcid(c)); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "trsvcid"); ret = 0;
 } ret; }) ||
   (hostnqn && add_argument(ctx, argstr, hostnqn, hostnqn)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->hostnqn; })) { ret = __add_argument(argstr, "hostnqn"
, hostnqn); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void
*)0), "option \"%s\" ignored\n", "hostnqn"); ret = 0; } ret; }
)) ||
   (hostid && add_argument(ctx, argstr, hostid, hostid)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->hostid; })) { ret = __add_argument(argstr, "hostid"
, hostid); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void
*)0), "option \"%s\" ignored\n", "hostid"); ret = 0; } ret; }
)) ||
   (discover && !discovery_nqn &&
    add_bool_argument(ctx, argstr, discovery, true)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->discovery; })) { ret = __add_bool_argument(argstr
, "discovery", 1); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "discovery"); ret = 0
; } ret; })) ||
   (hostkey &&
    add_argument(ctx, argstr, dhchap_secret, hostkey)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->dhchap_secret; })) { ret = __add_argument(argstr
, "dhchap_secret", hostkey); } else { __libnvme_msg(ctx, LIBNVME_LOG_WARN
, ((void*)0), "option \"%s\" ignored\n", "dhchap_secret"); ret
 = 0; } ret; })) ||
   (ctrlkey &&
    add_argument(ctx, argstr, dhchap_ctrl_secret, ctrlkey)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->dhchap_ctrl_secret; })) { ret = __add_argument
(argstr, "dhchap_ctrl_secret", ctrlkey); } else { __libnvme_msg
(ctx, LIBNVME_LOG_WARN, ((void*)0), "option \"%s\" ignored\n"
, "dhchap_ctrl_secret"); ret = 0; } ret; })) ||
   (!discover &&
    add_int_argument(ctx, argstr, nr_io_queues,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_io_queues; })) { ret = __add_int_argument
(argstr, "nr_io_queues", c->cfg.nr_io_queues, 0); } else {
 __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_io_queues"); ret = 0; } ret; })
	      c->cfg.nr_io_queues, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_io_queues; })) { ret = __add_int_argument
(argstr, "nr_io_queues", c->cfg.nr_io_queues, 0); } else {
 __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_io_queues"); ret = 0; } ret; })) ||
   (!discover &&
    add_int_argument(ctx, argstr, nr_write_queues,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_write_queues; })) { ret = __add_int_argument
(argstr, "nr_write_queues", c->cfg.nr_write_queues, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_write_queues"); ret = 0; } ret; })
	      c->cfg.nr_write_queues, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_write_queues; })) { ret = __add_int_argument
(argstr, "nr_write_queues", c->cfg.nr_write_queues, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_write_queues"); ret = 0; } ret; })) ||
   (!discover &&
    add_int_argument(ctx, argstr, nr_poll_queues,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_poll_queues; })) { ret = __add_int_argument
(argstr, "nr_poll_queues", c->cfg.nr_poll_queues, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_poll_queues"); ret = 0; } ret; })
	      c->cfg.nr_poll_queues, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->nr_poll_queues; })) { ret = __add_int_argument
(argstr, "nr_poll_queues", c->cfg.nr_poll_queues, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "nr_poll_queues"); ret = 0; } ret; })) ||
   (!discover &&
    add_int_argument(ctx, argstr, queue_size,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->queue_size; })) { ret = __add_int_argument(argstr
, "queue_size", c->cfg.queue_size, 0); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "queue_size"); ret = 0; } ret; })
	      c->cfg.queue_size, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->queue_size; })) { ret = __add_int_argument(argstr
, "queue_size", c->cfg.queue_size, 0); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "queue_size"); ret = 0; } ret; })) ||
   add_int_argument(ctx, argstr, keep_alive_tmo,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->keep_alive_tmo; })) { ret = __add_int_argument
(argstr, "keep_alive_tmo", c->cfg.keep_alive_tmo, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "keep_alive_tmo"); ret = 0; } ret; })
	     c->cfg.keep_alive_tmo, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->keep_alive_tmo; })) { ret = __add_int_argument
(argstr, "keep_alive_tmo", c->cfg.keep_alive_tmo, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "keep_alive_tmo"); ret = 0; } ret; }) ||
   add_int_argument(ctx, argstr, reconnect_delay,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->reconnect_delay; })) { ret = __add_int_argument
(argstr, "reconnect_delay", c->cfg.reconnect_delay, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "reconnect_delay"); ret = 0; } ret; })
	     c->cfg.reconnect_delay, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->reconnect_delay; })) { ret = __add_int_argument
(argstr, "reconnect_delay", c->cfg.reconnect_delay, 0); } else
 { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "reconnect_delay"); ret = 0; } ret; }) ||
   (strcmp(transport, "loop") &&
    add_int_or_minus_one_argument(ctx, argstr, ctrl_loss_tmo,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->ctrl_loss_tmo; })) { ret = __add_int_or_minus_one_argument
(argstr, "ctrl_loss_tmo", c->cfg.ctrl_loss_tmo); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "ctrl_loss_tmo"); ret = 0; } ret; })
	      c->cfg.ctrl_loss_tmo)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->ctrl_loss_tmo; })) { ret = __add_int_or_minus_one_argument
(argstr, "ctrl_loss_tmo", c->cfg.ctrl_loss_tmo); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "ctrl_loss_tmo"); ret = 0; } ret; })) ||
   (strcmp(transport, "loop") &&
    add_int_argument(ctx, argstr, fast_io_fail_tmo,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->fast_io_fail_tmo; })) { ret = __add_int_argument
(argstr, "fast_io_fail_tmo", c->cfg.fast_io_fail_tmo, 0); }
 else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "fast_io_fail_tmo"); ret = 0; } ret; })
	      c->cfg.fast_io_fail_tmo, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->fast_io_fail_tmo; })) { ret = __add_int_argument
(argstr, "fast_io_fail_tmo", c->cfg.fast_io_fail_tmo, 0); }
 else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "fast_io_fail_tmo"); ret = 0; } ret; })) ||
   (strcmp(transport, "loop") &&
    add_int_argument(ctx, argstr, tos, c->cfg.tos, true)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tos; })) { ret = __add_int_argument(argstr, "tos"
, c->cfg.tos, 1); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tos"); ret = 0; } ret
; })) ||
   add_hex_argument(ctx, argstr, keyring, keyring_id, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->keyring; })) { ret = __add_hex_argument(argstr
, "keyring", keyring_id, 0); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "keyring"); ret = 0;
 } ret; }) ||
   (!strcmp(transport, "tcp") &&
    add_hex_argument(ctx, argstr, tls_key, key_id, false)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tls_key; })) { ret = __add_hex_argument(argstr
, "tls_key", key_id, 0); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tls_key"); ret = 0;
 } ret; })) ||
   add_bool_argument(ctx, argstr, duplicate_connect,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->duplicate_connect; })) { ret = __add_bool_argument
(argstr, "duplicate_connect", c->cfg.duplicate_connect); }
 else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "duplicate_connect"); ret = 0; } ret; })
	      c->cfg.duplicate_connect)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->duplicate_connect; })) { ret = __add_bool_argument
(argstr, "duplicate_connect", c->cfg.duplicate_connect); }
 else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "duplicate_connect"); ret = 0; } ret; }) ||
   add_bool_argument(ctx, argstr, disable_sqflow,({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->disable_sqflow; })) { ret = __add_bool_argument
(argstr, "disable_sqflow", c->cfg.disable_sqflow); } else {
 __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "disable_sqflow"); ret = 0; } ret; })
	      c->cfg.disable_sqflow)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->disable_sqflow; })) { ret = __add_bool_argument
(argstr, "disable_sqflow", c->cfg.disable_sqflow); } else {
 __libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "disable_sqflow"); ret = 0; } ret; }) ||
   (!strcmp(transport, "tcp") &&
    add_bool_argument(ctx, argstr, hdr_digest, c->cfg.hdr_digest)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->hdr_digest; })) { ret = __add_bool_argument(
argstr, "hdr_digest", c->cfg.hdr_digest); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "hdr_digest"); ret = 0; } ret; })) ||
   (!strcmp(transport, "tcp") &&
    add_bool_argument(ctx, argstr, data_digest, c->cfg.data_digest)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->data_digest; })) { ret = __add_bool_argument
(argstr, "data_digest", c->cfg.data_digest); } else { __libnvme_msg
(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "option \"%s\" ignored\n"
, "data_digest"); ret = 0; } ret; })) ||
   (!strcmp(transport, "tcp") &&
    add_bool_argument(ctx, argstr, tls, c->cfg.tls)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->tls; })) { ret = __add_bool_argument(argstr,
 "tls", c->cfg.tls); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "tls"); ret = 0; } ret
; })) ||
   (!strcmp(transport, "tcp") &&
    add_bool_argument(ctx, argstr, concat, c->cfg.concat)({ int ret; if (({ !__nvmf_supported_options(ctx) && ctx
->options->concat; })) { ret = __add_bool_argument(argstr
, "concat", c->cfg.concat); } else { __libnvme_msg(ctx, LIBNVME_LOG_DEBUG
, ((void*)0), "option \"%s\" ignored\n", "concat"); ret = 0; }
 ret; })))
return -1;

return 0;
1584}

1586#define parse_option(ctx, v, name)if (!strcmp(v, "name")) { ctx->options->name = 1; continue
; }	   		\
if (!strcmp(v, stringify(name)"name")) {	 	\
ctx->options->name = true1;		\
continue;		   		\
}

1592void _libnvmf_free_kernel_options(struct libnvme_global_ctx *ctx)
1593{
char **name;

if (ctx->kernel_options) {
for (name = ctx->kernel_options; *name; name++)
	free(*name);
free(ctx->kernel_options);
ctx->kernel_options = NULL((void*)0);
}
free(ctx->options);
ctx->options = NULL((void*)0);
1604}

1606static int add_kernel_option(struct libnvme_global_ctx *ctx, size_t *count,
const char *name)
1608{
char **names;

names = realloc(ctx->kernel_options, (*count + 2) * sizeof(*names));
if (!names)
return -ENOMEM12;
ctx->kernel_options = names;

names[*count] = strdup(name);
if (!names[*count])
return -ENOMEM12;
names[++*count] = NULL((void*)0);

return 0;
1622}

1624/*
* Writes @args, unless NULL, to /dev/nvme-fabrics and reads the response
* into @buf, which is NUL-terminated.
*
* Return: the length of the response or a negative errno. On failure,
* @step is the step which failed.
*/
1631static ssize_t nvmf_dev_xfer(struct libnvme_global_ctx *ctx,
const char *args, char *buf, size_t size,
enum libnvmf_dev_step *step)
1634{
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int fd = -1;
ssize_t len;

if (ctx->privsep)
return __libnvme_privsep_fabrics(ctx->privsep, args, buf, size,
				 step);

*step = LIBNVMF_DEV_OPEN;
fd = open(nvmf_dev, args ? O_RDWR02 : O_RDONLY00);
if (fd < 0)
return -errno(*__errno_location ());

if (args) {
*step = LIBNVMF_DEV_WRITE;
len = write(fd, args, strlen(args));
if (len < 0)
	return -errno(*__errno_location ());
if ((size_t)len != strlen(args))
	return -EIO5;
}

*step = LIBNVMF_DEV_READ;
len = read(fd, buf, size - 1);
if (len < 0)
return -errno(*__errno_location ());
buf[len] = '\0';

return len;
1663}

1665/*
* Read the options the kernel accepts from /dev/nvme-fabrics, once per
* @ctx. A failed read is not cached, so the next call retries it.
*/
1669static int __nvmf_supported_options(struct libnvme_global_ctx *ctx)
1670{
char buf[0x1000], *options, *p, *v;
enum libnvmf_dev_step step;
size_t count = 0;
ssize_t len;
int err;

if (ctx->options)
return 0;

ctx->options = calloc(1, sizeof(*ctx->options));
if (!ctx->options)
return -ENOMEM12;

len = nvmf_dev_xfer(ctx, NULL((void*)0), buf, sizeof(buf), &step);
if (len < 0 && step == LIBNVMF_DEV_OPEN) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to open %s: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror(-len))
	 nvmf_dev, libnvme_strerror(-len))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror(-len));
err = -ENVME_CONNECT_OPEN;
goto out_free;
}

if (len < 0) {
if (len == -EINVAL22) {
	/*
	 * Older Linux kernels don't allow reading from nvmf_dev
	 * to get supported options, so use a default set
	 */
	libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "Cannot read %s, using default options\n"
, nvmf_dev)
	         "Cannot read %s, using default options\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "Cannot read %s, using default options\n"
, nvmf_dev)
	         nvmf_dev)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "Cannot read %s, using default options\n"
, nvmf_dev);
	*ctx->options = default_supported_options;
	return 0;
}

libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to read from %s: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror(-len))
	 nvmf_dev, libnvme_strerror(-len))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror(-len));
err = -ENVME_CONNECT_READ;
goto out_free;
}

options = buf;

libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "kernel supports: ")__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "kernel supports: "
);

while ((p = shr_strsep(&options, ",\n")) != NULL((void*)0)) {
if (!*p)
	continue;
v = shr_strsep(&p, "= ");
if (!v)
	continue;
libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "%s ", v)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s ", v);

/* "instance" & "cntlid" are returned values, not options. */
if (strcmp(v, "instance") && strcmp(v, "cntlid")) {
	err = add_kernel_option(ctx, &count, v);
	if (err)
		goto out_free;
}

parse_option(ctx, v, cntlid)if (!strcmp(v, "cntlid")) { ctx->options->cntlid = 1; continue
; };
parse_option(ctx, v, concat)if (!strcmp(v, "concat")) { ctx->options->concat = 1; continue
; };
parse_option(ctx, v, ctrl_loss_tmo)if (!strcmp(v, "ctrl_loss_tmo")) { ctx->options->ctrl_loss_tmo
 = 1; continue; };
parse_option(ctx, v, data_digest)if (!strcmp(v, "data_digest")) { ctx->options->data_digest
 = 1; continue; };
parse_option(ctx, v, dhchap_ctrl_secret)if (!strcmp(v, "dhchap_ctrl_secret")) { ctx->options->dhchap_ctrl_secret
 = 1; continue; };
parse_option(ctx, v, dhchap_secret)if (!strcmp(v, "dhchap_secret")) { ctx->options->dhchap_secret
 = 1; continue; };
parse_option(ctx, v, disable_sqflow)if (!strcmp(v, "disable_sqflow")) { ctx->options->disable_sqflow
 = 1; continue; };
parse_option(ctx, v, discovery)if (!strcmp(v, "discovery")) { ctx->options->discovery =
 1; continue; };
parse_option(ctx, v, duplicate_connect)if (!strcmp(v, "duplicate_connect")) { ctx->options->duplicate_connect
 = 1; continue; };
parse_option(ctx, v, fast_io_fail_tmo)if (!strcmp(v, "fast_io_fail_tmo")) { ctx->options->fast_io_fail_tmo
 = 1; continue; };
parse_option(ctx, v, hdr_digest)if (!strcmp(v, "hdr_digest")) { ctx->options->hdr_digest
 = 1; continue; };
parse_option(ctx, v, host_iface)if (!strcmp(v, "host_iface")) { ctx->options->host_iface
 = 1; continue; };
parse_option(ctx, v, host_traddr)if (!strcmp(v, "host_traddr")) { ctx->options->host_traddr
 = 1; continue; };
parse_option(ctx, v, hostid)if (!strcmp(v, "hostid")) { ctx->options->hostid = 1; continue
; };
parse_option(ctx, v, hostnqn)if (!strcmp(v, "hostnqn")) { ctx->options->hostnqn = 1;
 continue; };
parse_option(ctx, v, instance)if (!strcmp(v, "instance")) { ctx->options->instance = 1
; continue; };
parse_option(ctx, v, keep_alive_tmo)if (!strcmp(v, "keep_alive_tmo")) { ctx->options->keep_alive_tmo
 = 1; continue; };
parse_option(ctx, v, keyring)if (!strcmp(v, "keyring")) { ctx->options->keyring = 1;
 continue; };
parse_option(ctx, v, nqn)if (!strcmp(v, "nqn")) { ctx->options->nqn = 1; continue
; };
parse_option(ctx, v, nr_io_queues)if (!strcmp(v, "nr_io_queues")) { ctx->options->nr_io_queues
 = 1; continue; };
parse_option(ctx, v, nr_poll_queues)if (!strcmp(v, "nr_poll_queues")) { ctx->options->nr_poll_queues
 = 1; continue; };
parse_option(ctx, v, nr_write_queues)if (!strcmp(v, "nr_write_queues")) { ctx->options->nr_write_queues
 = 1; continue; };
parse_option(ctx, v, queue_size)if (!strcmp(v, "queue_size")) { ctx->options->queue_size
 = 1; continue; };
parse_option(ctx, v, reconnect_delay)if (!strcmp(v, "reconnect_delay")) { ctx->options->reconnect_delay
 = 1; continue; };
parse_option(ctx, v, tls)if (!strcmp(v, "tls")) { ctx->options->tls = 1; continue
; };
parse_option(ctx, v, tls_key)if (!strcmp(v, "tls_key")) { ctx->options->tls_key = 1;
 continue; };
parse_option(ctx, v, tos)if (!strcmp(v, "tos")) { ctx->options->tos = 1; continue
; };
parse_option(ctx, v, traddr)if (!strcmp(v, "traddr")) { ctx->options->traddr = 1; continue
; };
parse_option(ctx, v, transport)if (!strcmp(v, "transport")) { ctx->options->transport =
 1; continue; };
parse_option(ctx, v, trsvcid)if (!strcmp(v, "trsvcid")) { ctx->options->trsvcid = 1;
 continue; };
}
libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "\n")__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "\n");

return 0;
1764out_free:
_libnvmf_free_kernel_options(ctx);

return err;
1768}

1770/*
* The kernel lists its options since Linux 5.17. For an older kernel,
* connect uses the default set above. That set is a guess, so the public
* API does not report it.
*/
1775static int kernel_options(struct libnvme_global_ctx *ctx)
1776{
int err;

err = __nvmf_supported_options(ctx);
if (err)
return err;

return ctx->kernel_options ? 0 : -EOPNOTSUPP95;
1784}

1786__shr_public__attribute__((visibility("default"))) int libnvmf_kernel_option_supported(
struct libnvme_global_ctx *ctx, const char *name,
bool_Bool *supported)
1789{
char **opt;
int err;

if (!ctx || !name || !supported)
return -EINVAL22;

err = kernel_options(ctx);
if (err)
return err;

*supported = false0;
for (opt = ctx->kernel_options; *opt; opt++) {
if (!strcmp(*opt, name)) {
	*supported = true1;
	break;
}
}

return 0;
1809}

1811__shr_public__attribute__((visibility("default"))) int libnvmf_kernel_options_for_each(
struct libnvme_global_ctx *ctx,
void (*callback)(const char *name, void *user_data),
void *user_data)
1815{
char **opt;
int err;

if (!ctx || !callback)
return -EINVAL22;

err = kernel_options(ctx);
if (err)
return err;

for (opt = ctx->kernel_options; *opt; opt++)
callback(*opt, user_data);

return 0;
1830}

1832/* Parse the kernel instance number out of a ctrl's name ("nvme3" -> 3). */
1833static int ctrl_instance(struct libnvme_ctrl *c)
1834{
int instance = -1;
const char *name;

if (!c)
return instance;

name = libnvme_ctrl_get_name(c);
if (name)
if (sscanf(name, "nvme%d", &instance) != 1)
	instance = -1;

return instance;
1847}

1849enum registry_action {
REG_NONE,	/* leave the entry alone */
REG_CLAIM,	/* record @owner, overwriting any entry */
REG_CLEAR,	/* delete the entry */
1853};

1855/*
* Decide what a successful connect does to the registry entry. Pure
* function, no I/O, so it is directly unit-testable.
*
* @owner: ctx->owner. NULL means --owner was never given, "" means an
*         explicit disown, and a name means a claim.
* @fresh: whether the kernel just created this controller for us. A
*         controller that already existed may belong to another
*         orchestrator, so an unstated intent must not touch its entry.
*         A fresh one cannot legitimately be owned by anybody, so its
*         entry is cleared to drop what a recycled instance number left
*         behind.
*/
1868static enum registry_action registry_action_on_connect(const char *owner,
				       bool_Bool fresh)
1870{
if (owner && *owner)
return REG_CLAIM;

if (fresh || owner)
return REG_CLEAR;

return REG_NONE;
1878}

1880/*
* Best-effort registry update after a successful connect. Failures are
* logged but never fail the connection.
*/
1884static void registry_update_on_connect(struct libnvme_global_ctx *ctx,
		       int instance, bool_Bool fresh)
1886{
int ret;

switch (registry_action_on_connect(ctx->owner, fresh)) {
case REG_CLAIM:
ret = libnvmf_registry_create_instance(ctx, instance,
				       ctx->owner);
break;
case REG_CLEAR:
ret = libnvmf_registry_delete_instance(ctx, instance);
break;
case REG_NONE:
default:
return;
}

if (ret)
libnvme_msg(ctx, LIBNVME_LOG_WARN,__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "nvme%d: registry update failed: %s\n"
, instance, libnvme_strerror(-ret))
	    "nvme%d: registry update failed: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "nvme%d: registry update failed: %s\n"
, instance, libnvme_strerror(-ret))
	    instance, libnvme_strerror(-ret))__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "nvme%d: registry update failed: %s\n"
, instance, libnvme_strerror(-ret));
1906}

1908static int __nvmf_add_ctrl(struct libnvme_global_ctx *ctx, const char *argstr)
1909{
char buf[0x1000], *options, *p;
enum libnvmf_dev_step step;
ssize_t len;
int instance;

libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "connect ctrl, '%.*s'\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "connect ctrl, '%.*s'\n"
, (int)strcspn(argstr, "\n"), argstr)
 (int)strcspn(argstr, "\n"), argstr)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "connect ctrl, '%.*s'\n"
, (int)strcspn(argstr, "\n"), argstr);
if (ctx->dry_run) {
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "dry-run: connect skipped\n"
)
	    "dry-run: connect skipped\n")__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "dry-run: connect skipped\n"
);
return -ENVME_CONNECT_DRY_RUN;
}
len = nvmf_dev_xfer(ctx, argstr, buf, sizeof(buf), &step);
if (len < 0 && step == LIBNVMF_DEV_OPEN) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to open %s: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror(-len))
	 nvmf_dev, libnvme_strerror(-len))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror(-len));
return -ENVME_CONNECT_OPEN;
}

if (len < 0 && step == LIBNVMF_DEV_WRITE) {
libnvme_msg(ctx, LIBNVME_LOG_INFO, "Failed to write to %s: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Failed to write to %s: %s\n"
, nvmf_dev, libnvme_strerror(-len))
	 nvmf_dev, libnvme_strerror(-len))__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Failed to write to %s: %s\n"
, nvmf_dev, libnvme_strerror(-len));
switch (-len) {
case EALREADY114:
	return -ENVME_CONNECT_ALREADY;
case EINVAL22:
	return -ENVME_CONNECT_INVAL;
case EADDRINUSE98:
	return -ENVME_CONNECT_ADDRINUSE;
case ENODEV19:
	return -ENVME_CONNECT_NODEV;
case EOPNOTSUPP95:
	return -ENVME_CONNECT_OPNOTSUPP;
case ECONNREFUSED111:
	return -ENVME_CONNECT_CONNREFUSED;
case EADDRNOTAVAIL99:
	return -ENVME_CONNECT_ADDRNOTAVAIL;
case ENOKEY126:
	return -ENVME_CONNECT_NOKEY;
default:
	return -ENVME_CONNECT_WRITE;
}
}

if (len < 0) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to read from %s: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror(-len))
	 nvmf_dev, libnvme_strerror(-len))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror(-len));
return -ENVME_CONNECT_READ;
}
libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "connect ctrl, response '%.*s'\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "connect ctrl, response '%.*s'\n"
, (int)strcspn(buf, "\n"), buf)
 (int)strcspn(buf, "\n"), buf)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "connect ctrl, response '%.*s'\n"
, (int)strcspn(buf, "\n"), buf);
options = buf;
while ((p = shr_strsep(&options, ",\n")) != NULL((void*)0)) {
if (!*p)
	continue;
if (sscanf(p, "instance=%d", &instance) == 1) {
	registry_update_on_connect(ctx, instance, true1);
	return instance;
}
}

libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to parse ctrl info for \"%s\"\n", argstr)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to parse ctrl info for \"%s\"\n"
, argstr);
return -ENVME_CONNECT_PARSE;
1973}


1976static void nvme_parse_tls_args(const char *keyring, const char *tls_key,
		const char *tls_key_identity,
		struct libnvme_fabrics_config *cfg, struct libnvme_ctrl *c)
1979{
if (keyring) {
char *endptr;
long id = strtol(keyring, &endptr, 0);

if (endptr != keyring)
	cfg->keyring_id = id;
else
	libnvme_ctrl_set_keyring(c, keyring);
}

if (tls_key_identity)
libnvme_ctrl_set_tls_key_identity(c, tls_key_identity);

if (tls_key) {
char *endptr;
long id = strtol(tls_key, &endptr, 0);

if (endptr != tls_key)
	cfg->tls_key_id = id;
else
	libnvme_ctrl_set_tls_key(c, tls_key);
}
2002}

2004__shr_public__attribute__((visibility("default"))) int libnvmf_create_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_ctrl **cp)
2006{
struct libnvme_ctrl *c;
int ret;

ret = libnvme_create_ctrl(ctx, &fctx->ctrl_params, &c);
if (ret)
return ret;

/* libnvmf_add_ctrl() then passes "discovery" to the kernel. */
if (fctx->discovery_ctrl) {
libnvme_ctrl_set_discovery_ctrl(c, true1);
libnvme_ctrl_set_unique_discovery_ctrl(c,
	strcmp(fctx->ctrl_params.subsysnqn,
	       NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery"));
}

/*
* The credentials live on @fctx next to, not inside, ctrl_params,
* so libnvme_create_ctrl() cannot carry them over. Apply them here
* or a controller created from a context that has them would
* silently connect without.
*/
if (fctx->hostkey) {
libnvme_ctrl_set_kxchap_host_key(c, fctx->hostkey);
if (fctx->ctrlkey)
	libnvme_ctrl_set_kxchap_ctrl_key(c, fctx->ctrlkey);
}

nvme_parse_tls_args(fctx->keyring, fctx->tls_key,
fctx->tls_key_identity, &fctx->ctrl_params.cfg, c);
update_config(c, &fctx->ctrl_params.cfg);

*cp = c;

return 0;
2041}

2043__shr_public__attribute__((visibility("default"))) int libnvmf_add_ctrl(struct libnvme_host *h, struct libnvme_ctrl *c)
2044{
struct libnvme_subsystem *s;
__cleanup_free__attribute__((cleanup(shr_freep))) char *argstr = NULL((void*)0);
int ret;

/* Are duplicate connections allowed on existing controller */
if (libnvme_ctrl_get_name(c) && !c->cfg.duplicate_connect)
return -ENVME_CONNECT_ALREADY;

/* carry over config from an existing ctrl on the same subsystem */
s = libnvme_lookup_subsystem(h, NULL((void*)0), libnvme_ctrl_get_subsysnqn(c));
if (s) {
struct libnvme_ctrl *fc;
struct libnvme_ctrl_params params = {
	.transport = libnvme_ctrl_get_transport(c),
	.traddr = libnvme_ctrl_get_traddr(c),
	.host_traddr = libnvme_ctrl_get_host_traddr(c),
	.host_iface = libnvme_ctrl_get_host_iface(c),
	.trsvcid = libnvme_ctrl_get_trsvcid(c),
};

fc = libnvme_ctrl_find(s, &params, NULL((void*)0));
if (fc) {
	merge_config(c, &fc->cfg);
	ctrl_merge_keys(c, fc);
}

}

libnvme_ctrl_set_discovered(c, true1);
ret = nvmf_sanitize_addrs(h->ctx, c);
if (ret)
return ret;

ret = build_options(h, c, &argstr);
if (ret)
return ret;

ret = __nvmf_add_ctrl(h->ctx, argstr);
if (ret < 0)
return ret;

libnvme_msg(h->ctx, LIBNVME_LOG_INFO, "nvme%d: %s connected\n", ret,__libnvme_msg(h->ctx, LIBNVME_LOG_INFO, ((void*)0), "nvme%d: %s connected\n"
, ret, libnvme_ctrl_get_subsysnqn(c))
 libnvme_ctrl_get_subsysnqn(c))__libnvme_msg(h->ctx, LIBNVME_LOG_INFO, ((void*)0), "nvme%d: %s connected\n"
, ret, libnvme_ctrl_get_subsysnqn(c));
return libnvme_init_ctrl(h, c, ret);
2089}

2091__shr_public__attribute__((visibility("default"))) int libnvmf_connect_ctrl(struct libnvme_ctrl *c)
2092{
__cleanup_free__attribute__((cleanup(shr_freep))) char *argstr = NULL((void*)0);
int ret;

ret = nvmf_sanitize_addrs(c->s->h->ctx, c);
if (ret)
return ret;

ret = build_options(c->s->h, c, &argstr);
if (ret)
return ret;

ret = __nvmf_add_ctrl(c->s->h->ctx, argstr);
if (ret < 0)
return ret;

return 0;
2109}

2111__shr_public__attribute__((visibility("default"))) int libnvmf_disconnect_ctrl(struct libnvme_ctrl *c)
2112{
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);
int ret;

if (ctx && ctx->dry_run) {
libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "dry-run: disconnect of %s skipped\n"
, c->name)
	    "dry-run: disconnect of %s skipped\n", c->name)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "dry-run: disconnect of %s skipped\n"
, c->name);
return 0;
}

if (ctx && ctx->privsep)
ret = __libnvme_privsep_delete_ctrl(ctx->privsep, c->name);
else
ret = libnvme_set_attr(libnvme_ctrl_get_sysfs_dir(c),
		       "delete_controller", "1");
if (ret < 0) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to disconnect, error %d\n"
, c->name, -ret)
	"%s: failed to disconnect, error %d\n", c->name, -ret)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to disconnect, error %d\n"
, c->name, -ret);
return ret;
}
libnvme_msg(ctx, LIBNVME_LOG_INFO, "%s: %s disconnected\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: %s disconnected\n"
, c->name, c->subsysnqn)
c->name, c->subsysnqn)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: %s disconnected\n"
, c->name, c->subsysnqn);
libnvme_deconfigure_ctrl(c);
return 0;
2136}

2138static void nvmf_update_tls_concat(struct nvmf_disc_log_entry *e,
struct libnvme_ctrl *c, struct libnvme_host *h)
2140{
if (!e)
return;

if (e->trtype != NVMF_TRTYPE_TCP ||
   e->tsas.tcp.sectype == NVMF_TCP_SECTYPE_NONE)
return;

if (e->treq & NVMF_TREQ_REQUIRED) {
libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --tls due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	"setting --tls due to treq %s and sectype %s\n",__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --tls due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	libnvmf_treq_str(e->treq),__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --tls due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	libnvmf_sectype_str(e->tsas.tcp.sectype))__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --tls due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype));

c->cfg.tls = true1;
return;
}

if (e->treq & NVMF_TREQ_NOT_REQUIRED) {
libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --concat due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	"setting --concat due to treq %s and sectype %s\n",__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --concat due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	libnvmf_treq_str(e->treq),__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --concat due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype))
	libnvmf_sectype_str(e->tsas.tcp.sectype))__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "setting --concat due to treq %s and sectype %s\n"
, libnvmf_treq_str(e->treq), libnvmf_sectype_str(e->tsas
.tcp.sectype));

c->cfg.concat = true1;
return;
}
2167}

2169/*
* Enumerated-connect gate: consult the exclusion list before connecting a
* controller that was enumerated from a Discovery Log Page, the NBFT table,
* or a configuration file.  Controllers named explicitly by the user
* ("nvme connect", "nvme discover" with an address) are deliberately not
* checked -- a targeted human action overrides the list.
*/
2176static bool_Bool nvmf_excluded(struct libnvme_global_ctx *ctx,
	  const char *transport, const char *traddr,
	  const char *trsvcid, const char *subsysnqn,
	  const char *host_traddr, const char *host_iface,
	  const char *hostnqn, const char *hostid)
2181{
struct libnvmf_tid *tid;
bool_Bool excluded;

libnvmf_tid_from_fields(transport, traddr, trsvcid, subsysnqn,
		host_traddr, host_iface, hostnqn, hostid, &tid);
if (!tid)
return false0; /* fail-safe: never block on allocation failure */

excluded = libnvmf_exclusion_match(ctx, tid);
if (excluded) {
const char *rendered = libnvmf_tid_str(tid);
libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "skipping excluded controller %s\n"
, rendered ? rendered : subsysnqn)
	 "skipping excluded controller %s\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "skipping excluded controller %s\n"
, rendered ? rendered : subsysnqn)
	 rendered ? rendered : subsysnqn)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "skipping excluded controller %s\n"
, rendered ? rendered : subsysnqn);
}
libnvmf_tid_free(tid);

return excluded;
2200}

2202/*
* A discovered controller gets the KX-HMAC-CHAP secrets of the
* configuration section with its NQN. Otherwise it gets the host secret of
* the DC that reported it. It always gets the keyring of that DC. The
* controller secret and the TLS PSK of the DC belong to the discovery
* subsystem, so they are not inherited.
*/
2209static void dc_inherit_keys(struct libnvmf_context *fctx,
struct libnvme_ctrl *dc, struct libnvme_ctrl *c)
2211{
const char *hostkey = NULL((void*)0), *ctrlkey = NULL((void*)0), *keyring;
const struct libnvmf_config_subsys *s;

s = libnvmf_config_find_subsys(fctx->config, fctx->conn,
	c->discovery_ctrl, c->subsysnqn);
if (s) {
hostkey = libnvmf_params_get(s->keys, "kxchap-secret");
ctrlkey = libnvmf_params_get(s->keys, "kxchap-ctrl-secret");
}

/* An empty value in the section resets the secret. */
if (!hostkey)
hostkey = fctx->hostkey;
if (!hostkey)
libnvme_ctrl_get_kxchap_host_key(dc, &hostkey, NULL((void*)0));
if (hostkey && *hostkey)
libnvme_ctrl_set_kxchap_host_key(c, hostkey);
if (ctrlkey && *ctrlkey)
libnvme_ctrl_set_kxchap_ctrl_key(c, ctrlkey);

if (!libnvme_ctrl_get_keyring(dc, &keyring, NULL((void*)0)))
libnvme_ctrl_set_keyring(c, keyring);
2234}

2236static int nvmf_connect_disc_entry(struct libnvmf_context *fctx,
struct libnvme_host *h, struct libnvme_ctrl *dc,
struct nvmf_disc_log_entry *e,
struct libnvme_ctrl_params *params,
struct libnvme_ctrl **cp)
2241{
struct libnvme_ctrl *c;
int ret;

switch (e->trtype) {
case NVMF_TRTYPE_RDMA:
case NVMF_TRTYPE_TCP:
switch (e->adrfam) {
case NVMF_ADDR_FAMILY_IP4:
case NVMF_ADDR_FAMILY_IP6:
	params->traddr = e->traddr;
	params->trsvcid = e->trsvcid;
	break;
default:
	libnvme_msg(h->ctx, LIBNVME_LOG_ERR,__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam)
		 "skipping unsupported adrfam %d\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam)
		 e->adrfam)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam);
	return -EINVAL22;
}
break;
      case NVMF_TRTYPE_FC:
switch (e->adrfam) {
case NVMF_ADDR_FAMILY_FC:
	params->traddr = e->traddr;
	break;
default:
	libnvme_msg(h->ctx, LIBNVME_LOG_ERR,__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam)
		 "skipping unsupported adrfam %d\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam)
		 e->adrfam)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported adrfam %d\n"
, e->adrfam);
	return -EINVAL22;
}
break;
case NVMF_TRTYPE_LOOP:
params->traddr = strlen(e->traddr) ? e->traddr : NULL((void*)0);
break;
default:
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "skipping unsupported transport %d\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported transport %d\n"
, e->trtype)
	 e->trtype)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "skipping unsupported transport %d\n"
, e->trtype);
return -EINVAL22;
}

params->transport = libnvmf_trtype_str(e->trtype);
params->subsysnqn = e->subnqn;

libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, params->transport, params->traddr, params->trsvcid
)
 "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n",__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, params->transport, params->traddr, params->trsvcid
)
 params->transport, params->traddr,__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, params->transport, params->traddr, params->trsvcid
)
 params->trsvcid)__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, params->transport, params->traddr, params->trsvcid
);

if (nvmf_excluded(h->ctx, params->transport,
	  params->traddr, params->trsvcid,
	  params->subsysnqn,
	  params->host_traddr,
	  params->host_iface,
	  libnvme_host_get_hostnqn(h),
	  libnvme_host_get_hostid(h)))
return -EPERM1;

ret = libnvme_create_ctrl(h->ctx, params, &c);
if (ret) {
libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, "skipping discovery entry, "__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "skipping discovery entry, "
 "failed to allocate %s controller with traddr %s\n", params->
transport, params->traddr)
	 "failed to allocate %s controller with traddr %s\n",__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "skipping discovery entry, "
 "failed to allocate %s controller with traddr %s\n", params->
transport, params->traddr)
	 params->transport, params->traddr)__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "skipping discovery entry, "
 "failed to allocate %s controller with traddr %s\n", params->
transport, params->traddr);
return ret;
}

/*
* Self entries (SUBTYPE 03h) are filtered out by the caller before
* this function is ever reached -- they never need a connection of
* their own.
*/
switch (e->subtype) {
case NVME_NQN_DISC:
libnvme_ctrl_set_discovery_ctrl(c, true1);
libnvme_ctrl_set_unique_discovery_ctrl(c,
		strcmp(e->subnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery"));
break;
default:
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "unsupported subtype %d\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "unsupported subtype %d\n"
, e->subtype)
	 e->subtype)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "unsupported subtype %d\n"
, e->subtype);
fallthrough__attribute__((fallthrough));
case NVME_NQN_NVME:
libnvme_ctrl_set_discovery_ctrl(c, false0);
libnvme_ctrl_set_unique_discovery_ctrl(c, false0);
break;
}

if (e->treq & NVMF_TREQ_DISABLE_SQFLOW &&
   nvmf_check_option(h->ctx, disable_sqflow)({ !__nvmf_supported_options(h->ctx) && h->ctx->
options->disable_sqflow; }))
c->cfg.disable_sqflow = true1;

/* update tls or concat */
nvmf_update_tls_concat(e, c, h);

dc_inherit_keys(fctx, dc, c);

ret = libnvmf_add_ctrl(h, c);
if (!ret) {
*cp = c;
return 0;
}

if (ret == EINVAL22 && c->cfg.disable_sqflow) {
/* disable_sqflow is unrecognized option on older kernels */
libnvme_msg(h->ctx, LIBNVME_LOG_INFO, "failed to connect controller, "__libnvme_msg(h->ctx, LIBNVME_LOG_INFO, ((void*)0), "failed to connect controller, "
 "retry with disabling SQ flow control\n")
	 "retry with disabling SQ flow control\n")__libnvme_msg(h->ctx, LIBNVME_LOG_INFO, ((void*)0), "failed to connect controller, "
 "retry with disabling SQ flow control\n");
c->cfg.disable_sqflow = false0;
ret = libnvmf_add_ctrl(h, c);
if (!ret) {
	*cp = c;
	return 0;
}
}
libnvme_free_ctrl(c);
return -ENOENT2;
2356}

2358/*
* Most of nvmf_discovery_log is reserved, so only fetch the initial bytes.
* 8 bytes for GENCTR, 8 for NUMREC, and 2 for RECFMT.
* Since only multiples of 4 bytes are allowed, round 18 up to 20.
*/
2363#define DISCOVERY_HEADER_LEN20 20

2365static int nvme_discovery_log(struct libnvme_ctrl *ctrl,
	      const struct libnvmf_discovery_args *args,
	      struct nvmf_discovery_log **logp)
2368{
struct libnvme_global_ctx *ctx = ctrl->ctx;
struct nvmf_discovery_log *log;
int retries = 0;
int err;
const char *name = libnvme_ctrl_get_name(ctrl);
uint64_t genctr, numrec;
struct libnvme_transport_handle *hdl;
struct libnvme_passthru_cmd cmd;

hdl = libnvme_ctrl_get_transport_handle(ctrl);
if (!hdl)
return -ENODEV19;

log = libnvme_alloc(sizeof(*log));
if (!log) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not allocate memory for discovery log header\n"
)
	 "could not allocate memory for discovery log header\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not allocate memory for discovery log header\n"
);
return -ENOMEM12;
}

libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "%s: get header (try %d/%d)\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get header (try %d/%d)\n"
, name, retries, args->max_retries)
 name, retries, args->max_retries)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get header (try %d/%d)\n"
, name, retries, args->max_retries);
nvme_init_get_log_discovery(&cmd, 0, log, DISCOVERY_HEADER_LEN20);
err = libnvme_get_log(hdl, &cmd, false0, DISCOVERY_HEADER_LEN20);
if (err) {
libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
	 "%s: discover try %d/%d failed, errno %d status 0x%x\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
	 name, retries, args->max_retries, errno, err)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err);
goto out_free_log;
}

do {
size_t entries_size;

numrec = le64_to_cpu(log->numrec);
genctr = le64_to_cpu(log->genctr);

if (numrec == 0)
	break;

if (numrec > (SIZE_MAX(18446744073709551615UL) - sizeof(*log)) / sizeof(*log->entries)) {
	libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: don't trust record count %"
 "l" "u" "\n", name, numrec)
		 "%s: don't trust record count %" PRIu64 "\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: don't trust record count %"
 "l" "u" "\n", name, numrec)
		 name, numrec)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: don't trust record count %"
 "l" "u" "\n", name, numrec);
	err = -EINVAL22;
	goto out_free_log;
}

libnvme_free(log);
entries_size = sizeof(*log->entries) * numrec;
log = libnvme_alloc(sizeof(*log) + entries_size);
if (!log) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not alloc memory for discovery log page\n"
)
		 "could not alloc memory for discovery log page\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not alloc memory for discovery log page\n"
);
	return -ENOMEM12;
}

libnvme_msg(ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get %"
 "l" "u" " records (genctr %" "l" "u" ")\n", name, numrec, genctr
)
	 "%s: get %" PRIu64 " records (genctr %" PRIu64 ")\n",__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get %"
 "l" "u" " records (genctr %" "l" "u" ")\n", name, numrec, genctr
)
	 name, numrec, genctr)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get %"
 "l" "u" " records (genctr %" "l" "u" ")\n", name, numrec, genctr
);

nvme_init_get_log_discovery(&cmd, sizeof(*log), log->entries, entries_size);
cmd.cdw10 |= NVME_FIELD_ENCODE(args->lsp,(((__u32)(args->lsp) & (NVME_LOG_CDW10_LSP_MASK)) <<
 (NVME_LOG_CDW10_LSP_SHIFT))
			       NVME_LOG_CDW10_LSP_SHIFT,(((__u32)(args->lsp) & (NVME_LOG_CDW10_LSP_MASK)) <<
 (NVME_LOG_CDW10_LSP_SHIFT))
			       NVME_LOG_CDW10_LSP_MASK)(((__u32)(args->lsp) & (NVME_LOG_CDW10_LSP_MASK)) <<
 (NVME_LOG_CDW10_LSP_SHIFT));
err = libnvme_get_log(hdl, &cmd, false0, NVME_LOG_PAGE_PDU_SIZE4096);
if (err) {
	libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
		 "%s: discover try %d/%d failed, errno %d status 0x%x\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
		 name, retries, args->max_retries, errno, err)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err);
	goto out_free_log;
}

/*
 * If the log page was read with multiple Get Log Page commands,
 * genctr must be checked afterwards to ensure atomicity
 */
libnvme_msg(ctx, LIBNVME_LOG_DEBUG, "%s: get header again\n", name)__libnvme_msg(ctx, LIBNVME_LOG_DEBUG, ((void*)0), "%s: get header again\n"
, name);

nvme_init_get_log_discovery(&cmd, 0, log, DISCOVERY_HEADER_LEN20);
err = libnvme_get_log(hdl, &cmd, false0, DISCOVERY_HEADER_LEN20);
if (err) {
	libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
		 "%s: discover try %d/%d failed, errno %d status 0x%x\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err)
		 name, retries, args->max_retries, errno, err)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover try %d/%d failed, errno %d status 0x%x\n"
, name, retries, args->max_retries, (*__errno_location ())
, err);
	goto out_free_log;
}
} while (genctr != le64_to_cpu(log->genctr) &&
 ++retries < args->max_retries);

if (genctr != le64_to_cpu(log->genctr)) {
libnvme_msg(ctx, LIBNVME_LOG_INFO, "%s: discover genctr mismatch\n", name)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: discover genctr mismatch\n"
, name);
err = -EAGAIN11;
} else if (numrec != le64_to_cpu(log->numrec)) {
libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: numrec changed unexpectedly "
 "from %" "l" "u" " to %" "l" "u" "\n", name, numrec, le64_to_cpu
(log->numrec))
	 "%s: numrec changed unexpectedly "__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: numrec changed unexpectedly "
 "from %" "l" "u" " to %" "l" "u" "\n", name, numrec, le64_to_cpu
(log->numrec))
	 "from %" PRIu64 " to %" PRIu64 "\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: numrec changed unexpectedly "
 "from %" "l" "u" " to %" "l" "u" "\n", name, numrec, le64_to_cpu
(log->numrec))
	 name, numrec, le64_to_cpu(log->numrec))__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: numrec changed unexpectedly "
 "from %" "l" "u" " to %" "l" "u" "\n", name, numrec, le64_to_cpu
(log->numrec));
err = -EBADSLT57;
} else {
*logp = log;
return 0;
}

2473out_free_log:
libnvme_free(log);
return err;
2476}

2478static void sanitize_discovery_log_entry(struct libnvme_global_ctx *ctx,
struct nvmf_disc_log_entry *e)
2480{
/*
* Force a NUL terminator into the last byte. Every buffer here is
* far larger than any value a compliant peer can send, so this only
* ever truncates a non-compliant one. The purpose is to keep the
* field from being read as an unbounded char *. This must run
* before shr_rtrim() below, which relies on the field already being
* terminated.
*/
e->trsvcid[sizeof(e->trsvcid) - 1] = '\0';
e->subnqn[sizeof(e->subnqn) - 1] = '\0';
e->traddr[sizeof(e->traddr) - 1] = '\0';

shr_rtrim(e->trsvcid);
shr_rtrim(e->traddr);
shr_rtrim(e->subnqn);

/*
* Report traddr always in 'nn-0x:pn-0x' format, but some discovery logs
* provide 'nn-0x,pn-0x'.
*/
if (e->trtype == NVMF_TRTYPE_FC) {
char *comma = strchr(e->traddr, ',')_Generic (0 ? (e->traddr) : (void *) 1, const void *: (const
 char *) (strchr (e->traddr, ',')), default: strchr (e->
traddr, ','));

if (comma) {
	libnvme_msg(ctx, LIBNVME_LOG_WARN,__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "invalid traddr separator ',' instead ':', fixing it"
)
		"invalid traddr separator ',' instead ':', fixing it")__libnvme_msg(ctx, LIBNVME_LOG_WARN, ((void*)0), "invalid traddr separator ',' instead ':', fixing it"
);
	*comma = ':';
}
}
2510}

2512__shr_public__attribute__((visibility("default"))) int libnvmf_get_discovery_log(struct libnvme_ctrl *ctrl,
		    const struct libnvmf_discovery_args *args,
		    struct nvmf_discovery_log **logp)
2515{
static const struct libnvmf_discovery_args defaults = {
.max_retries = 6,
.lsp         = NVMF_LOG_DISC_LSP_NONE,
};
struct nvmf_discovery_log *log;
int err;

if (!ctrl || !logp)
return -EINVAL22;

if (!args)
args = &defaults;

err = nvme_discovery_log(ctrl, args, &log);
if (err)
return err;

for (int i = 0; i < le64_to_cpu(log->numrec); i++)
sanitize_discovery_log_entry(ctrl->ctx, &log->entries[i]);

*logp = log;
return 0;
2538}


2541/**
* nvmf_get_tel() - Calculate the amount of memory needed for a DIE.
* @hostsymname:	Symbolic name (may be NULL)
*
* Each Discovery Information Entry (DIE) must contain at a minimum an
* Extended Attribute for the HostID. The Entry may optionally contain an
* Extended Attribute for the Symbolic Name.
*
* Return: Total Entry Length
*/
2551static __u32 nvmf_get_tel(const char *hostsymname)
2552{
__u32 tel = sizeof(struct nvmf_ext_die);
__u16 len;

/* Host ID is mandatory */
tel += libnvmf_exat_size(NVME_UUID_LEN16);

/* Symbolic name is optional */
len = hostsymname ? strlen(hostsymname) : 0;
if (len)
tel += libnvmf_exat_size(len);

return tel;
2565}

2567/**
* nvmf_fill_die() - Fill a Discovery Information Entry.
* @die:	Pointer to Discovery Information Entry to be filled
* @h:		Pointer to the host data structure
* @tel:	Length of the DIE
* @trtype:	Transport type
* @adrfam:	Address family
* @reg_addr:	Address to register. Setting this to an empty string tells
*		the DC to infer address from the source address of the socket.
* @tsas:	Transport Specific Address Subtype for the address being
*		registered.
*/
2579static void nvmf_fill_die(struct nvmf_ext_die *die, struct libnvme_host *h,
	  __u32 tel, __u8 trtype, __u8 adrfam,
	  const char *reg_addr, union nvmf_tsas *tsas)
2582{
__u16 numexat = 0;
size_t symname_len;
struct nvmf_ext_attr *exat;

die->tel = cpu_to_le32(tel);
die->trtype = trtype;
die->adrfam = adrfam;

memcpy(die->nqn, h->hostnqn, MIN(sizeof(die->nqn), strlen(h->hostnqn))(((sizeof(die->nqn))<(strlen(h->hostnqn)))?(sizeof(die
->nqn)):(strlen(h->hostnqn))));
memcpy(die->traddr, reg_addr, MIN(sizeof(die->traddr), strlen(reg_addr))(((sizeof(die->traddr))<(strlen(reg_addr)))?(sizeof(die
->traddr)):(strlen(reg_addr))));

if (tsas)
memcpy(&die->tsas, tsas, sizeof(die->tsas));

/* Extended Attribute for the HostID (mandatory) */
numexat++;
exat = die->exat;
exat->exattype = cpu_to_le16(NVMF_EXATTYPE_HOSTID);
exat->exatlen  = cpu_to_le16(libnvmf_exat_len(NVME_UUID_LEN16));
libnvme_uuid_from_string(h->hostid, exat->exatval);

/* Extended Attribute for the Symbolic Name (optional) */
symname_len = h->hostsymname ? strlen(h->hostsymname) : 0;
if (symname_len) {
__u16 exatlen = libnvmf_exat_len(symname_len);

numexat++;
exat = libnvmf_exat_ptr_next(exat);
exat->exattype = cpu_to_le16(NVMF_EXATTYPE_SYMNAME);
exat->exatlen  = cpu_to_le16(exatlen);
memcpy(exat->exatval, h->hostsymname, symname_len);
/* Per Base specs, ASCII strings must be padded with spaces */
memset(&exat->exatval[symname_len], ' ', exatlen - symname_len);
}

die->numexat = cpu_to_le16(numexat);
2619}

2621/**
* nvmf_dim() - Explicit reg, dereg, reg-update issuing DIM
* @c:		Host NVMe controller instance maintaining the admin queue used to
*		submit the DIM command to the DC.
* @tas:	Task field of the Command Dword 10 (cdw10). Indicates whether to
*		perform a Registration, Deregistration, or Registration-update.
* @trtype:	Transport type (&enum nvmf_trtype - must be NVMF_TRTYPE_TCP)
* @adrfam:	Address family (&enum nvmf_addr_family)
* @reg_addr:	Address to register. Setting this to an empty string tells
*		the DC to infer address from the source address of the socket.
* @tsas:	Transport Specific Address Subtype for the address being
*		registered.
* @result:	Location where to save the command-specific result returned by
*		the discovery controller.
*
* Perform explicit registration, deregistration, or
* registration-update (specified by @tas) by sending a Discovery
* Information Management (DIM) command to the Discovery Controller
* (DC).
*
* Return: 0 on success; on failure -1 is returned and errno is set
*/
2643static int nvmf_dim(struct libnvme_ctrl *c, enum nvmf_dim_tas tas, __u8 trtype,
    __u8 adrfam, const char *reg_addr, union nvmf_tsas *tsas,
    __u32 *result)
2646{
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) struct nvmf_dim_data *dim = NULL((void*)0);
struct libnvme_transport_handle *hdl = libnvme_ctrl_get_transport_handle(c);
struct libnvme_passthru_cmd cmd;
struct nvmf_ext_die  *die;
__u32 tdl;
__u32 tel;
int ret;

if (!c->s) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. subsystem undefined.\n"
, c->name)
	 "%s: failed to perform DIM. subsystem undefined.\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. subsystem undefined.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. subsystem undefined.\n"
, c->name);
return -EINVAL22;
}

if (!c->s->h) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. host undefined.\n"
, c->name)
	 "%s: failed to perform DIM. host undefined.\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. host undefined.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. host undefined.\n"
, c->name);
return -EINVAL22;
}

if (!c->s->h->hostid) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostid undefined.\n"
, c->name)
	 "%s: failed to perform DIM. hostid undefined.\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostid undefined.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostid undefined.\n"
, c->name);
return -EINVAL22;
}

if (!c->s->h->hostnqn) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostnqn undefined.\n"
, c->name)
	 "%s: failed to perform DIM. hostnqn undefined.\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostnqn undefined.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to perform DIM. hostnqn undefined.\n"
, c->name);
return -EINVAL22;
}

if (strcmp(c->transport, "tcp")) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: DIM only supported for TCP connections.\n"
, c->name)
	 "%s: DIM only supported for TCP connections.\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: DIM only supported for TCP connections.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: DIM only supported for TCP connections.\n"
, c->name);
return -EINVAL22;
}

/* Register one Discovery Information Entry (DIE) of size TEL */
tel = nvmf_get_tel(c->s->h->hostsymname);
tdl = sizeof(struct nvmf_dim_data) + tel;

dim = (struct nvmf_dim_data *)calloc(1, tdl);
if (!dim) {
return -ENOMEM12;
}

dim->tdl    = cpu_to_le32(tdl);
dim->nument = cpu_to_le64(1);    /* only one DIE to register */
dim->entfmt = cpu_to_le16(NVMF_DIM_ENTFMT_EXTENDED);
dim->etype  = cpu_to_le16(NVMF_DIM_ETYPE_HOST);
dim->ektype = cpu_to_le16(0x5F); /* must be 0x5F per specs */

memcpy(dim->eid, c->s->h->hostnqn,
      MIN(sizeof(dim->eid), strlen(c->s->h->hostnqn))(((sizeof(dim->eid))<(strlen(c->s->h->hostnqn)
))?(sizeof(dim->eid)):(strlen(c->s->h->hostnqn))));

ret = libnvmf_get_entity_name(dim->ename, sizeof(dim->ename));
if (ret < 0)
libnvme_msg(ctx, LIBNVME_LOG_INFO, "%s: Failed to retrieve ENAME. %s.\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: Failed to retrieve ENAME. %s.\n"
, c->name, libnvme_strerror(-ret))
	 c->name, libnvme_strerror(-ret))__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: Failed to retrieve ENAME. %s.\n"
, c->name, libnvme_strerror(-ret));
else if (ret == 0)
libnvme_msg(ctx, LIBNVME_LOG_INFO, "%s: Failed to retrieve ENAME.\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: Failed to retrieve ENAME.\n"
, c->name)
	 c->name)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: Failed to retrieve ENAME.\n"
, c->name);

ret = libnvmf_get_entity_version(dim->ever, sizeof(dim->ever));
if (ret <= 0)
libnvme_msg(ctx, LIBNVME_LOG_INFO, "%s: Failed to retrieve EVER.\n", c->name)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "%s: Failed to retrieve EVER.\n"
, c->name);

die = &dim->die->extended;
nvmf_fill_die(die, c->s->h, tel, trtype, adrfam, reg_addr, tsas);

nvme_init_dim_send(&cmd, tas, dim, tdl);
return libnvme_exec_admin_passthru(hdl, &cmd);
2726}

2728/**
* nvme_get_adrfam() - Get address family for the address we're registering
* with the DC.
*
* We retrieve this info from the socket itself. If we can't get the source
* address from the socket, then we'll infer the address family from the
* address of the DC since the DC address has the same address family.
*
* @c: Host NVMe controller instance maintaining the admin queue used to
*   submit the DIM command to the DC.
*
* Return: The address family of the source address associated with the
*   socket connected to the DC.
*/
2742static __u8 nvme_get_adrfam(struct libnvme_ctrl *c)
2743{
struct sockaddr_storage addr;
__u8 adrfam = NVMF_ADDR_FAMILY_IP4;
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);

if (!inet_pton_with_scope(ctx, AF_UNSPEC0, c->traddr, c->trsvcid, &addr)) {
if (addr.ss_family == AF_INET610)
	adrfam = NVMF_ADDR_FAMILY_IP6;
}

return adrfam;
2754}

2756/* These string definitions must match with the kernel */
2757static const char *cntrltype_str[] = {
[NVME_CTRL_CNTRLTYPE_IO] = "io",
[NVME_CTRL_CNTRLTYPE_DISCOVERY] = "discovery",
[NVME_CTRL_CNTRLTYPE_ADMIN] = "admin",
2761};

2763static const char *dctype_str[] = {
[NVME_CTRL_DCTYPE_NOT_REPORTED] = "none",
[NVME_CTRL_DCTYPE_DDC] = "ddc",
[NVME_CTRL_DCTYPE_CDC] = "cdc",
2767};

2769/**
* nvme_fetch_cntrltype_dctype_from_id - Get cntrltype and dctype from identify command
* @c:	Controller instance
*
* On legacy kernels the cntrltype and dctype are not exposed through the
* sysfs. We must get them directly from the controller by performing an
* identify command.
*/
2777static int nvme_fetch_cntrltype_dctype_from_id(struct libnvme_ctrl *c)
2778{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ctrl *id = NULL((void*)0);
const char *val;
int ret;

id = libnvme_alloc(sizeof(*id));
if (!id)
return -ENOMEM12;

ret = libnvme_ctrl_identify(c, id);
if (ret)
return ret;

if (libnvme_ctrl_get_cntrltype(c, &val, NULL((void*)0))) {
if (id->cntrltype > NVME_CTRL_CNTRLTYPE_ADMIN || !cntrltype_str[id->cntrltype])
	libnvme_ctrl_set_cntrltype(c, "reserved");
else
	libnvme_ctrl_set_cntrltype(c,
			cntrltype_str[id->cntrltype]);
}

if (libnvme_ctrl_get_dctype(c, &val, NULL((void*)0))) {
if (id->dctype > NVME_CTRL_DCTYPE_CDC || !dctype_str[id->dctype])
	libnvme_ctrl_set_dctype(c, "reserved");
else
	libnvme_ctrl_set_dctype(c, dctype_str[id->dctype]);
}
return 0;
2806}

2808__shr_public__attribute__((visibility("default"))) bool_Bool libnvmf_is_registration_supported(struct libnvme_ctrl *c)
2809{
const char *cntrltype, *dctype;

if (libnvme_ctrl_get_cntrltype(c, &cntrltype, NULL((void*)0)) ||
   libnvme_ctrl_get_dctype(c, &dctype, NULL((void*)0)))
if (nvme_fetch_cntrltype_dctype_from_id(c))
	return false0;

libnvme_ctrl_get_dctype(c, &dctype, NULL((void*)0));
return shr_streq0(dctype, "ddc") || shr_streq0(dctype, "cdc");
2819}

2821__shr_public__attribute__((visibility("default"))) int libnvmf_register_ctrl(
struct libnvme_ctrl *c, enum nvmf_dim_tas tas, __u32 *result)
2823{
if (!libnvmf_is_registration_supported(c))
return -ENOTSUP95;

/* We're registering our source address with the DC. To do
* that, we can simply send an empty string. This tells the DC
* to retrieve the source address from the socket and use that
* as the registration address.
*/
return nvmf_dim(c, tas, NVMF_TRTYPE_TCP, nvme_get_adrfam(c), "", NULL((void*)0), result);
2833}

2835#define IS_XDIGIT(c)((c >= '0' && c <= '9') || (c >= 'A' &&
 c <= 'F') || (c >= 'a' && c <= 'f')) ((c >= '0' && c <= '9') || \
      (c >= 'A' && c <= 'F') || \
      (c >= 'a' && c <= 'f'))
2838#define XDIGIT_VAL(c)((c >= '0' && c <= '9') ? c - '0' : ( (c >= 'A'
 && c <= 'F') ? c - 'A' + 10 : c - 'a' + 10)) ((c >= '0' && c <= '9') ? c - '0' : ( \
       (c >= 'A' && c <= 'F') ? c - 'A' + 10 : c - 'a' + 10))

2841/* returns newly allocated string */
2842static char *unescape_uri(const char *str, int len)
2843{
char *dst;
int l;
int i, j;

l = len > 0 ? len : strlen(str);
dst = malloc(l + 1);
if (!dst)
return NULL((void*)0);

for (i = 0, j = 0; i < l; i++, j++) {
if (str[i] == '%' && i + 2 < l &&
    IS_XDIGIT(str[i + 1])((str[i + 1] >= '0' && str[i + 1] <= '9') || (str
[i + 1] >= 'A' && str[i + 1] <= 'F') || (str[i +
 1] >= 'a' && str[i + 1] <= 'f')) && IS_XDIGIT(str[i + 2])((str[i + 2] >= '0' && str[i + 2] <= '9') || (str
[i + 2] >= 'A' && str[i + 2] <= 'F') || (str[i +
 2] >= 'a' && str[i + 2] <= 'f'))) {
	dst[j] = (XDIGIT_VAL(str[i + 1])((str[i + 1] >= '0' && str[i + 1] <= '9') ? str
[i + 1] - '0' : ( (str[i + 1] >= 'A' && str[i + 1]
 <= 'F') ? str[i + 1] - 'A' + 10 : str[i + 1] - 'a' + 10)) << 4) +
		  XDIGIT_VAL(str[i + 2])((str[i + 2] >= '0' && str[i + 2] <= '9') ? str
[i + 2] - '0' : ( (str[i + 2] >= 'A' && str[i + 2]
 <= 'F') ? str[i + 2] - 'A' + 10 : str[i + 2] - 'a' + 10));
	i += 2;
} else
	dst[j] = str[i];
}
dst[j] = '\0';
return dst;
2864}

2866__shr_public__attribute__((visibility("default"))) int libnvmf_uri_parse(
const char *str, struct libnvmf_uri **urip)
2868{
__cleanup_uri__attribute__((cleanup(free_uri))) struct libnvmf_uri *uri = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *scheme = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *authority = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *path = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *h = NULL((void*)0);
const char *host;
int i;

/* As defined in Boot Specification rev. 1.0:
*
* section 1.5.7: NVMe-oF URI Format
*  nvme+tcp://192.168.1.1:4420/
*  nvme+tcp://[FE80::1010]:4420/
*
* section 3.1.2.5.3: DHCP Root-Path - a hierarchical NVMe-oF URI Format
*  NVME<+PROTOCOL>://<SERVERNAME/IP>[:TRANSPORT PORT]/<SUBSYS NQN>/<NID>
* or
*  NVME<+PROTOCOL>://<DISCOVERY CONTROLLER ADDRESS>[:DISCOVERY-
*  -CONTROLLER PORT]/NQN.2014-08.ORG.NVMEXPRESS.DISCOVERY/<NID>
*/

uri = calloc(1, sizeof(struct libnvmf_uri));
if (!uri)
return -ENOMEM12;

if (sscanf(str, "%m[^:/]://%m[^/?#]%ms",
   &scheme, &authority, &path) < 2)
return -EINVAL22;

if (sscanf(scheme, "%m[^+]+%ms",
   &uri->scheme, &uri->protocol) < 1)
return -EINVAL22;

/*
* The scheme and transport protocol are a fixed, small vocabulary
* ("nvme", "tcp"/"rdma"/"fc"), unlike the host/subsystem NQNs that can
* also appear in this URI -- so, unlike those, normalizing case here
* costs nothing. Boot Specification section 3.1.2.5.3 spells the DHCP
* root-path form in upper case ("NVME<+PROTOCOL>://..."), and both that
* and mixed case are otherwise rejected by validate_uri()'s
* case-sensitive comparisons below.
*/
shr_strtolower(uri->scheme);
if (uri->protocol)
shr_strtolower(uri->protocol);

/* split userinfo */
host = strrchr(authority, '@')_Generic (0 ? (authority) : (void *) 1, const void *: (const char
 *) (strrchr (authority, '@')), default: strrchr (authority, '@'
));
if (host) {
if (host > authority) {
	uri->userinfo = unescape_uri(authority,
				     host - authority);
	if (!uri->userinfo)
		return -ENOMEM12;
}
host++;
} else
host = authority;

/* try matching IPv6 address first */
if (sscanf(host, "[%m[^]]]:%d",
   &uri->host, &uri->port) < 1) {
/* treat it as IPv4/hostname */
if (sscanf(host, "%m[^:]:%d",
	   &h, &uri->port) < 1)
	return -EINVAL22;
uri->host = unescape_uri(h, 0);
if (!uri->host)
	return -ENOMEM12;
}

/* split path into elements */
if (path) {
char *e, *elem;

/* separate the fragment */
e = strrchr(path, '#')_Generic (0 ? (path) : (void *) 1, const void *: (const char *
) (strrchr (path, '#')), default: strrchr (path, '#'));
if (e) {
	uri->fragment = unescape_uri(e + 1, 0);
	if (!uri->fragment)
		return -ENOMEM12;
	*e = '\0';
}
/* separate the query string */
e = strrchr(path, '?')_Generic (0 ? (path) : (void *) 1, const void *: (const char *
) (strrchr (path, '?')), default: strrchr (path, '?'));
if (e) {
	uri->query = unescape_uri(e + 1, 0);
	if (!uri->query)
		return -ENOMEM12;
	*e = '\0';
}

/* count elements first */
for (i = 0, e = path; *e; e++)
	if (*e == '/' && *(e + 1) != '/')
		i++;
uri->path_segments = calloc(i + 2, sizeof(char *));
if (!uri->path_segments)
	return -ENOMEM12;

/*
 * libnvmf_uri_free() walks path_segments until the first NULL
 * entry, so a failed unescape_uri() partway through must abort
 * the whole parse instead of leaving a NULL hole followed by
 * more entries that would then never be freed.
 */
i = 0;
elem = strtok_r(path, "/", &e);
if (elem) {
	uri->path_segments[i] = unescape_uri(elem, 0);
	if (!uri->path_segments[i])
		return -ENOMEM12;
	i++;
}
while (elem && strlen(elem)) {
	elem = strtok_r(NULL((void*)0), "/", &e);
	if (elem) {
		uri->path_segments[i] = unescape_uri(elem, 0);
		if (!uri->path_segments[i])
			return -ENOMEM12;
		i++;
	}
}
}

*urip = uri;
uri = NULL((void*)0);

return 0;
2998}

3000__shr_public__attribute__((visibility("default"))) void libnvmf_uri_free(struct libnvmf_uri *uri)
3001{
char **s;

if (!uri)
return;
free(uri->scheme);
free(uri->protocol);
free(uri->userinfo);
free(uri->host);
for (s = uri->path_segments; s && *s; s++)
free(*s);
free(uri->path_segments);
free(uri->query);
free(uri->fragment);
free(uri);
3016}

3018static struct libnvme_ctrl *lookup_ctrl(struct libnvme_host *h,
const struct libnvme_ctrl_params *params)
3020{
struct libnvme_subsystem *s;
struct libnvme_ctrl *c;

libnvme_for_each_subsystem(h, s)for (s = libnvme_first_subsystem(h); s != ((void*)0); s = libnvme_next_subsystem
(h, s)) {
c = libnvme_ctrl_find(s, params, NULL((void*)0));
if (c)
	return c;
}

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

3033/*
* Same as lookup_ctrl(), but only returns a controller that's actually
* connected. lookup_ctrl() can also match a scanned-but-unconnected
* draft, which has no kernel-assigned name yet.
*/
3038static struct libnvme_ctrl *lookup_live_ctrl(struct libnvme_host *h,
const struct libnvme_ctrl_params *params)
3040{
struct libnvme_ctrl *c = lookup_ctrl(h, params);

return (c && libnvme_ctrl_get_name(c)) ? c : NULL((void*)0);
3044}

3046__shr_public__attribute__((visibility("default"))) int libnvmf_get_owner_from_tid(struct libnvme_global_ctx *ctx,
const struct libnvmf_tid *tid, char **owner)
3048{
struct libnvme_ctrl_params params = { 0 };
struct libnvme_subsystem *s;
struct libnvme_host *h;
struct libnvme_ctrl *c = NULL((void*)0);
int ret;

if (!ctx || !tid || !owner)
return -EINVAL22;

*owner = NULL((void*)0);

h = libnvme_lookup_host(ctx, libnvmf_tid_get_hostnqn(tid),
		 libnvmf_tid_get_hostid(tid));
if (!h)
return 0;

params.transport = libnvmf_tid_get_transport(tid);
params.traddr = libnvmf_tid_get_traddr(tid);
params.trsvcid = libnvmf_tid_get_trsvcid(tid);
params.subsysnqn = libnvmf_tid_get_subsysnqn(tid);
params.host_traddr = libnvmf_tid_get_host_traddr(tid);
params.host_iface = libnvmf_tid_get_host_iface(tid);

libnvme_for_each_subsystem(h, s)for (s = libnvme_first_subsystem(h); s != ((void*)0); s = libnvme_next_subsystem
(h, s)) {
c = libnvme_ctrl_find(s, &params, NULL((void*)0));
if (c)
	break;
}
if (!c)
return 0;

ret = libnvmf_registry_retrieve(ctx, libnvme_ctrl_get_name(c),
			"owner", owner);
return (ret == -ENOENT2) ? 0 : ret;
3083}

3085__shr_public__attribute__((visibility("default"))) int libnvmf_get_owner_from_fctx(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, char **owner)
3087{
struct libnvmf_tid *tid;
const char *name;
int ret;

if (!ctx || !fctx || !owner)
return -EINVAL22;

*owner = NULL((void*)0);

name = libnvmf_context_get_device(fctx);
if (name) {
ret = libnvmf_registry_retrieve(ctx, name, "owner", owner);
return (ret == -ENOENT2) ? 0 : ret;
}

ret = libnvmf_tid_from_fields(
	libnvmf_context_get_transport(fctx),
	libnvmf_context_get_traddr(fctx),
	libnvmf_context_get_trsvcid(fctx),
	libnvmf_context_get_subsysnqn(fctx),
	libnvmf_context_get_host_traddr(fctx),
	libnvmf_context_get_host_iface(fctx),
	libnvmf_context_get_hostnqn(fctx),
	libnvmf_context_get_hostid(fctx), &tid);
if (ret)
return ret;

ret = libnvmf_get_owner_from_tid(ctx, tid, owner);
libnvmf_tid_free(tid);

return ret;
3119}

3121static int setup_connection(struct libnvmf_context *fctx, bool_Bool discovery)
3122{
if (!fctx->ctrl_params.trsvcid)
fctx->ctrl_params.trsvcid =
	libnvmf_get_default_trsvcid(fctx->ctrl_params.transport,
		discovery);

return 0;
3129}


3132static int set_discovery_kato(struct libnvmf_context *fctx,
struct libnvme_ctrl_params *params)
3134{
int tmo = params->cfg.keep_alive_tmo;
/*
* EPCSD isn't known until after the Discovery Log Page comes back, so
* auto mode optimistically requests a KATO here; dc_decide()
* disconnects per entry afterward if EPCSD turns out to be unset.
*/
bool_Bool wants_kato = fctx->persistent == LIBNVMF_PERSISTENT_AUTO ||
fctx->persistent == LIBNVMF_PERSISTENT_FORCE;

/* Set kato to NVMF_DEF_DISC_TMO for persistent controllers */
if (wants_kato && !params->cfg.keep_alive_tmo)
params->cfg.keep_alive_tmo = fctx->default_keep_alive_timeout;
/* Set kato to zero for non-persistent controllers */
else if (!wants_kato && params->cfg.keep_alive_tmo > 0)
params->cfg.keep_alive_tmo = 0;

return tmo;
3152}

3154enum dc_ownership {
DC_OWNED,
DC_BORROWED,
3157};

3159/*
* Decide whether a discovery controller connection should be disconnected
* once its own Discovery Log Page has been fully walked. Pure function,
* no I/O, so it is directly unit-testable.
*
* @own: DC_BORROWED means this connection pre-existed the walk and is
*       never ours to disconnect, regardless of persistence mode.
* @self_seen: whether this DC's own self entry (SUBTYPE 03h, "current
*             discovery subsystem") was found in its own Discovery Log
*             Page.
* @self_eflags: that self entry's EFLAGS; meaningful only if @self_seen.
* @parent_eflags: the EFLAGS this DC's own referral entry carried in its
*                 parent's Discovery Log Page, or NULL if this DC has no
*                 parent (the primary). Used only as a fallback when
*                 @self_seen is false.
*/
3175static bool_Bool dc_decide(struct libnvmf_context *fctx, const char *subnqn,
enum dc_ownership own, bool_Bool self_seen, __u16 self_eflags,
const __u16 *parent_eflags)
3178{
__u16 eflags;
bool_Bool disconnect;

if (own == DC_BORROWED)
return false0;

if (self_seen)
eflags = self_eflags;
else if (parent_eflags)
eflags = *parent_eflags;
else
eflags = 0;

switch (fctx->persistent) {
case LIBNVMF_PERSISTENT_FORCE:
/* Persist regardless of what EPCSD reports. */
disconnect = false0;
break;
case LIBNVMF_PERSISTENT_AUTO:
/* Persist only where the entry's own EPCSD flag says so. */
disconnect = !(eflags & NVMF_DISC_EFLAGS_EPCSD);
if (disconnect)
	libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN,__libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN, ((void*)0), "%s: not persisting, EPCSD=0\n"
, subnqn)
		"%s: not persisting, EPCSD=0\n", subnqn)__libnvme_msg(fctx->ctx, LIBNVME_LOG_WARN, ((void*)0), "%s: not persisting, EPCSD=0\n"
, subnqn);
break;
case LIBNVMF_PERSISTENT_NO:
case LIBNVMF_PERSISTENT_UNSET:
default:
disconnect = true1;
break;
}

return disconnect;
3212}

3214/*
* Bundles the controller and the decisions made about it while walking a
* Discovery Log Page, so the whole outcome for one entry (or, with @e
* NULL, for the primary's own self entry) can be logged in one place.
*/
3219struct dc_decision {
struct libnvme_ctrl *c;
bool_Bool primary;
bool_Bool already_connected;
bool_Bool connect;
bool_Bool disconnect;
3225};

3227static void dc_log_decision(struct libnvmf_context *fctx,
struct nvmf_disc_log_entry *e, const struct dc_decision *d,
const char *reason)
3230{
const char *subnqn, *transport, *traddr, *trsvcid;
const char *ctrl_name = d->c ? libnvme_ctrl_get_name(d->c) : NULL((void*)0);
__u16 eflags = 0;

if (e) {
subnqn = e->subnqn;
transport = libnvmf_trtype_str(e->trtype);
traddr = e->traddr;
trsvcid = e->trsvcid;
eflags = le16_to_cpu(e->eflags);
} else if (d->c) {
subnqn = libnvme_ctrl_get_subsysnqn(d->c);
transport = libnvme_ctrl_get_transport(d->c);
traddr = libnvme_ctrl_get_traddr(d->c);
trsvcid = libnvme_ctrl_get_trsvcid(d->c);
} else {
subnqn = transport = traddr = trsvcid = "-";
}

libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "")
"discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n",__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "")
subnqn, transport, traddr, trsvcid, eflags, d->primary,__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "")
d->already_connected, d->connect, d->disconnect,__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "")
ctrl_name ? ctrl_name : "-", reason ? " reason=" : "",__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "")
reason ? reason : "")__libnvme_msg(fctx->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "discover: %s transport %s traddr %s trsvcid %s eflags 0x%04x primary=%d already_connected=%d connect=%d disconnect=%d ctrl=%s%s%s\n"
, subnqn, transport, traddr, trsvcid, eflags, d->primary, d
->already_connected, d->connect, d->disconnect, ctrl_name
 ? ctrl_name : "-", reason ? " reason=" : "", reason ? reason
 : "");
3256}

3258static void dc_already_connected(struct libnvmf_context *fctx,
struct libnvme_host *h, struct nvmf_disc_log_entry *e)
3260{
if (fctx->hooks.already_connected)
fctx->hooks.already_connected(fctx, h, e->subnqn,
	libnvmf_trtype_str(e->trtype), e->traddr,
	e->trsvcid, fctx->hooks.user_data);
3265}

3267/*
* The spec does not require processing referral entries deeper than
* eight levels.
*/
3271#define NVMF_MAX_REFERRAL_DEPTH8 8

3273/*
* Every discovery controller visited during one top-level walk, keyed by
* TID. The depth cap alone is not a cycle guard -- a referral graph can
* cycle back to an earlier DC within eight hops -- so this is what
* actually stops the walk from looping.
*/
3279SHR_PTRARRAY_DEFINE(dc_visited, struct libnvmf_tid)struct dc_visited { struct libnvmf_tid **items; size_t len; size_t
 cap; }; static inline int dc_visited_append(struct dc_visited
 *a, struct libnvmf_tid *item) { do { (void) sizeof(char [1 -
 2*!(sizeof(struct dc_visited) == sizeof(struct shr_ptrarray)
)]); } while(0); return shr_ptrarray_append( (struct shr_ptrarray
 *)a, item); } static inline void dc_visited_free(struct dc_visited
 *a) { shr_ptrarray_free((struct shr_ptrarray *)a); };

3281static bool_Bool dc_visited_has(const struct dc_visited *v,
const struct libnvmf_tid *tid)
3283{
const char *canon = libnvmf_tid_get_canonical(tid);

if (!canon)
return false0;

for (size_t i = 0; i < v->len; i++) {
const char *seen = libnvmf_tid_get_canonical(v->items[i]);

if (seen && !strcmp(seen, canon))
	return true1;
}

return false0;
3297}

3299/*
* Registers c's own real, connected identity -- not whatever a referring
* entry claimed about it -- so a cycle that loops back to c (including
* back to the primary) is recognized even if reached via a differently
* reported path. Best-effort: a TID construction failure here just means
* this one DC isn't deduplicated, not a fatal error for the walk.
*/
3306static void dc_visited_register(struct dc_visited *visited,
struct libnvme_ctrl *c, struct libnvmf_context *fctx)
3308{
struct libnvmf_tid *tid;
int err;

err = libnvmf_tid_from_fields(libnvme_ctrl_get_transport(c),
	libnvme_ctrl_get_traddr(c), libnvme_ctrl_get_trsvcid(c),
	libnvme_ctrl_get_subsysnqn(c),
	libnvme_ctrl_get_host_traddr(c),
	libnvme_ctrl_get_host_iface(c),
	fctx->hostnqn, fctx->hostid, &tid);
if (err)
return;

if (dc_visited_append(visited, tid))
libnvmf_tid_free(tid);
3323}

3325static inline void free_libnvmf_tid(struct libnvmf_tid **tid)
3326{
libnvmf_tid_free(*tid);
3328}
3329#define __cleanup_libnvmf_tid__attribute__((cleanup(free_libnvmf_tid))) __cleanup(free_libnvmf_tid)__attribute__((cleanup(free_libnvmf_tid)))

3331/*
* A leaf entry (NVME_NQN_NVME, an I/O controller) is a dead end for the
* walk: connect it if --connect was requested, and there is nothing
* further to recurse into.
*/
3336static void dc_connect_leaf_entry(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host *h,
struct libnvme_ctrl *dc, struct nvmf_disc_log_entry *e,
struct libnvme_ctrl_params *params)
3340{
struct dc_decision d = { 0 };
int err;

if (!fctx->connect) {
dc_log_decision(fctx, e, &d, "connect not requested");
return;
}

if (fctx->hooks.connect_leaf) {
/*
 * NBFT's own leaf-connect quirks (DHCP retry, firing
 * hooks.connected) apply instead -- it fires the hook
 * itself.
 */
err = fctx->hooks.connect_leaf(ctx, fctx, h, e, params, &d.c);
} else {
err = nvmf_connect_disc_entry(fctx, h, dc, e, params, &d.c);
if (d.c && fctx->hooks.connected)
	fctx->hooks.connected(fctx, d.c, fctx->hooks.user_data);
}
if (d.c) {
d.connect = true1;
dc_log_decision(fctx, e, &d, NULL((void*)0));
} else if (err == -ENVME_CONNECT_ALREADY) {
dc_already_connected(fctx, h, e);
} else {
dc_log_decision(fctx, e, &d, libnvme_strerror(-err));
}
3369}

3371static int _nvmf_discover(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx,
const struct libnvme_ctrl_params *ctrl_params,
struct libnvme_ctrl *c, enum dc_ownership own, int depth,
struct dc_visited *visited, const __u16 *parent_eflags,
bool_Bool *disconnected);

3378/*
* A referral entry (NVME_NQN_DISC) is a branch point: it opens up another
* Discovery Service to walk, unlike a leaf entry.
*/
3382static void dc_walk_referral(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host *h,
struct libnvme_ctrl *dc, struct nvmf_disc_log_entry *e,
struct libnvme_ctrl_params *params, int depth,
struct dc_visited *visited, __u16 eflags)
3387{
__cleanup_libnvmf_tid__attribute__((cleanup(free_libnvmf_tid))) struct libnvmf_tid *tid = NULL((void*)0);
struct dc_decision d = { 0 };
enum dc_ownership child_own;
bool_Bool child_disconnected = false0;
struct libnvme_ctrl *cl;
int err, tmo;

if (depth >= NVMF_MAX_REFERRAL_DEPTH8) {
dc_log_decision(fctx, e, &d,
	"referral depth limit reached, not descending");
return;
}

if (libnvmf_tid_from_fields(params->transport, params->traddr,
	params->trsvcid, params->subsysnqn,
	params->host_traddr, params->host_iface,
	fctx->hostnqn, fctx->hostid, &tid)) {
dc_log_decision(fctx, e, &d, "invalid entry");
return;
}

if (dc_visited_has(visited, tid)) {
dc_log_decision(fctx, e, &d, "already visited this walk");
return;
}

cl = lookup_live_ctrl(h, params);
if (cl) {
d.c = cl;
d.already_connected = true1;
child_own = DC_BORROWED;
} else {
/* params also serves as the child DC's entries' parent. */
tmo = set_discovery_kato(fctx, params);
err = nvmf_connect_disc_entry(fctx, h, dc, e, params, &d.c);
params->cfg.keep_alive_tmo = tmo;
if (!d.c) {
	if (err == -ENVME_CONNECT_ALREADY)
		dc_already_connected(fctx, h, e);
	else
		dc_log_decision(fctx, e, &d,
			libnvme_strerror(-err));
	return;
}
child_own = DC_OWNED;
if (fctx->hooks.connected)
	fctx->hooks.connected(fctx, d.c, fctx->hooks.user_data);
}
d.connect = true1;
dc_log_decision(fctx, e, &d, NULL((void*)0));

if (tid) {
if (!dc_visited_append(visited, tid))
	tid = NULL((void*)0); /* ownership transferred */
}

/*
* The child decides its own fate (disconnect or persist)
* internally, the same way this DC just did above for
* itself. Only free it if it actually disconnected --
* a persisted child must stay in the tree, since a sibling
* or later referral elsewhere in this same walk may still
* need to find it via lookup_live_ctrl()/dc_visited_has().
*/
_nvmf_discover(ctx, fctx, params, d.c, child_own, depth + 1,
       visited, &eflags, &child_disconnected);
if (child_disconnected)
libnvme_free_ctrl(d.c);
3456}

3458/*
* A Discovery Log Page entry never carries an IPv6 scope, but a link-local
* address is only meaningful together with the link it was learned on.
* Without the scope the kernel has to guess the outgoing interface, which
* fails on multi-homed hosts. TCP can fall back on host_iface, RDMA has no
* such option, so the scope in traddr is the only way to pass it along.
*
* If @c was reached through a scoped link-local address, the DC can only
* have reported link-local addresses on that very same link, so inherit
* @c's scope for any unscoped link-local traddr in @e.
*/
3469static void dc_scope_link_local_entry(const struct libnvme_ctrl *c,
struct nvmf_disc_log_entry *e)
3471{
const char *scope;
size_t len;

if (e->adrfam != NVMF_ADDR_FAMILY_IP6 || strchr(e->traddr, '%')_Generic (0 ? (e->traddr) : (void *) 1, const void *: (const
 char *) (strchr (e->traddr, '%')), default: strchr (e->
traddr, '%')))
return;
scope = c->traddr ? strchr(c->traddr, '%')_Generic (0 ? (c->traddr) : (void *) 1, const void *: (const
 char *) (strchr (c->traddr, '%')), default: strchr (c->
traddr, '%')) : NULL((void*)0);
if (!scope)
return;
/* A scope on anything but a link-local address names no link. */
if (!shr_ipv6_is_link_local(c->traddr) ||
   !shr_ipv6_is_link_local(e->traddr))
return;

len = strlen(e->traddr);
if (len + strlen(scope) >= sizeof(e->traddr))
return;

strcpy(e->traddr + len, scope);
libnvme_msg(c->ctx, LIBNVME_LOG_DEBUG,__libnvme_msg(c->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "using scope '%s' of %s for link-local traddr %s\n"
, scope + 1, libnvme_ctrl_get_name(c), e->traddr)
 "using scope '%s' of %s for link-local traddr %s\n",__libnvme_msg(c->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "using scope '%s' of %s for link-local traddr %s\n"
, scope + 1, libnvme_ctrl_get_name(c), e->traddr)
 scope + 1, libnvme_ctrl_get_name(c), e->traddr)__libnvme_msg(c->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "using scope '%s' of %s for link-local traddr %s\n"
, scope + 1, libnvme_ctrl_get_name(c), e->traddr);
3493}

3495/*
* Is @e the self entry for the DC's own connection (@c)? A multi-homed DC may
* report one self entry per port (Base spec 2.4, Figure 320, subtype 03h);
* only the entry matching @c's transport, traddr and trsvcid is this same
* connection, so only its EFLAGS apply here. The others describe the DC's
* other ports.
*/
3502static bool_Bool dc_entry_is_self(const struct libnvme_ctrl *c,
const struct nvmf_disc_log_entry *e)
3504{
if (e->subtype != NVME_NQN_CURR ||
   !shr_streq0(c->transport, libnvmf_trtype_str(e->trtype)) ||
   !shr_streq0(c->trsvcid, e->trsvcid))
return false0;

if (shr_streq0(c->traddr, e->traddr))
return true1;

/*
* c->traddr is canonicalized, but the DC may report its own address
* in any valid notation (e.g. "FE80::20C:..."). Compare IP addresses
* by value.
*/
return (e->trtype == NVMF_TRTYPE_TCP ||
e->trtype == NVMF_TRTYPE_RDMA) &&
      libnvme_ipaddrs_eq(c->traddr, e->traddr);
3521}

3523/*
* Pass 1a: sanitize the DLP entries and inherit @c's IPv6 scope for
* link-local ones. This must happen before dc_survey_self_entry(), which
* relies on terminated strings and compares traddr including the scope.
*
* Sanitizing here, not right after the fetch, is deliberate: fctx->hooks
* .discovery_log fires before this runs, and it must see the log page
* exactly as the DC returned it (e.g. for --raw). Only the passes that
* follow need the guaranteed-terminated strings this pass produces.
*/
3533static void dc_prepare_entries(struct libnvme_ctrl *c,
struct nvmf_discovery_log *log, uint64_t numrec)
3535{
for (uint64_t i = 0; i < numrec; i++) {
struct nvmf_disc_log_entry *e = &log->entries[i];

sanitize_discovery_log_entry(c->ctx, e);
dc_scope_link_local_entry(c, e);
}
3542}

3544/*
* Pass 1b: survey this DC's own self entry (SUBTYPE 03h) -- the only place
* this DC's own EPCSD is ever reported. Returns whether c should be
* disconnected once its own Discovery Log Page has been fully walked.
*/
3549static bool_Bool dc_survey_self_entry(struct libnvmf_context *fctx,
struct libnvme_ctrl *c, enum dc_ownership own, bool_Bool primary,
const __u16 *parent_eflags, struct nvmf_discovery_log *log,
uint64_t numrec)
3553{
struct nvmf_disc_log_entry *self_entry = NULL((void*)0);
struct dc_decision d = {
.c = c,
.primary = primary,
.already_connected = own == DC_BORROWED,
};
bool_Bool self_seen;
__u16 self_eflags;

for (uint64_t i = 0; i < numrec; i++) {
struct nvmf_disc_log_entry *e = &log->entries[i];

if (dc_entry_is_self(c, e))
	self_entry = e;
}

self_seen = self_entry != NULL((void*)0);
self_eflags = self_seen ? le16_to_cpu(self_entry->eflags) : 0;

d.disconnect = dc_decide(fctx, libnvme_ctrl_get_subsysnqn(c), own,
	self_seen, self_eflags, parent_eflags);

if (self_entry) {
dc_log_decision(fctx, self_entry, &d, NULL((void*)0));
} else if (own == DC_BORROWED) {
dc_log_decision(fctx, NULL((void*)0), &d,
	"pre-existing, not ours to disconnect");
} else if (parent_eflags) {
dc_log_decision(fctx, NULL((void*)0), &d,
	"no self entry, using parent's view");
} else {
dc_log_decision(fctx, NULL((void*)0), &d,
	"no self entry, EPCSD assumed 0");
}

return d.disconnect;
3590}

3592static int _nvmf_discover(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx,
const struct libnvme_ctrl_params *ctrl_params,
struct libnvme_ctrl *c, enum dc_ownership own, int depth,
struct dc_visited *visited, const __u16 *parent_eflags,
bool_Bool *disconnected)
3598{
__cleanup_free__attribute__((cleanup(shr_freep))) struct nvmf_discovery_log *log = NULL((void*)0);
struct libnvme_subsystem *s = libnvme_ctrl_get_subsystem(c);
struct libnvme_host *h = libnvme_subsystem_get_host(s);
uint64_t numrec;
bool_Bool disconnect;
int err;

if (disconnected)
*disconnected = false0;

struct libnvmf_discovery_args args = {
.max_retries = fctx->default_max_discovery_retries,
.lsp = NVMF_LOG_DISC_LSP_NONE,
};

err = nvme_discovery_log(c, &args, &log);
if (err) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(-err))
	"failed to get discovery log: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(-err))
	libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(-err));
return err;
}

numrec = le64_to_cpu(log->numrec);

if (fctx->hooks.discovery_log)
fctx->hooks.discovery_log(fctx, log, numrec,
	fctx->hooks.user_data);

dc_visited_register(visited, c, fctx);

/*
* Pass 1: prepare the entries, then survey c's own self entry and
* determine if safe to disconnect.
*/
dc_prepare_entries(c, log, numrec);
disconnect = dc_survey_self_entry(fctx, c, own, !parent_eflags,
			   parent_eflags, log, numrec);

/*
* Safe to disconnect now, before walking c's own referrals: this
* connection is only ever needed to fetch c's own DLP, and
* dc_visited already recorded c, independent of whether the
* connection stays open.
*/
if (disconnect) {
libnvmf_disconnect_ctrl(c);
if (disconnected)
	*disconnected = true1;
}

/*
* Pass 2: everything else -- referrals to walk, NVM subsystem
* entries to connect per --connect. Self entries are already
* handled above.
*/
for (uint64_t i = 0; i < numrec; i++) {
struct nvmf_disc_log_entry *e = &log->entries[i];
__cleanup_ctrl_params__attribute__((cleanup(cleanup_ctrl_params))) struct libnvme_ctrl_params params =
	ctrl_params_dup(ctrl_params);
struct dc_decision d = { 0 };
const char *transport;
__u16 eflags;

/*
 * A self entry describes this same Discovery subsystem.
 * Real DCs publish one for the port already connected;
 * a multi-port DC may also list its other ports. Base spec
 * 2.4 makes acting on either a "may", and a log page entry
 * carries no source address or interface, so the only local
 * path available is the one this connection already uses.
 */
if (e->subtype == NVME_NQN_CURR)
	continue;

/* Skip connect if the transport types don't match */
transport = libnvmf_trtype_str(e->trtype);
if (strcmp(libnvme_ctrl_get_transport(c), transport)) {
	dc_log_decision(fctx, e, &d, "transport mismatch");
	continue;
}

params.subsysnqn = e->subnqn;
params.transport = transport;
params.traddr = e->traddr;
params.trsvcid = e->trsvcid;
eflags = le16_to_cpu(e->eflags);

if (e->subtype == NVME_NQN_NVME) {
	dc_connect_leaf_entry(ctx, fctx, h, c, e, &params);
	continue;
}

/* NVME_NQN_DISC: a referral to another Discovery Service. */
dc_walk_referral(ctx, fctx, h, c, e, &params, depth, visited,
		  eflags);
}

return 0;
3698}

3700/*
* Owns the whole-walk visited-set lifetime, so callers don't need to know
* it exists. c has no parent -- it is the primary discovery controller
* connection -- so the walk starts at depth 0 with no parent eflags.
*/
3705static int dc_walk(struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx,
struct libnvme_ctrl *c, enum dc_ownership own)
3707{
struct dc_visited visited = { 0 };
int err;

err = _nvmf_discover(ctx, fctx, &fctx->ctrl_params, c, own, 0,
	&visited, NULL((void*)0), NULL((void*)0));

/* dc_visited owns only the backing array, not the TIDs in it. */
for (size_t i = 0; i < visited.len; i++)
libnvmf_tid_free(visited.items[i]);
dc_visited_free(&visited);

return err;
3720}

3722__shr_public__attribute__((visibility("default"))) const char *libnvmf_get_default_trsvcid(const char *transport,
bool_Bool discovery_ctrl)
3724{
if (!transport)
return NULL((void*)0);
if (!strcmp(transport, "tcp")) {
if (discovery_ctrl)
	/* Default port for NVMe/TCP discovery controllers */
	return stringify(NVME_DISC_IP_PORT)"8009";
/* Default port for NVMe/TCP io controllers */
return stringify(NVME_RDMA_IP_PORT)"4420";
} else if (!strcmp(transport, "rdma")) {
/* Default port for NVMe/RDMA controllers */
return stringify(NVME_RDMA_IP_PORT)"4420";
}

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

3741static int libnvme_add_ctrl(struct libnvmf_context *fctx,
struct libnvme_host *h, struct libnvme_ctrl *c)
3743{
int err;

3746retry:
err = libnvmf_add_ctrl(h, c);
if (!err)
return 0;
if (fctx->hooks.decide_retry &&
   fctx->hooks.decide_retry(fctx, err, fctx->hooks.user_data))
goto retry;

return err;
3755}

3757static int __create_discovery_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_ctrl_params *params,
struct libnvme_host *h, struct libnvme_ctrl **ctrl)
3760{
struct libnvme_ctrl *c;
int tmo, ret;

/* libnvme_create_ctrl() copies params->cfg into the controller. */
tmo = set_discovery_kato(fctx, params);
ret = libnvme_create_ctrl(ctx, params, &c);
params->cfg.keep_alive_tmo = tmo;
if (ret)
return ret;

libnvme_ctrl_set_discovery_ctrl(c, true1);
libnvme_ctrl_set_unique_discovery_ctrl(c,
strcmp(params->subsysnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery"));

/*
* TP8017: no bidirectional authentication with the well-known
* discovery NQN.
*/
if (fctx->hostkey) {
libnvme_ctrl_set_kxchap_host_key(c, fctx->hostkey);
if (fctx->ctrlkey && libnvme_ctrl_get_unique_discovery_ctrl(c))
	libnvme_ctrl_set_kxchap_ctrl_key(c, fctx->ctrlkey);
}

ret = libnvme_add_ctrl(fctx, h, c);
if (ret) {
libnvme_free_ctrl(c);
return ret;
}

*ctrl = c;
return 0;
3793}

3795static int nvmf_create_discovery_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_ctrl_params *params,
struct libnvme_host *h, struct libnvme_ctrl **ctrl)
3798{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ctrl *id = NULL((void*)0);
struct libnvme_ctrl *c;
int ret;

ret = __create_discovery_ctrl(ctx, fctx, params, h, &c);
if (ret)
return ret;

if (libnvme_ctrl_get_unique_discovery_ctrl(c)) {
*ctrl = c;
return 0;
}

id = libnvme_alloc(sizeof(*id));
if (!id) {
libnvme_free_ctrl(c);
return -ENOMEM12;
}

ret = libnvme_open(ctx, c->name, O_RDONLY00, &c->hdl);
if (ret) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "failed to open %s\n", c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open %s\n"
, c->name);
libnvmf_disconnect_ctrl(c);
libnvme_free_ctrl(c);
return ret;
}

/* Find out the name of discovery controller */
ret = libnvme_ctrl_identify(c, id);
if (ret)  {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to identify controller, error %s\n"
, libnvme_strerror(-ret))
	 "failed to identify controller, error %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to identify controller, error %s\n"
, libnvme_strerror(-ret))
	 libnvme_strerror(-ret))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to identify controller, error %s\n"
, libnvme_strerror(-ret));
libnvmf_disconnect_ctrl(c);
libnvme_free_ctrl(c);
return ret;
}

/* Force NUL termination — id->subnqn is a fixed-width wire field */
char subnqn[NVME_NQN_LENGTH + 1];

memcpy(subnqn, id->subnqn, NVME_NQN_LENGTH);
subnqn[NVME_NQN_LENGTH] = '\0';
shr_rtrim(subnqn);

if (!strcmp(subnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery")) {
*ctrl = c;
return 0;
}

/*
* The subsysnqn is not the well-known name. Prefer the unique
* subsysnqn over the well-known one.
*/
libnvmf_disconnect_ctrl(c);
libnvme_free_ctrl(c);

/*
* params may be &fctx->ctrl_params, which outlives this
* function; libnvme_create_ctrl() (called from
* __create_discovery_ctrl() below) takes its own strdup()'d
* copy of subsysnqn before returning, so restoring the
* caller's pointer right after that call is safe and keeps
* params from being left pointing at this function's stack.
*/
const char *prev_subsysnqn = params->subsysnqn;

params->subsysnqn = subnqn;
ret = __create_discovery_ctrl(ctx, fctx, params, h, &c);
params->subsysnqn = prev_subsysnqn;
if (ret)
return ret;

*ctrl = c;
return 0;
3874}

3876static struct libnvme_ctrl *dc_open_by_device(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx,
struct libnvme_ctrl_params *params, enum dc_ownership *own)
3879{
struct libnvme_ctrl *c;
int err;

err = libnvme_scan_ctrl(ctx, fctx->device, &c);
if (err) {
/* No controller found, fall back to creating one. */
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found\n"
, fctx->device)
	"ctrl device %s not found\n", fctx->device)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found\n"
, fctx->device);
return NULL((void*)0);
}

/* Check if device matches command-line options */
if (!libnvmf_ctrl_match_config(c, params)) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non matching command-line options\n"
, fctx->device)
	"ctrl device %s found, ignoring non matching command-line options\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non matching command-line options\n"
, fctx->device)
	fctx->device)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non matching command-line options\n"
, fctx->device);
}

if (!libnvme_ctrl_get_discovery_ctrl(c)) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non discovery controller\n"
, fctx->device)
	"ctrl device %s found, ignoring non discovery controller\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non discovery controller\n"
, fctx->device)
	fctx->device)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non discovery controller\n"
, fctx->device);

libnvme_free_ctrl(c);
return NULL((void*)0);
}

/*
* The controller device was found, so this is an already-existing
* connection: it must not be disconnected on exit. Record that fact
* locally instead of overriding fctx->persistent, which must keep
* reflecting what the user actually asked for.
*/
*own = DC_BORROWED;

/*
* When --host-traddr/--host-iface are not specified on the
* command line, use the discovery controller's (c) host-
* traddr/host-iface for the connections to controllers
* returned in the Discovery Log Pages. This is essential
* when invoking "connect-all" with --device to reuse an
* existing persistent discovery controller (as is done
* for the udev rules). This ensures that host-traddr/
* host-iface are consistent with the discovery controller (c).
*/
if (!params->host_traddr)
params->host_traddr = (char *)libnvme_ctrl_get_host_traddr(c);
if (!params->host_iface)
params->host_iface = (char *)libnvme_ctrl_get_host_iface(c);

return c;
3931}

3933/*
* Ownership is reported separately (@own) rather than folded into
* fctx->persistent, which must keep reflecting what the user actually
* asked for regardless of whether this connection is reused or fresh.
*
* @honor_no_reuse: false makes this ignore --no-reuse and always attempt
*                  reuse first. NBFT's boot-time auto-connect has no
*                  concept of --no-reuse and always tries to reuse an
*                  existing connection first.
*/
3943static int dc_open(struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx,
struct libnvme_host *h, struct libnvme_ctrl_params *params,
bool_Bool honor_no_reuse, enum dc_ownership *own,
struct libnvme_ctrl **ctrl)
3947{
struct libnvme_ctrl *c = NULL((void*)0);
enum dc_ownership local_own = DC_OWNED;
int err;

if (!honor_no_reuse || !fctx->no_reuse) {
if (fctx->device)
	c = dc_open_by_device(ctx, fctx, params, &local_own);

if (!c) {
	c = lookup_ctrl(h, params);
	if (c)
		local_own = DC_BORROWED;
}
}

if (c) {
if (!libnvme_ctrl_get_transport_handle(c)) {
	/*
	 * When we found an existing controller it might not
	 * have a device handle yet
	 */
	err = libnvme_open(ctx, c->name, O_RDONLY00, &c->hdl);
	if (err) {
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open %s\n"
, c->name)
			"failed to open %s\n", c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open %s\n"
, c->name);
		return err;
	}
}
} else {
/*
 * No existing controller, or --no-reuse was given: create a
 * new one.
 */
err = nvmf_create_discovery_ctrl(ctx, fctx, params, h, &c);

/*
 * NBFT only: the OS's own DHCP client can obtain a different
 * local address for this HFI than the firmware had when it
 * built the NBFT table. Retry once without host_traddr.
 * fctx->nbft_hfi is NULL for every non-NBFT caller, so this
 * is a complete no-op for the general path.
 */
if (err == -ENVME_CONNECT_ADDRNOTAVAIL && fctx->nbft_hfi &&
    !strcmp(params->transport, "tcp") &&
    strlen(fctx->nbft_hfi->tcp_info.dhcp_server_ipaddr) > 0) {
	params->host_traddr = NULL((void*)0);
	err = nvmf_create_discovery_ctrl(ctx, fctx, params,
			h, &c);
}

if (err)
	return err;
}

*own = local_own;
*ctrl = c;
return 0;
4005}

4007#define NBFT_SYSFS_FILENAME"NBFT*"	"NBFT*"

4009static int nbft_filter(const struct dirent *dent)
4010{
return !fnmatch(NBFT_SYSFS_FILENAME"NBFT*", dent->d_name, FNM_PATHNAME(1 << 0));
4012}

4014__shr_public__attribute__((visibility("default"))) int libnvmf_nbft_read_files(
struct libnvme_global_ctx *ctx, char *path,
struct nbft_file_entry **head)
4017{
struct nbft_file_entry *entry = NULL((void*)0);
struct libnbft_info *nbft = NULL((void*)0);
struct dirent **dent;
char filename[PATH_MAX4096];
int i, count, ret;

*head = NULL((void*)0);

count = scandir(path, &dent, nbft_filter, NULL((void*)0));
if (count < 0)
return -errno(*__errno_location ());

for (i = 0; i < count; i++) {
snprintf(filename, sizeof(filename), "%s/%s", path,
	dent[i]->d_name);

ret = libnvmf_read_nbft(ctx, &nbft, filename);
if (!ret) {
	struct nbft_file_entry *new;

	new = calloc(1, sizeof(*new));
	if (!new) {
		libnvmf_free_nbft(ctx, nbft);
		ret = -ENOMEM12;
		goto err;
	}
	new->nbft = nbft;
	if (entry) {
		entry->next = new;
		entry = entry->next;
	} else {
		entry = new;
		*head = entry;
	}
}
free(dent[i]);
}
free(dent);
return 0;

4058err:
for (; i < count; i++)
free(dent[i]);
free(dent);
libnvmf_nbft_free(ctx, *head);
*head = NULL((void*)0);
return ret;
4065}

4067__shr_public__attribute__((visibility("default"))) void libnvmf_nbft_free(
struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
4069{
if (!head)
return;

while (head) {
struct nbft_file_entry *next = head->next;

libnvmf_free_nbft(ctx, head->nbft);
free(head);

head = next;
}
4081}

4083static bool_Bool validate_uri(struct libnvme_global_ctx *ctx,
	 struct libnbft_discovery *dd,
	 struct libnvmf_uri *uri)
4086{
if (!uri) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to parse URI %s\n"
, dd->index, dd->uri)
	 "Discovery Descriptor %d: failed to parse URI %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to parse URI %s\n"
, dd->index, dd->uri)
	 dd->index, dd->uri)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to parse URI %s\n"
, dd->index, dd->uri);
return false0;
}
if (strcmp(uri->scheme, "nvme") != 0) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported scheme '%s'\n"
, dd->index, uri->scheme)
	 "Discovery Descriptor %d: unsupported scheme '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported scheme '%s'\n"
, dd->index, uri->scheme)
	 dd->index, uri->scheme)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported scheme '%s'\n"
, dd->index, uri->scheme);
return false0;
}
if (!uri->protocol || strcmp(uri->protocol, "tcp") != 0) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported transport '%s'\n"
, dd->index, uri->protocol)
	 "Discovery Descriptor %d: unsupported transport '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported transport '%s'\n"
, dd->index, uri->protocol)
	 dd->index, uri->protocol)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: unsupported transport '%s'\n"
, dd->index, uri->protocol);
return false0;
}

return true1;
4107}

4109static int nbft_connect(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_ctrl_params *params,
struct libnvme_host *h, struct nvmf_disc_log_entry *e,
struct libnbft_subsystem_ns *ss, struct libnvme_ctrl **cp)
4113{
struct libnvme_ctrl *c;
int saved_log_level;
bool_Bool saved_log_tstamp;
bool_Bool saved_log_pid;
int ret;

if (cp)
*cp = NULL((void*)0);

saved_log_level = libnvme_get_logging_level(ctx, &saved_log_pid,
&saved_log_tstamp);

c = lookup_live_ctrl(h, params);
if (c) {
if (cp)
	*cp = c;
return 0;
}

if (nvmf_excluded(ctx, params->transport,
	  params->traddr, params->trsvcid,
	  params->subsysnqn,
	  params->host_traddr,
	  params->host_iface,
	  libnvme_host_get_hostnqn(h),
	  libnvme_host_get_hostid(h)))
return 0;

ret = libnvme_create_ctrl(ctx, params, &c);
if (ret)
return ret;

/* Pause logging for unavailable SSNSs */
if (ss && (ss->flags & NBFT_SSNS_UNAVAIL_NAMESPACE_UNAVAIL) && saved_log_level < 1)
libnvme_set_logging_level(ctx, -1, false0, false0);

/* Update tls or concat */
nvmf_update_tls_concat(e, c, h);

ret = libnvmf_add_ctrl(h, c);

/* Resume logging */
if (ss && (ss->flags & NBFT_SSNS_UNAVAIL_NAMESPACE_UNAVAIL) && saved_log_level < 1)
libnvme_set_logging_level(ctx,
		  saved_log_level,
		  saved_log_pid,
		  saved_log_tstamp);

if (ret) {
libnvme_free_ctrl(c);
/*
 * In case this SSNS was marked as 'unavailable' and
 * our connection attempt has failed, ignore it.
 */
if (ss && (ss->flags & NBFT_SSNS_UNAVAIL_NAMESPACE_UNAVAIL)) {
	libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d reported as unavailable, skipping\n"
, ss->index)
		"SSNS %d reported as unavailable, skipping\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d reported as unavailable, skipping\n"
, ss->index)
		ss->index)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d reported as unavailable, skipping\n"
, ss->index);
	return 0;
}
return ret;
}

if (fctx->hooks.connected)
fctx->hooks.connected(fctx, c, fctx->hooks.user_data);

if (cp)
*cp = c;
return 0;
4183}

4185/*
* connect_leaf hook for the NBFT-driven walk: nbft_connect() plus the
* checks _nvmf_discover()'s general leaf-connect path gets for free from
* distinguishable lookup_ctrl()/nvmf_excluded() outcomes. nbft_connect()
* has its own copies of both checks internally, but folds every "nothing
* to do" outcome into a plain 0 -- fine for its other caller (the SSNS
* loop below), but not enough to fit dc_log_decision()'s
* connected/already-connected/reason contract. Re-checking here, before
* calling nbft_connect(), keeps nbft_connect() itself untouched for that
* other caller.
*/
4196static int nbft_connect_leaf(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host *h,
struct nvmf_disc_log_entry *e,
struct libnvme_ctrl_params *params, struct libnvme_ctrl **cp)
4200{
struct libnvme_ctrl *c;
int ret;

*cp = NULL((void*)0);

c = lookup_live_ctrl(h, params);
if (c) {
*cp = c;
return -ENVME_CONNECT_ALREADY;
}

if (nvmf_excluded(ctx, params->transport, params->traddr,
	  params->trsvcid, params->subsysnqn,
	  params->host_traddr, params->host_iface,
	  libnvme_host_get_hostnqn(h),
	  libnvme_host_get_hostid(h)))
return -EPERM1;

ret = nbft_connect(ctx, fctx, params, h, e, NULL((void*)0), &c);

/*
* With TCP/DHCP, the OS's own DHCP client can obtain a different
* local address for this HFI than the firmware had. Retry once
* without host_traddr.
*/
if (ret == -ENVME_CONNECT_ADDRNOTAVAIL &&
   !strcmp(params->transport, "tcp") && fctx->nbft_hfi &&
   strlen(fctx->nbft_hfi->tcp_info.dhcp_server_ipaddr) > 0) {
params->host_traddr = NULL((void*)0);
ret = nbft_connect(ctx, fctx, params, h, e, NULL((void*)0), &c);
}

if (!ret)
*cp = c;

return ret;
4237}

4239#define VLAN_PROC_PATH"/proc/net/vlan" "/proc/net/vlan"

4241/*
* Return 0 for no vlan_id, to be consistent with the NBFT spec.
*/
4244static int get_vlan_id(const char *ifname)
4245{
char path[256], line[256];
int vlan_id = 0;
FILE *f;

snprintf(path, sizeof(path), "%s/%s", VLAN_PROC_PATH"/proc/net/vlan", ifname);
f = fopen(path, "r");
if (!f)
return 0;

while (fgets(line, sizeof(line), f)) {
if (sscanf(line, " VID: %d", &vlan_id) == 1) {
	fclose(f);
	return vlan_id;
}
}

fclose(f);
return 0;
4264}

4266/*
* Find network interface corresponding to the NBFT HFI
* by looking for mac address and vlan id.
*/
4270static char *nbft_find_hfi_iface(struct libnbft_hfi *hfi)
4271{
struct ifaddrs *ifaddr, *ifa;
char *result = NULL((void*)0);

if (strcmp((char *)hfi->transport, "tcp"))
return NULL((void*)0);

if (getifaddrs(&ifaddr) != 0)
return NULL((void*)0);

for (ifa = ifaddr; ifa != NULL((void*)0); ifa = ifa->ifa_next) {
struct sockaddr_ll *sll;

if (!ifa->ifa_addr)
	continue;

if (ifa->ifa_addr->sa_family != AF_PACKET17)
	continue;

sll = (struct sockaddr_ll *)ifa->ifa_addr;

if (sll->sll_halen != ETH_ALEN6)
	continue;

if (!memcmp(sll->sll_addr, hfi->tcp_info.mac_addr, ETH_ALEN6)) {
	int vlan_id = get_vlan_id(ifa->ifa_name);

	if (vlan_id == hfi->tcp_info.vlan) {
		result = strdup(ifa->ifa_name);
		break;
	}
}
}

freeifaddrs(ifaddr);
return result;
4307}

4309__shr_public__attribute__((visibility("default"))) int libnvmf_discover_nbft(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
4311{
const char *hostnqn = NULL((void*)0), *hostid = NULL((void*)0), *host_traddr = NULL((void*)0);
char uuid[NVME_UUID_LEN_STRING37];
struct nbft_file_entry *head = NULL((void*)0), *entry;
struct libnbft_subsystem_ns **ss;
struct libnbft_hfi *hfi;
struct libnbft_discovery **dd;
struct libnvme_host *h;
int ret, rr, i;

if (!fctx->nbft_path)
return -EINVAL22;

ret = libnvme_get_host(ctx, fctx->hostnqn, fctx->hostid, &h);
if (ret)
return ret;

ret = setup_connection(fctx, false0);
if (ret)
return ret;

if (!fctx->connect)
/* TODO: print discovery-type info from NBFT tables */
return 0;

ret = libnvmf_nbft_read_files(ctx, fctx->nbft_path, &head);
if (ret) {
if (ret != -ENOENT2)
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to access ACPI tables directory\n"
)
		"Failed to access ACPI tables directory\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to access ACPI tables directory\n"
);
else
	ret = 0;  /* nothing to connect */
goto out_free;
}

for (entry = head; entry; entry = entry->next) {
hostid = fctx->hostid;
if (fctx->hostnqn)
	hostnqn = fctx->hostnqn;
else {
	hostnqn = entry->nbft->host.nqn;
	if (!hostnqn)
		hostnqn = fctx->hostnqn;
}

if (!hostid && entry->nbft->host.id && *entry->nbft->host.id) {
	ret = libnvme_uuid_to_string(entry->nbft->host.id, uuid);
	if (!ret)
		hostid = uuid;
}

ret = libnvme_get_host(ctx, hostnqn, hostid, &h);
if (ret)
	goto out_free;

/* Subsystem Namespace Descriptor List */
for (ss = entry->nbft->subsystem_ns_list; ss && *ss; ss++)
	for (i = 0; i < (*ss)->num_hfis; i++) {
		__cleanup_ctrl_params__attribute__((cleanup(cleanup_ctrl_params))) struct libnvme_ctrl_params params =
			ctrl_params_copy(&fctx->ctrl_params);

		hfi = (*ss)->hfis[i];
		if (!hfi) {
			libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has no HFI at position %d\n"
, (*ss)->index, i)
				"SSNS %d has no HFI at position %d\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has no HFI at position %d\n"
, (*ss)->index, i)
				(*ss)->index, i)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has no HFI at position %d\n"
, (*ss)->index, i);
			ret = -EINVAL22;
			continue;
		}

		/* Skip discovery NQN records */
		if (strcmp((*ss)->subsys_nqn,
				NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery") == 0) {
			libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d points to well-known discovery NQN, skipping\n"
, (*ss)->index)
				"SSNS %d points to well-known discovery NQN, skipping\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d points to well-known discovery NQN, skipping\n"
, (*ss)->index)
				(*ss)->index)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d points to well-known discovery NQN, skipping\n"
, (*ss)->index);
			continue;
		}

		if ((*ss)->security) {
			libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*ss)->index, (*ss)->security->index)
				"SSNS %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*ss)->index, (*ss)->security->index)
				(*ss)->index,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*ss)->index, (*ss)->security->index)
				(*ss)->security->index)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*ss)->index, (*ss)->security->index);
			continue;
		}

		params.host_traddr = NULL((void*)0);
		if (!fctx->ctrl_params.host_traddr &&
		    !strncmp((*ss)->transport, "tcp", 3))
			params.host_traddr =
				hfi->tcp_info.ipaddr;

		params.subsysnqn = (*ss)->subsys_nqn;
		params.transport = (*ss)->transport;
		params.traddr = (*ss)->traddr;
		params.trsvcid = (*ss)->trsvcid;
		params.host_iface = nbft_find_hfi_iface(hfi);
		if (!params.host_iface)
			libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: could not find host interface for HFI %d\n"
, (*ss)->index, hfi->index)
				"SSNS %d: could not find host interface for HFI %d\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: could not find host interface for HFI %d\n"
, (*ss)->index, hfi->index)
				(*ss)->index, hfi->index)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: could not find host interface for HFI %d\n"
, (*ss)->index, hfi->index);

		rr = nbft_connect(ctx, fctx, &params, h, NULL((void*)0),
				*ss, NULL((void*)0));

		/*
		 * With TCP/DHCP, it can happen that the OS
		 * obtains a different local IP address than the
		 * firmware had. Retry without host_traddr.
		 */
		if (rr == -ENVME_CONNECT_ADDRNOTAVAIL &&
		    !strcmp(params.transport,
			    "tcp") &&
		    strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
			params.host_traddr = NULL((void*)0);

			rr = nbft_connect(ctx, fctx, &params, h,
				NULL((void*)0), *ss, NULL((void*)0));

			if (rr == 0)
				libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, (*ss)->index, host_traddr)
					"SSNS %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, (*ss)->index, host_traddr)
					(*ss)->index,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, (*ss)->index, host_traddr)
					host_traddr)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "SSNS %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, (*ss)->index, host_traddr);
		}

		if (rr) {
			libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d: no controller found\n"
, (*ss)->index)
				"SSNS %d: no controller found\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d: no controller found\n"
, (*ss)->index)
				(*ss)->index)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "SSNS %d: no controller found\n"
, (*ss)->index);
			/* report an error */
			ret = rr;
		}

		if (rr == -ENOMEM12)
			goto out_free;
	}

/* Discovery Descriptor List */
for (dd = entry->nbft->discovery_list; dd && *dd; dd++) {
	__cleanup_uri__attribute__((cleanup(free_uri))) struct libnvmf_uri *uri = NULL((void*)0);
	__cleanup_free__attribute__((cleanup(shr_freep))) char *trsvcid = NULL((void*)0);
	__cleanup_ctrl_params__attribute__((cleanup(cleanup_ctrl_params))) struct libnvme_ctrl_params params =
		ctrl_params_copy(&fctx->ctrl_params);
	enum dc_ownership own;
	bool_Bool linked = false0;
	struct libnvme_ctrl *c;

	/* only perform discovery when no SSNS record references it */
	for (ss = entry->nbft->subsystem_ns_list;
			ss && *ss; ss++)
		if ((*ss)->discovery &&
		    (*ss)->discovery->index == (*dd)->index &&
		    /* unavailable boot attempts are not discovered
		     * and may get transferred along with a well-known
		     * discovery NQN into an SSNS record.
		     */
		    strcmp((*ss)->subsys_nqn,
				NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery") != 0) {
			linked = true1;
			break;
		}
	if (linked)
		continue;

	if ((*dd)->security) {
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*dd)->index, (*dd)->security->index)
			"Discovery Descriptor %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*dd)->index, (*dd)->security->index)
			(*dd)->index,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*dd)->index, (*dd)->security->index)
			(*dd)->security->index)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has Security Profile Descriptor %d associated, security profile descriptors are currently unimplemented, skipping\n"
, (*dd)->index, (*dd)->security->index);
		continue;
	}

	hfi = (*dd)->hfi;
	if (!hfi) {
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has no HFI\n"
, (*dd)->index)
			"Discovery Descriptor %d has no HFI\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has no HFI\n"
, (*dd)->index)
			(*dd)->index)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d has no HFI\n"
, (*dd)->index);
		ret = -EINVAL22;
		continue;
	}
	ret = libnvmf_uri_parse((*dd)->uri, &uri);
	if (ret)
		continue;
	if (!validate_uri(ctx, *dd, uri))
		continue;

	host_traddr = NULL((void*)0);
	if (!fctx->ctrl_params.host_traddr &&
	    !strncmp(uri->protocol, "tcp", 3))
		host_traddr = hfi->tcp_info.ipaddr;
	if (uri->port > 0) {
		if (asprintf(&trsvcid, "%d", uri->port) < 0) {
			ret = -ENOMEM12;
			goto out_free;
		}
	} else
		trsvcid =
			strdup(libnvmf_get_default_trsvcid(
				uri->protocol, true1));

	params.subsysnqn = (*dd)->nqn ?
		(*dd)->nqn : NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery";
	params.transport =  uri->protocol;
	params.traddr = uri->host;
	params.trsvcid = trsvcid;
	params.host_traddr = host_traddr;
	params.host_iface = nbft_find_hfi_iface(hfi);
	if (!params.host_iface)
		libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index)
			"Discovery Descriptor %d: could not find host interface for HFI %d\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index)
			(*dd)->index, hfi->index)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index);

	/*
	 * NBFT boot discovery is a one-shot operation: never
	 * honor --no-reuse (dc_open()'s honor_no_reuse=false
	 * below) and never keep a freshly created connection
	 * alive past this walk (--persistent has no meaning
	 * here either). nbft_hfi and connect_leaf give
	 * dc_open() and the shared walker's leaf-connect step
	 * access to this DC's own HFI/leaf-connect quirks,
	 * several stack frames removed from this loop.
	 */
	fctx->nbft_hfi = hfi;
	fctx->hooks.connect_leaf = nbft_connect_leaf;
	fctx->persistent = LIBNVMF_PERSISTENT_NO;

	ret = dc_open(ctx, fctx, h, &params, false0, &own, &c);
	if (ret) {
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to add discovery controller: %s\n"
, (*dd)->index, libnvme_strerror(-ret))
			"Discovery Descriptor %d: failed to add discovery controller: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to add discovery controller: %s\n"
, (*dd)->index, libnvme_strerror(-ret))
			(*dd)->index, libnvme_strerror(-ret))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to add discovery controller: %s\n"
, (*dd)->index, libnvme_strerror(-ret));
		goto out_free;
	}

	rr = dc_walk(ctx, fctx, c, own);
	libnvme_free_ctrl(c);
	if (rr == -ENOMEM12) {
		ret = rr;
		goto out_free;
	}
}
}
4555out_free:
libnvmf_nbft_free(ctx, head);
return ret;
4558}

4560__shr_public__attribute__((visibility("default"))) int libnvmf_discover(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
4562{
struct libnvme_ctrl *c = NULL((void*)0);
struct libnvme_host *h;
enum dc_ownership own;
int err;

err = libnvme_get_host(ctx, fctx->hostnqn, fctx->hostid, &h);
if (err)
return err;

err = setup_connection(fctx, true1);
if (err)
return err;

err = dc_open(ctx, fctx, h, &fctx->ctrl_params, true1, &own, &c);
if (err) {
if (err != -ENVME_CONNECT_IGNORED &&
    err != -ENVME_CONNECT_DRY_RUN)
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-err))
		"failed to add controller, error %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-err))
		libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-err));
return err;
}

err = dc_walk(ctx, fctx, c, own);
libnvme_free_ctrl(c);

return err;
4590}

4592__shr_public__attribute__((visibility("default"))) int libnvmf_connect(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx)
4594{
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int devid_fd = -1;
struct libnvme_host *h;
struct libnvme_ctrl *c;
int err;

/* Open before touching kernel state, so a bad path fails fast. */
if (fctx->devid_file) {
devid_fd = open_devid_file(fctx);
if (devid_fd < 0)
	return devid_fd;
}

err = libnvme_get_host(ctx, fctx->hostnqn, fctx->hostid, &h);
if (err)
return err;

err = setup_connection(fctx, false0);
if (err)
return err;

c = lookup_live_ctrl(h, &fctx->ctrl_params);
if (c && !fctx->ctrl_params.cfg.duplicate_connect) {
int instance = ctrl_instance(c);

write_devid_file(fctx, devid_fd, c);
if (instance >= 0)
	registry_update_on_connect(ctx, instance, false0);
if (fctx->hooks.already_connected)
	fctx->hooks.already_connected(fctx, h,
		libnvme_ctrl_get_subsysnqn(c),
		libnvme_ctrl_get_transport(c),
		libnvme_ctrl_get_traddr(c),
		libnvme_ctrl_get_trsvcid(c),
		fctx->hooks.user_data);
return -ENVME_CONNECT_ALREADY;
}

err = libnvmf_create_ctrl(ctx, fctx, &c);
if (err)
return err;

err = libnvme_add_ctrl(fctx, h, c);
if (err) {
/*
 * Kernel-level race: something else connected between our
 * scan and this ioctl. @c is our own unconnected draft, not
 * the winner.
 */
if (err == -ENVME_CONNECT_ALREADY) {
	if (libnvme_scan_topology(ctx, NULL((void*)0), NULL((void*)0)) == 0) {
		struct libnvme_ctrl *winner;

		winner = lookup_ctrl(h, &fctx->ctrl_params);
		if (winner) {
			int instance = ctrl_instance(winner);

			write_devid_file(fctx, devid_fd, winner);
			if (instance >= 0)
				registry_update_on_connect(ctx,
					instance, false0);
		}
	}

	if (fctx->hooks.already_connected)
		fctx->hooks.already_connected(fctx, h,
			fctx->ctrl_params.subsysnqn,
			fctx->ctrl_params.transport,
			fctx->ctrl_params.traddr,
			fctx->ctrl_params.trsvcid,
			fctx->hooks.user_data);
} else if (err != -ENVME_CONNECT_DRY_RUN) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR, "could not add new controller: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not add new controller: %s\n"
, libnvme_strerror(-err))
		libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not add new controller: %s\n"
, libnvme_strerror(-err));
}

libnvme_free_ctrl(c);
return err;
}

write_devid_file(fctx, devid_fd, c);
if (fctx->hooks.connected)
fctx->hooks.connected(fctx, c, fctx->hooks.user_data);

return 0;
4679}