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

Bug Summary

File:	.build-ci/../libnvme/src/nvme/fabrics.c
Warning:	line 2049, column 32 Access to field 'ctx' results in a dereference of a null pointer (loaded from variable 'c')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -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/lib/llvm-19/lib/clang/19 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I libnvme/src/libnvme3.so.3.0.0.p -I libnvme/src -I ../libnvme/src -I ccan -I ../ccan -I . -I .. -I /usr/include/json-c -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -std=gnu99 -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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-06-24-175442-590-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 <unistd.h>

24#include <arpa/inet.h>
25#include <linux1/if_ether.h>
26#include <net/if.h>
27#include <netpacket/packet.h>
28#include <netdb.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 <libnvme.h>

40#include "cleanup.h"
41#include "cleanup-linux.h"
42#include "private.h"
43#include "private-fabrics.h"
44#include "compiler-attributes.h"

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

48static inline void free_uri(struct libnvmf_uri **uri)
49{
libnvmf_uri_free(*uri);
51}
52#define __cleanup_uri__attribute__((cleanup(free_uri))) __cleanup(free_uri)__attribute__((cleanup(free_uri)))

54/**
* strchomp() - Strip trailing spaces
* @str: String to strip
* @max: Maximum length of string
*/
59static void strchomp(char *str, int max)
60{
int i;

for (i = max - 1; i >= 0 && str[i] == ' '; i--) {
str[i] = '\0';
}
66}

68const char *arg_str(const char * const *strings,
size_t array_size, size_t idx)
70{
if (idx < array_size && strings[idx])
return strings[idx];
return "unrecognized";
74}

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

83__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_trtype_str(__u8 trtype)
84{
return arg_str(trtypes, ARRAY_SIZE(trtypes)(sizeof(trtypes) / sizeof((trtypes)[0]) + 0), trtype);
86}

88static 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",
94};

96__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_adrfam_str(__u8 adrfam)
97{
return arg_str(adrfams, ARRAY_SIZE(adrfams)(sizeof(adrfams) / sizeof((adrfams)[0]) + 0), adrfam);
99}

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

107__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_subtype_str(__u8 subtype)
108{
return arg_str(subtypes, ARRAY_SIZE(subtypes)(sizeof(subtypes) / sizeof((subtypes)[0]) + 0), subtype);
110}

112static 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",
125};

127__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_treq_str(__u8 treq)
128{
return arg_str(treqs, ARRAY_SIZE(treqs)(sizeof(treqs) / sizeof((treqs)[0]) + 0), treq);
130}

132static 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",
151};

153__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_eflags_str(__u16 eflags)
154{
return arg_str(eflags_strings, ARRAY_SIZE(eflags_strings)(sizeof(eflags_strings) / sizeof((eflags_strings)[0]) + 0), eflags);
156}

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

164__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_sectype_str(__u8 sectype)
165{
return arg_str(sectypes, ARRAY_SIZE(sectypes)(sizeof(sectypes) / sizeof((sectypes)[0]) + 0), sectype);
167}

169static 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",
175};

177__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_prtype_str(__u8 prtype)
178{
return arg_str(prtypes, ARRAY_SIZE(prtypes)(sizeof(prtypes) / sizeof((prtypes)[0]) + 0), prtype);
180}

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

187__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_qptype_str(__u8 qptype)
188{
return arg_str(qptypes, ARRAY_SIZE(qptypes)(sizeof(qptypes) / sizeof((qptypes)[0]) + 0), qptype);
190}

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

196__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_cms_str(__u8 cm)
197{
return arg_str(cms, ARRAY_SIZE(cms)(sizeof(cms) / sizeof((cms)[0]) + 0), cm);
199}

201void libnvmf_default_config(struct libnvme_fabrics_config *cfg)
202{
cfg->tos = -1;
cfg->ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO600;
205}

207__libnvme_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)
217{
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;
236}

238__libnvme_public__attribute__((visibility("default"))) void libnvmf_context_free(struct libnvmf_context *fctx)
239{
if (!fctx)
return;

free(fctx->tls_key);
free(fctx);
245}

247__libnvme_public__attribute__((visibility("default"))) int libnvmf_context_set_discovery_hooks(
struct libnvmf_context *fctx,
void (*discovery_log)(struct libnvmf_context *fctx,
	bool_Bool connect,
	struct nvmf_discovery_log *log,
	uint64_t numrec, void *user_data),
int (*parser_init)(struct libnvmf_context *fctx,
	void *user_data),
void (*parser_cleanup)(struct libnvmf_context *fctx,
	void *user_data),
int (*parser_next_line)(struct libnvmf_context *fctx,
	void *user_data))
259{
fctx->hooks.discovery_log = discovery_log;
fctx->hooks.parser_init = parser_init;
fctx->hooks.parser_cleanup = parser_cleanup;
fctx->hooks.parser_next_line = parser_next_line;

return 0;
266}



270__libnvme_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)
274{
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;
283}

285static const char *hostid_from_hostnqn(const char *hostnqn)
286{
const char *match;

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

match = strstr(hostnqn, "uuid:");
if (!match)
return NULL((void*)0);

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

299__libnvme_public__attribute__((visibility("default"))) int libnvmf_context_set_hostnqn(struct libnvmf_context *fctx,
const char *hostnqn, const char *hostid)
301{
fctx->hostnqn = hostnqn;
if (!hostid)
hostid = hostid_from_hostnqn(hostnqn);
fctx->hostid = hostid;

return 0;
308}

310__libnvme_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)
314{
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)) {
__cleanup_free__attribute__((cleanup(freep))) unsigned char *raw_secret = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *encoded_key = NULL((void*)0);
int key_len = 32;

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

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

fctx->tls_key = encoded_key;
encoded_key = NULL((void*)0);
return 0;
}

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

349__libnvme_public__attribute__((visibility("default"))) int libnvmf_context_set_device(
struct libnvmf_context *fctx, const char *device)
351{
fctx->device = device;

return 0;
355}

357__libnvme_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)
361{
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;
369}

371__libnvme_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)
374{
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;
380}

382/*
* 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.
*/
388static 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,
411};

413#define MERGE_CFG_OPTION(c, n, o, d)if ((c)->o == d) (c)->o = (n)->o			\
if ((c)->o == d) (c)->o = (n)->o
415static void merge_config(libnvme_ctrl_t c,
const struct libnvme_fabrics_config *cfg)
417{
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;
437}

439#define UPDATE_CFG_OPTION(c, n, o, d)if ((n)->o != d) (c)->o = (n)->o			\
if ((n)->o != d) (c)->o = (n)->o
441static void update_config(libnvme_ctrl_t c,
const struct libnvme_fabrics_config *cfg)
443{
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;
463}

465static int __add_bool_argument(char **argstr, char *tok, bool_Bool arg)
466{
char *nstr;

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

return 0;
478}

480static int __add_hex_argument(char **argstr, char *tok, int arg, bool_Bool allow_zero)
481{
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;
493}

495static int __add_int_argument(char **argstr, char *tok, int arg, bool_Bool allow_zero)
496{
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;
508}

510static int __add_int_or_minus_one_argument(char **argstr, char *tok, int arg)
511{
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;
523}

525static int __add_argument(char **argstr, const char *tok, const char *arg)
526{
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;
538}

540static int __nvmf_supported_options(struct libnvme_global_ctx *ctx);
541#define nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })					\
542({									\
!__nvmf_supported_options(ctx) && ctx->options->tok;		\
544})

546#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;
 })			\
547({									\
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;								\
560})

562#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
; })		\
563({									\
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;								\
577})

579#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
; })		\
580({									\
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;								\
594})

596#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
; })		\
597({									\
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;								\
610})

612#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; })				\
613({									\
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;								\
626})

628static int inet4_pton(const char *src, uint16_t port,
      struct sockaddr_storage *addr)
630{
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;
643}

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

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

__cleanup_free__attribute__((cleanup(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, '%');
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;
682}

684/**
* 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.
*/
694static int inet_pton_with_scope(struct libnvme_global_ctx *ctx, int af,
		const char *src, const char * trsvcid,
		struct sockaddr_storage *addr)
697{
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;
730}

732bool_Bool traddr_is_hostname(struct libnvme_global_ctx *ctx,
const char *transport, const char *traddr)
734{
struct sockaddr_storage addr;

if (!traddr || !transport)
return false0;
if (!strcmp(traddr, "none"))
return false0;
if (strcmp(transport, "tcp") && strcmp(transport, "rdma"))
return false0;
if (inet_pton_with_scope(ctx, AF_UNSPEC0,
	traddr, NULL((void*)0), &addr) == 0)  /* scope-aware */
return false0;

return true1;
748}

750static int build_options(libnvme_host_t h, libnvme_ctrl_t c, char **argstr)
751{
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);
hostkey = libnvme_host_get_dhchap_host_key(h);
if (!hostkey)
hostkey = libnvme_ctrl_get_dhchap_host_key(c);

if (hostkey)
ctrlkey = libnvme_ctrl_get_dhchap_ctrl_key(c);

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 [--dhchap-secret | -S] not specified with --concat\n")__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "required argument [--dhchap-secret | -S] not specified with --concat\n"
);
return -ENVME_CONNECT_INVAL;
}

if (c->cfg.tls) {
ret = __libnvme_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; }))) {
free(*argstr);
return -1;
}

return 0;
881}

883#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;		   		\
}

889static int __nvmf_supported_options(struct libnvme_global_ctx *ctx)
890{
char buf[0x1000], *options, *p, *v;
__cleanup_fd__attribute__((cleanup(cleanup_fd))) int fd = -1;
ssize_t len;

if (ctx->options)
return 0;

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

fd = open(nvmf_dev, O_RDONLY00);
if (fd < 0) {
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((*__errno_location ())))
	 nvmf_dev, libnvme_strerror(errno))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror((*__errno_location ())));
return -ENVME_CONNECT_OPEN;
}

memset(buf, 0x0, sizeof(buf));
len = read(fd, buf, sizeof(buf) - 1);
if (len < 0) {
if (errno(*__errno_location ()) == 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((*__errno_location ())))
	 nvmf_dev, libnvme_strerror(errno))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror((*__errno_location ())));
return -ENVME_CONNECT_READ;
}

buf[len] = '\0';
options = buf;

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

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

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;
975}

977/*
* Best-effort registry update after a successful connect: record ownership
* when an owner is set, otherwise clear any stale entry for a recycled
* instance.  Failures are logged but never fail the connection.
*/
982static void registry_update_on_connect(struct libnvme_global_ctx *ctx,
		       int instance)
984{
int ret;

if (ctx->owner)
ret = libnvmf_registry_create_instance(ctx, instance,
				       ctx->owner);
else
ret = libnvmf_registry_delete_instance(ctx, instance);
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));
996}

998static int __nvmf_add_ctrl(struct libnvme_global_ctx *ctx, const char *argstr)
999{
__cleanup_fd__attribute__((cleanup(cleanup_fd))) int fd = -1;
int ret, len = strlen(argstr);
int instance;
char buf[0x1000], *options, *p;

fd = open(nvmf_dev, O_RDWR02);
if (fd < 0) {
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((*__errno_location ())))
	 nvmf_dev, libnvme_strerror(errno))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to open %s: %s\n"
, nvmf_dev, libnvme_strerror((*__errno_location ())));
return -ENVME_CONNECT_OPEN;
}

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);
ret = write(fd, argstr, len);
if (ret != len) {
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((*__errno_location ())))
	 nvmf_dev, libnvme_strerror(errno))__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Failed to write to %s: %s\n"
, nvmf_dev, libnvme_strerror((*__errno_location ())));
switch (errno(*__errno_location ())) {
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;
}
}

memset(buf, 0x0, sizeof(buf));
len = read(fd, buf, sizeof(buf) - 1);
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((*__errno_location ())))
	 nvmf_dev, libnvme_strerror(errno))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to read from %s: %s\n"
, nvmf_dev, libnvme_strerror((*__errno_location ())));
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);
buf[len] = '\0';
options = buf;
while ((p = strsep(&options, ",\n")) != NULL((void*)0)) {
if (!*p)
	continue;
if (sscanf(p, "instance=%d", &instance) == 1) {
	registry_update_on_connect(ctx, instance);
	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;
1062}


1065__libnvme_public__attribute__((visibility("default"))) int libnvmf_create_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_ctrl_t *cp)
1067{
return libnvme_create_ctrl(ctx, &fctx->ctrl_params, cp);
1069}

1071__libnvme_public__attribute__((visibility("default"))) int libnvmf_add_ctrl(libnvme_host_t h, libnvme_ctrl_t c)
1072{
libnvme_subsystem_t s;
__cleanup_free__attribute__((cleanup(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;

/* apply configuration from config file (JSON) */
s = libnvme_lookup_subsystem(h, NULL((void*)0), libnvme_ctrl_get_subsysnqn(c));
if (s) {
libnvme_ctrl_t fc;
struct libnvmf_context fctx = {
	.ctrl_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_trsvcid(c),
		.trsvcid = libnvme_ctrl_get_trsvcid(c),
	},
};

fc = libnvmf_ctrl_find(s, &fctx);
if (fc) {
	const char *key;

	merge_config(c, &fc->cfg);
	/*
	 * An authentication key might already been set
	 * in @cfg, so ensure to update @c with the correct
	 * controller key.
	 */
	key = libnvme_ctrl_get_dhchap_host_key(fc);
	if (key)
		libnvme_ctrl_set_dhchap_host_key(c, key);
	key = libnvme_ctrl_get_dhchap_ctrl_key(fc);
	if (key)
		libnvme_ctrl_set_dhchap_ctrl_key(c, key);
	key = libnvme_ctrl_get_keyring(fc);
	if (key)
		libnvme_ctrl_set_keyring(c, key);
	key = libnvme_ctrl_get_tls_key_identity(fc);
	if (key)
		libnvme_ctrl_set_tls_key_identity(c, key);
	key = libnvme_ctrl_get_tls_key(fc);
	if (key)
		libnvme_ctrl_set_tls_key(c, key);
}

}

libnvme_ctrl_set_discovered(c, true1);
if (traddr_is_hostname(h->ctx, c->transport, c->traddr)) {
char *traddr = c->traddr;

if (hostname2traddr(h->ctx, traddr, &c->traddr)) {
	c->traddr = traddr;
	return -ENVME_CONNECT_TRADDR;
}
free(traddr);
}

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);
1146}

1148__libnvme_public__attribute__((visibility("default"))) int libnvmf_connect_ctrl(libnvme_ctrl_t c)
1149{
__cleanup_free__attribute__((cleanup(freep))) char *argstr = NULL((void*)0);
int 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;
1162}

1164__libnvme_public__attribute__((visibility("default"))) int libnvmf_disconnect_ctrl(libnvme_ctrl_t c)
1165{
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);
int ret;

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, (*__errno_location ()))
	"%s: failed to disconnect, error %d\n", c->name, errno)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "%s: failed to disconnect, error %d\n"
, c->name, (*__errno_location ()));
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);
nvme_deconfigure_ctrl(c);
return 0;
1180}

1182static void nvmf_update_tls_concat(struct nvmf_disc_log_entry *e,
libnvme_ctrl_t c, libnvme_host_t h)
1184{
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;
}
1211}

1213static int nvmf_connect_disc_entry(libnvme_host_t h,
struct nvmf_disc_log_entry *e,
struct libnvmf_context *fctx,
bool_Bool *discover, libnvme_ctrl_t *cp)
1217{
libnvme_ctrl_t 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:
	fctx->ctrl_params.traddr = e->traddr;
	fctx->ctrl_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:
	fctx->ctrl_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:
fctx->ctrl_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;
}

fctx->ctrl_params.transport = libnvmf_trtype_str(e->trtype);
fctx->ctrl_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"
, fctx->ctrl_params.transport, fctx->ctrl_params.traddr
, fctx->ctrl_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"
, fctx->ctrl_params.transport, fctx->ctrl_params.traddr
, fctx->ctrl_params.trsvcid)
 fctx->ctrl_params.transport, fctx->ctrl_params.traddr,__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, fctx->ctrl_params.transport, fctx->ctrl_params.traddr
, fctx->ctrl_params.trsvcid)
 fctx->ctrl_params.trsvcid)__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "lookup ctrl (transport: %s, traddr: %s, trsvcid %s)\n"
, fctx->ctrl_params.transport, fctx->ctrl_params.traddr
, fctx->ctrl_params.trsvcid);

ret = libnvme_create_ctrl(h->ctx, &fctx->ctrl_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", fctx->
ctrl_params.transport, fctx->ctrl_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", fctx->
ctrl_params.transport, fctx->ctrl_params.traddr)
	 fctx->ctrl_params.transport, fctx->ctrl_params.traddr)__libnvme_msg(h->ctx, LIBNVME_LOG_DEBUG, ((void*)0), "skipping discovery entry, "
 "failed to allocate %s controller with traddr %s\n", fctx->
ctrl_params.transport, fctx->ctrl_params.traddr);
return ret;
}

switch (e->subtype) {
case NVME_NQN_CURR:
libnvme_ctrl_set_discovered(c, true1);
libnvme_ctrl_set_unique_discovery_ctrl(c,
		strcmp(e->subnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery"));
break;
case NVME_NQN_DISC:
if (discover)
	*discover = true1;
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 (libnvme_ctrl_get_discovered(c)) {
libnvme_free_ctrl(c);
return -EAGAIN11;
}

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);

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;
1328}

1330/*
* 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.
*/
1335#define DISCOVERY_HEADER_LEN20 20

1337static int nvme_discovery_log(libnvme_ctrl_t ctrl,
	      const struct libnvmf_discovery_args *args,
	      struct nvmf_discovery_log **logp)
1340{
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;

hdl = libnvme_ctrl_get_transport_handle(ctrl);
struct libnvme_passthru_cmd cmd;

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;

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;
}

1435out_free_log:
libnvme_free(log);
return err;
1438}

1440static void sanitize_discovery_log_entry(struct libnvme_global_ctx *ctx,
struct nvmf_disc_log_entry *e)
1442{
strchomp(e->trsvcid, sizeof(e->trsvcid));
strchomp(e->traddr, sizeof(e->traddr));

/*
* 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, ',');

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 = ':';
}
}
1459}

1461__libnvme_public__attribute__((visibility("default"))) int libnvmf_get_discovery_log(libnvme_ctrl_t ctrl,
		    const struct libnvmf_discovery_args *args,
		    struct nvmf_discovery_log **logp)
1464{
static const struct libnvmf_discovery_args defaults = {
.max_retries = 6,
.lsp         = NVMF_LOG_DISC_LSP_NONE,
};
struct nvmf_discovery_log *log;
int err;

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;
1484}


1487/**
* 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
*/
1497static __u32 nvmf_get_tel(const char *hostsymname)
1498{
__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;
1511}

1513/**
* 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.
*/
1525static 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)
1528{
__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);
1565}

1567/**
* 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
*/
1589static int nvmf_dim(libnvme_ctrl_t c, enum nvmf_dim_tas tas, __u8 trtype,
    __u8 adrfam, const char *reg_addr, union nvmf_tsas *tsas,
    __u32 *result)
1592{
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);
__cleanup_free__attribute__((cleanup(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);
1672}

1674/**
* 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.
*/
1688static __u8 nvme_get_adrfam(libnvme_ctrl_t c)
1689{
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;
1700}

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

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

1715/**
* 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.
*/
1723static int nvme_fetch_cntrltype_dctype_from_id(libnvme_ctrl_t c)
1724{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ctrl *id = NULL((void*)0);
int ret;

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

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

if (!c->cntrltype) {
if (id->cntrltype > NVME_CTRL_CNTRLTYPE_ADMIN || !cntrltype_str[id->cntrltype])
	c->cntrltype = strdup("reserved");
else
	c->cntrltype = strdup(cntrltype_str[id->cntrltype]);
}

if (!c->dctype) {
if (id->dctype > NVME_CTRL_DCTYPE_CDC || !dctype_str[id->dctype])
	c->dctype = strdup("reserved");
else
	c->dctype = strdup(dctype_str[id->dctype]);
}
return 0;
1750}

1752__libnvme_public__attribute__((visibility("default"))) bool_Bool libnvmf_is_registration_supported(libnvme_ctrl_t c)
1753{
if (!c->cntrltype || !c->dctype)
if (nvme_fetch_cntrltype_dctype_from_id(c))
	return false0;

return !strcmp(c->dctype, "ddc") || !strcmp(c->dctype, "cdc");
1759}

1761__libnvme_public__attribute__((visibility("default"))) int libnvmf_register_ctrl(
libnvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
1763{
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);
1773}

1775#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'))
1778#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))

1781/* returns newly allocated string */
1782static char *unescape_uri(const char *str, int len)
1783{
char *dst;
int l;
int i, j;

l = len > 0 ? len : strlen(str);
dst = malloc(l + 1);
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;
1801}

1803__libnvme_public__attribute__((visibility("default"))) int libnvmf_uri_parse(
const char *str, struct libnvmf_uri **urip)
1805{
__cleanup_uri__attribute__((cleanup(free_uri))) struct libnvmf_uri *uri = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *scheme = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *authority = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *path = NULL((void*)0);
__cleanup_free__attribute__((cleanup(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;

/* split userinfo */
host = strrchr(authority, '@');
if (host) {
host++;
uri->userinfo = unescape_uri(authority, host - authority);
} 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);
}

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

/* separate the fragment */
e = strrchr(path, '#');
if (e) {
	uri->fragment = unescape_uri(e + 1, 0);
	*e = '\0';
}
/* separate the query string */
e = strrchr(path, '?');
if (e) {
	uri->query = unescape_uri(e + 1, 0);
	*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 *));

i = 0;
elem = strtok_r(path, "/", &e);
if (elem)
	uri->path_segments[i++] = unescape_uri(elem, 0);
while (elem && strlen(elem)) {
	elem = strtok_r(NULL((void*)0), "/", &e);
	if (elem)
		uri->path_segments[i++] = unescape_uri(elem, 0);
}
}

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

return 0;
1895}

1897__libnvme_public__attribute__((visibility("default"))) void libnvmf_uri_free(struct libnvmf_uri *uri)
1898{
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);
1913}

1915static libnvme_ctrl_t lookup_ctrl(libnvme_host_t h, struct libnvmf_context *fctx)
1916{
libnvme_subsystem_t s;
libnvme_ctrl_t c;

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

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

1929static int lookup_host(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host **host)
1931{
__cleanup_free__attribute__((cleanup(freep))) char *hnqn = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *hid = NULL((void*)0);
struct libnvme_host *h;
int err;

err = libnvme_host_get_ids(ctx, fctx->hostnqn, fctx->hostid, &hnqn, &hid);
if (err < 0)
return err;

h = libnvme_lookup_host(ctx, hnqn, hid);
if (!h)
return -ENOMEM12;

*host = h;

return 0;
1948}

1950static int setup_connection(struct libnvmf_context *fctx, struct libnvme_host *h,
bool_Bool discovery)
1952{
if (fctx->hostkey)
libnvme_host_set_dhchap_host_key(h, fctx->hostkey);

if (!fctx->ctrl_params.trsvcid)
fctx->ctrl_params.trsvcid =
	libnvmf_get_default_trsvcid(fctx->ctrl_params.transport,
		discovery);

return 0;
1962}


1965static int set_discovery_kato(struct libnvmf_context *fctx)
1966{
int tmo = fctx->ctrl_params.cfg.keep_alive_tmo;

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

return tmo;
1979}

1981static void nvme_parse_tls_args(const char *keyring, const char *tls_key,
		const char *tls_key_identity,
		struct libnvme_fabrics_config *cfg, libnvme_ctrl_t c)
1984{
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);
}
2007}


2010static int _nvmf_discovery(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, bool_Bool connect,
struct libnvme_ctrl *c)
2013{
__cleanup_free__attribute__((cleanup(freep))) struct nvmf_discovery_log *log = NULL((void*)0);
libnvme_subsystem_t s = libnvme_ctrl_get_subsystem(c);
libnvme_host_t h = libnvme_subsystem_get_host(s);
uint64_t numrec;
int err;

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) {
17
←
Assuming 'err' is 0→
18
←
Taking false branch→
37
←
Assuming 'err' is 0→
38
←
Taking false branch→
libnvme_msg(ctx, LIBNVME_LOG_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)
19
←
Assuming field 'discovery_log' is null→
20
←
Taking false branch→
39
←
Assuming field 'discovery_log' is null→
40
←
Taking false branch→
fctx->hooks.discovery_log(fctx, connect, log, numrec,
	fctx->hooks.user_data);

if (!connect40.1
'connect' is true
)
21
←
Assuming 'connect' is true→
22
←
Taking false branch→
41
←
Taking false branch→
return 0;

for (int i = 0; i < numrec; i++) {
23
←
Assuming 'i' is < 'numrec'→
24
←
Loop condition is true.  Entering loop body→
42
←
Assuming 'i' is < 'numrec'→
43
←
Loop condition is true.  Entering loop body→
struct nvmf_disc_log_entry *e = &log->entries[i];
libnvme_ctrl_t cl;
bool_Bool discover = false0;
bool_Bool disconnect;
libnvme_ctrl_t child = { 0 };
int tmo = fctx->ctrl_params.cfg.keep_alive_tmo;
struct libnvmf_context nfctx = *fctx;

sanitize_discovery_log_entry(c->ctx, e);
44
←
Access to field 'ctx' results in a dereference of a null pointer (loaded from variable 'c')

nfctx.ctrl_params.subsysnqn = e->subnqn;
nfctx.ctrl_params.transport = libnvmf_trtype_str(e->trtype);
nfctx.ctrl_params.traddr = e->traddr;
nfctx.ctrl_params.trsvcid = e->trsvcid;

/* Already connected ? */
cl = lookup_ctrl(h, &nfctx);
if (cl && libnvme_ctrl_get_name(cl))
25
←
Assuming 'cl' is null→
	continue;

/* Skip connect if the transport types don't match */
if (strcmp(libnvme_ctrl_get_transport(c),
26
←
Assuming the condition is false→
	   nfctx.ctrl_params.transport))
	continue;

if (e->subtype == NVME_NQN_DISC ||
27
←
Assuming field 'subtype' is not equal to NVME_NQN_DISC→
29
←
Taking false branch→
    e->subtype == NVME_NQN_CURR) {
28
←
Assuming field 'subtype' is not equal to NVME_NQN_CURR→
	__u16 eflags = le16_to_cpu(e->eflags);
	/*
	 * Does this discovery controller return the
	 * same information?
	 */
	if (eflags & NVMF_DISC_EFLAGS_DUPRETINFO)
		continue;

	/*
	 * Are we supposed to keep the discovery
	 * controller around?
	 */
	disconnect = !nfctx.persistent;

	if (strcmp(e->subnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery")) {
		/*
		 * Does this discovery controller doesn't
		 * support explicit persistent connection?
		 */
		if (!(eflags & NVMF_DISC_EFLAGS_EPCSD))
			disconnect = true1;
		else
			disconnect = false0;
	}

	set_discovery_kato(&nfctx);
} else {
	/* NVME_NQN_NVME */
	disconnect = false0;
}

err = nvmf_connect_disc_entry(h, e, &nfctx, &discover, &child);
30
←
Value assigned to 'child'→

nfctx.ctrl_params.cfg.keep_alive_tmo = tmo;

if (!child) {
31
←
Assuming 'child' is null→
32
←
Taking true branch→
	if (discover)
33
←
Assuming 'discover' is true→
34
←
Taking true branch→
		_nvmf_discovery(ctx, &nfctx, true1, child);
35
←
Passing null pointer value via 4th parameter 'c'→
36
←
Calling '_nvmf_discovery'→

	if (child && disconnect) {
		libnvmf_disconnect_ctrl(child);
		libnvme_free_ctrl(child);
	}
} else if (err == -ENVME_CONNECT_ALREADY) {
	struct nvmf_disc_log_entry *e = &log->entries[i];

	nfctx.hooks.already_connected(&nfctx, h, e->subnqn,
		libnvmf_trtype_str(e->trtype), e->traddr,
		e->trsvcid, nfctx.hooks.user_data);
}
}

return 0;
2121}

2123__libnvme_public__attribute__((visibility("default"))) const char *libnvmf_get_default_trsvcid(const char *transport,
bool_Bool discovery_ctrl)
2125{
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);
2140}

2142static bool_Bool is_persistent_discovery_ctrl(libnvme_host_t h, libnvme_ctrl_t c)
2143{
if (libnvme_host_is_pdc_enabled(h, DEFAULT_PDC_ENABLED0))
return libnvme_ctrl_get_unique_discovery_ctrl(c);

return false0;
2148}

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

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

return err;
2163}

2165static int __create_discovery_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_host_t h,
struct libnvme_ctrl **ctrl)
2168{
libnvme_ctrl_t c;
int tmo, ret;

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

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"));
tmo = set_discovery_kato(fctx);

if (libnvme_ctrl_get_unique_discovery_ctrl(c) && fctx->hostkey) {
libnvme_ctrl_set_dhchap_host_key(c, fctx->hostkey);
if (fctx->ctrlkey)
	libnvme_ctrl_set_dhchap_ctrl_key(c, fctx->ctrlkey);
}

ret = libnvme_add_ctrl(fctx, h, c);
fctx->ctrl_params.cfg.keep_alive_tmo = tmo;
if (ret) {
libnvme_free_ctrl(c);
return ret;
}

*ctrl = c;
return 0;
2197}

2199static int nvmf_create_discovery_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_host_t h,
struct libnvme_ctrl **ctrl)
2202{
__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, 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, &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);
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;
}

if (!strcmp(id->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);

fctx->ctrl_params.subsysnqn = id->subnqn;
ret = __create_discovery_ctrl(ctx, fctx, h, &c);
if (ret)
return ret;

*ctrl = c;
return 0;
2258}

2260int _discovery_config_json(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_host_t h, libnvme_ctrl_t c,
bool_Bool connect, bool_Bool force)
2263{
struct libnvmf_context nfctx = *fctx;
libnvme_ctrl_t cn;
int ret = 0;

nfctx.ctrl_params.transport = libnvme_ctrl_get_transport(c);
nfctx.ctrl_params.traddr = libnvme_ctrl_get_traddr(c);
nfctx.ctrl_params.host_traddr = libnvme_ctrl_get_host_traddr(c);
nfctx.ctrl_params.host_iface = libnvme_ctrl_get_host_iface(c);

if (!nfctx.ctrl_params.transport && !nfctx.ctrl_params.traddr)
1
Assuming field 'transport' is non-null→
return 0;

/* ignore none fabric transports */
if (strcmp(nfctx.ctrl_params.transport, "tcp") &&
2
←
Assuming the condition is false→
   strcmp(nfctx.ctrl_params.transport, "rdma") &&
   strcmp(nfctx.ctrl_params.transport, "fc"))
return 0;

/* ignore if no host_traddr for fc */
if (!strcmp(nfctx.ctrl_params.transport, "fc")) {
3
←
Assuming the condition is false→
if (!nfctx.ctrl_params.host_traddr) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host_traddr required for fc\n"
)
		 "host_traddr required for fc\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host_traddr required for fc\n"
);
	return 0;
}
}

/* ignore if host_iface set for any transport other than tcp */
if (!strcmp(nfctx.ctrl_params.transport, "rdma") ||
   !strcmp(nfctx.ctrl_params.transport, "fc")) {
if (nfctx.ctrl_params.host_iface) {
4
←
Assuming field 'host_iface' is null→
5
←
Taking false branch→
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host_iface not permitted for rdma or fc\n"
)
		 "host_iface not permitted for rdma or fc\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "host_iface not permitted for rdma or fc\n"
);
	return 0;
}
}

nfctx.ctrl_params.trsvcid = libnvme_ctrl_get_trsvcid(c);
if (!nfctx.ctrl_params.trsvcid ||
6
←
Assuming field 'trsvcid' is non-null→
8
←
Taking false branch→
   !strcmp(nfctx.ctrl_params.trsvcid, ""))
7
←
Assuming the condition is false→
nfctx.ctrl_params.trsvcid =
	libnvmf_get_default_trsvcid(
		nfctx.ctrl_params.transport, true1);

if (force)
9
←
Assuming 'force' is false→
10
←
Taking false branch→
nfctx.ctrl_params.subsysnqn = libnvme_ctrl_get_subsysnqn(c);
else
nfctx.ctrl_params.subsysnqn = NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery";

if (libnvme_ctrl_get_persistent(c))
11
←
Assuming the condition is false→
12
←
Taking false branch→
nfctx.persistent = true1;

if (!force12.1
'force' is false
) {
13
←
Taking true branch→
cn = lookup_ctrl(h, &nfctx);
if (cn) {
14
←
Assuming 'cn' is non-null→
15
←
Taking true branch→
	nfctx.persistent = true1;
	_nvmf_discovery(ctx, &nfctx, connect, cn);
16
←
Calling '_nvmf_discovery'→
	return 0;
}
}

ret = nvmf_create_discovery_ctrl(ctx, &nfctx, h, &cn);
if (ret)
return 0;

_nvmf_discovery(ctx, &nfctx, connect, cn);
if (!(fctx->persistent || is_persistent_discovery_ctrl(h, cn)))
ret = libnvmf_disconnect_ctrl(cn);
libnvme_free_ctrl(cn);

return ret;
2335}

2337__libnvme_public__attribute__((visibility("default"))) int libnvmf_discovery_config_json(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx,
bool_Bool connect, bool_Bool force)
2340{
const char *hnqn, *hid;
struct libnvme_subsystem *s;
struct libnvme_host *h;
struct libnvme_ctrl *c;
int ret = 0, err;

err = lookup_host(ctx, fctx, &h);
if (err)
return err;

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

libnvme_for_each_host(ctx, h)for (h = libnvme_first_host(ctx); h != ((void*)0); h = libnvme_next_host
(ctx, h)) {
libnvme_for_each_subsystem(h, s)for (s = libnvme_first_subsystem(h); s != ((void*)0); s = libnvme_next_subsystem
(h, s)) {
	hnqn = libnvme_host_get_hostnqn(h);
	if (fctx->hostnqn && hnqn &&
			strcmp(fctx->hostnqn, hnqn))
		continue;
	hid = libnvme_host_get_hostid(h);
	if (fctx->hostid && hid &&
			strcmp(fctx->hostid, hid))
		continue;

	libnvme_subsystem_for_each_ctrl(s, c)for (c = libnvme_subsystem_first_ctrl(s); c != ((void*)0); c =
 libnvme_subsystem_next_ctrl(s, c)) {
		err = _discovery_config_json(ctx, fctx, h, c,
			connect, force);
		if (err) {
			libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				"failed to connect to hostnqn=%s,nqn=%s,%s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				libnvme_host_get_hostnqn(h),__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				libnvme_subsystem_get_name(s),__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				libnvme_ctrl_get_traddr(c))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c));

			if (!ret)
				ret = err;
		}
	}
}
}

return ret;
2384}

2386__libnvme_public__attribute__((visibility("default"))) int libnvmf_connect_config_json(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
2388{
const char *hnqn, *hid;
const char *transport;
libnvme_host_t h;
libnvme_subsystem_t s;
libnvme_ctrl_t c, _c;
int ret = 0, err;

err = lookup_host(ctx, fctx, &h);
if (err)
return err;

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

libnvme_for_each_host(ctx, h)for (h = libnvme_first_host(ctx); h != ((void*)0); h = libnvme_next_host
(ctx, h)) {
libnvme_for_each_subsystem(h, s)for (s = libnvme_first_subsystem(h); s != ((void*)0); s = libnvme_next_subsystem
(h, s)) {
	hnqn = libnvme_host_get_hostnqn(h);
	if (fctx->hostnqn && hnqn &&
			strcmp(fctx->hostnqn, hnqn))
		continue;
	hid = libnvme_host_get_hostid(h);
	if (fctx->hostid && hid &&
			strcmp(fctx->hostid, hid))
		continue;

	libnvme_subsystem_for_each_ctrl_safe(s, c, _c)for (c = libnvme_subsystem_first_ctrl(s), _c = libnvme_subsystem_next_ctrl
(s, c); c != ((void*)0); c = _c, _c = libnvme_subsystem_next_ctrl
(s, c)) {
		transport = libnvme_ctrl_get_transport(c);

		/* ignore none fabric transports */
		if (strcmp(transport, "tcp") &&
		    strcmp(transport, "rdma") &&
		    strcmp(transport, "fc"))
			continue;

		err = libnvmf_connect_ctrl(c);
		if (err) {
			if (err == -ENVME_CONNECT_ALREADY)
				continue;

			libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				 "failed to connect to hostnqn=%s,nqn=%s,%s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				 libnvme_host_get_hostnqn(h),__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				 libnvme_subsystem_get_name(s),__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c))
				 libnvme_ctrl_get_traddr(c))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to connect to hostnqn=%s,nqn=%s,%s\n"
, libnvme_host_get_hostnqn(h), libnvme_subsystem_get_name(s),
 libnvme_ctrl_get_traddr(c));

			if (!ret)
				ret = err;
		}
	}
}
}

return ret;
2443}

2445__libnvme_public__attribute__((visibility("default"))) int libnvmf_discovery_config_file(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx,
bool_Bool connect, bool_Bool force)
2448{
int err;

err = fctx->hooks.parser_init(fctx, fctx->hooks.user_data);
if (err)
return err;

do {
struct libnvmf_context nfctx = *fctx;
err = fctx->hooks.parser_next_line(&nfctx, fctx->hooks.user_data);
if (err)
	break;
libnvmf_discovery(ctx, &nfctx, connect, force);
} while (!err);

fctx->hooks.parser_cleanup(fctx, fctx->hooks.user_data);

if (err != -EOF(-1))
return err;

return 0;
2469}

2471__libnvme_public__attribute__((visibility("default"))) int libnvmf_config_modify(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
2473{
__cleanup_free__attribute__((cleanup(freep))) char *hnqn = NULL((void*)0);
__cleanup_free__attribute__((cleanup(freep))) char *hid = NULL((void*)0);
struct libnvme_host *h;
struct libnvme_subsystem *s;
struct libnvme_ctrl *c;

if (!fctx->hostnqn)
fctx->hostnqn = hnqn = libnvme_read_hostnqn();
if (!fctx->hostid && hnqn)
fctx->hostid = hid = libnvme_read_hostid();

h = libnvme_lookup_host(ctx, fctx->hostnqn, fctx->hostid);
if (!h) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to lookup host '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup host '%s'\n"
, fctx->hostnqn)
	fctx->hostnqn)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup host '%s'\n"
, fctx->hostnqn);
return -ENODEV19;
}

if (fctx->hostkey)
libnvme_host_set_dhchap_host_key(h, fctx->hostkey);

s = libnvme_lookup_subsystem(h, NULL((void*)0), fctx->ctrl_params.subsysnqn);
if (!s) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to lookup subsystem '%s'\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup subsystem '%s'\n"
, fctx->ctrl_params.subsysnqn)
	fctx->ctrl_params.subsysnqn)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup subsystem '%s'\n"
, fctx->ctrl_params.subsysnqn);
return -ENODEV19;
}

c = libnvme_lookup_ctrl(s, &fctx->ctrl_params, NULL((void*)0));
if (!c) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Failed to lookup controller\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup controller\n"
);
return -ENODEV19;
}
if (fctx->ctrlkey)
libnvme_ctrl_set_dhchap_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);

return 0;
2516}

2518#define NBFT_SYSFS_FILENAME"NBFT*"	"NBFT*"

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

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

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)
		return -ENOMEM12;
	new->nbft = nbft;
	if (entry) {
		entry->next = new;
		entry = entry->next;
	} else {
		entry = new;
		*head = entry;
	}
}
free(dent[i]);
}
free(dent);
return 0;
2563}

2565__libnvme_public__attribute__((visibility("default"))) void libnvmf_nbft_free(
struct libnvme_global_ctx *ctx, struct nbft_file_entry *head)
2567{
if (!head)
return;

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

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

head = next;
}
2579}

2581static bool_Bool validate_uri(struct libnvme_global_ctx *ctx,
	 struct libnbft_discovery *dd,
	 struct libnvmf_uri *uri)
2584{
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;
2605}

2607static int nbft_connect(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host *h,
struct nvmf_disc_log_entry *e,
struct libnbft_subsystem_ns *ss)
2611{
libnvme_ctrl_t c;
int saved_log_level;
bool_Bool saved_log_tstamp;
bool_Bool saved_log_pid;
int ret;

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

c = lookup_ctrl(h, fctx);
if (c && libnvme_ctrl_get_name(c))
return 0;

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

/* Pause logging for unavailable SSNSs */
if (ss && ss->unavailable && 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->unavailable && 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->unavailable) {
	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);

return 0;
2664}

2666static int nbft_discovery(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnbft_discovery *dd,
struct libnvme_host *h, struct libnvme_ctrl *c)
2669{
struct nvmf_discovery_log *log = NULL((void*)0);
int ret;
int i;

struct libnvmf_discovery_args args = {
.max_retries = 10 /* MAX_DISC_RETRIES */,
.lsp = NVMF_LOG_DISC_LSP_NONE,
};

ret = nvme_discovery_log(c, &args, &log);
if (ret) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to get discovery log: %s\n"
, dd->index, libnvme_strerror(ret))
	"Discovery Descriptor %d: failed to get discovery log: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: failed to get discovery log: %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 get discovery log: %s\n"
, dd->index, libnvme_strerror(ret));
return ret;
}

for (i = 0; i < le64_to_cpu(log->numrec); i++) {
struct nvmf_disc_log_entry *e = &log->entries[i];
struct libnvmf_context nfctx = *fctx;
libnvme_ctrl_t cl;
int tmo = fctx->ctrl_params.cfg.keep_alive_tmo;

sanitize_discovery_log_entry(c->ctx, e);

nfctx.ctrl_params.subsysnqn = e->subnqn;
nfctx.ctrl_params.transport = libnvmf_trtype_str(e->trtype);
nfctx.ctrl_params.traddr = e->traddr;
nfctx.ctrl_params.trsvcid = e->trsvcid;

if (e->subtype == NVME_NQN_CURR)
	continue;

/* Already connected ? */
cl = lookup_ctrl(h, &nfctx);
if (cl && libnvme_ctrl_get_name(cl))
	continue;

/* Skip connect if the transport types don't match */
if (strcmp(libnvme_ctrl_get_transport(c),
	   nfctx.ctrl_params.transport))
	continue;

if (e->subtype == NVME_NQN_DISC) {
	libnvme_ctrl_t child;

	ret = nvmf_connect_disc_entry(h, e, &nfctx,
		NULL((void*)0), &child);
	if (ret)
		continue;
	nbft_discovery(ctx, &nfctx, dd, h, child);
	libnvmf_disconnect_ctrl(child);
	libnvme_free_ctrl(child);
} else {
	ret = nbft_connect(ctx, &nfctx, h, e, 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 (ret == -ENVME_CONNECT_ADDRNOTAVAIL &&
	    !strcmp(nfctx.ctrl_params.transport, "tcp") &&
	    strlen(dd->hfi->tcp_info.dhcp_server_ipaddr) > 0) {
		const char *htradr =
			nfctx.ctrl_params.host_traddr;

		nfctx.ctrl_params.host_traddr = NULL((void*)0);
		ret = nbft_connect(ctx, &nfctx, h, e, NULL((void*)0));

		if (ret == 0)
			libnvme_msg(ctx, LIBNVME_LOG_INFO,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, dd->index, htradr)
				"Discovery Descriptor %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, dd->index, htradr)
				dd->index,__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, dd->index, htradr)
				htradr)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n"
, dd->index, htradr);
	}

	if (ret)
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: no controller found\n"
, dd->index)
			"Discovery Descriptor %d: no controller found\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: no controller found\n"
, dd->index)
			dd->index)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Discovery Descriptor %d: no controller found\n"
, dd->index);
	if (ret == -ENOMEM12)
		break;
}

fctx->ctrl_params.cfg.keep_alive_tmo = tmo;
}

libnvme_free(log);
return 0;
2760}

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

2764/*
* Return 0 for no vlan_id, to be consistent with the NBFT spec.
*/
2767static int get_vlan_id(const char *ifname)
2768{
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;
2787}

2789/*
* Find network interface corresponding to the NBFT HFI
* by looking for mac address and vlan id.
*/
2793static char *nbft_find_hfi_iface(struct libnbft_hfi *hfi)
2794{
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;
2830}

2832__libnvme_public__attribute__((visibility("default"))) int libnvmf_discovery_nbft(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, bool_Bool connect, char *nbft_path)
2834{
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 *entry = NULL((void*)0);
struct libnbft_subsystem_ns **ss;
struct libnbft_hfi *hfi;
struct libnbft_discovery **dd;
struct libnvme_host *h;
int ret, rr, i;

ret = lookup_host(ctx, fctx, &h);
if (ret)
return ret;

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

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

ret = libnvmf_nbft_read_files(ctx, nbft_path, &entry);
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; entry = entry->next) {
if (fctx->hostnqn)
	hostnqn = fctx->hostnqn;
else {
	hostnqn = entry->nbft->host.nqn;
	if (!hostnqn)
		hostnqn = fctx->hostnqn;
}

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

h = libnvme_lookup_host(ctx, hostnqn, hostid);
if (!h) {
	ret = -ENOENT2;
	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++) {
		struct libnvmf_context nfctx = *fctx;

		hfi = (*ss)->hfis[i];

		/* 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;
		}

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

		nfctx.ctrl_params.subsysnqn = (*ss)->subsys_nqn;
		nfctx.ctrl_params.transport = (*ss)->transport;
		nfctx.ctrl_params.traddr = (*ss)->traddr;
		nfctx.ctrl_params.trsvcid = (*ss)->trsvcid;
		nfctx.ctrl_params.host_iface = nbft_find_hfi_iface(hfi);
		if (!nfctx.ctrl_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, &nfctx, h, NULL((void*)0), *ss);

		/*
		 * 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(nfctx.ctrl_params.transport,
			    "tcp") &&
		    strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
			nfctx.ctrl_params.host_traddr = NULL((void*)0);

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

			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 (nfctx.ctrl_params.host_iface)
			free((char *)nfctx.ctrl_params.host_iface);

		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(freep))) char *trsvcid = NULL((void*)0);
	struct libnvmf_context nfctx = *fctx;
	bool_Bool persistent = false0;
	bool_Bool linked = false0;
	libnvme_ctrl_t 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;

	hfi = (*dd)->hfi;
	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));

	nfctx.ctrl_params.subsysnqn = NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery";
	nfctx.ctrl_params.transport =  uri->protocol;
	nfctx.ctrl_params.traddr = uri->host;
	nfctx.ctrl_params.trsvcid = trsvcid;
	nfctx.ctrl_params.host_traddr = host_traddr;
	nfctx.ctrl_params.host_iface = nbft_find_hfi_iface(hfi);
	if (!nfctx.ctrl_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);

	/* Lookup existing discovery controller */
	c = lookup_ctrl(h, &nfctx);
	if (c && libnvme_ctrl_get_name(c))
		persistent = true1;

	if (!c) {
		ret = nvmf_create_discovery_ctrl(ctx, &nfctx,
			h, &c);
		if (ret == -ENVME_CONNECT_ADDRNOTAVAIL &&
		    !strcmp(nfctx.ctrl_params.transport,
			    "tcp") &&
		    strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
			nfctx.ctrl_params.traddr = NULL((void*)0);
			ret = nvmf_create_discovery_ctrl(ctx,
				&nfctx, h, &c);
		}
	} else
		ret = 0;

	if (nfctx.ctrl_params.host_iface)
		free((char *)nfctx.ctrl_params.host_iface);

	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 = nbft_discovery(ctx, &nfctx, *dd, h, c);
	if (!persistent)
		libnvmf_disconnect_ctrl(c);
	libnvme_free_ctrl(c);
	if (rr == -ENOMEM12) {
		ret = rr;
		goto out_free;
	}
}
}
3058out_free:
libnvmf_nbft_free(ctx, entry);
return ret;
3061}

3063__libnvme_public__attribute__((visibility("default"))) int libnvmf_discovery(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx,
bool_Bool connect, bool_Bool force)
3066{
struct libnvme_ctrl *c = NULL((void*)0);
struct libnvme_host *h;
int ret;

ret = lookup_host(ctx, fctx, &h);
if (ret)
return ret;

ret = setup_connection(fctx, h, true1);
if (ret)
return ret;

if (fctx->device && !force) {
ret = libnvme_scan_ctrl(ctx, fctx->device, &c);
if (!ret) {
	/* Check if device matches command-line options */
	if (!libnvmf_ctrl_match_config(c, fctx)) {
		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(__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s found, ignoring non discovery controller\n"
, fctx->device)
			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);
		c = NULL((void*)0);
		fctx->persistent = false0;
	} else {
		/*
		 * If the controller device is found it must
		 * be persistent, and shouldn't be disconnected
		 * on exit.
		 */
		fctx->persistent = true1;
		/*
		 * 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 (!fctx->ctrl_params.host_traddr)
			fctx->ctrl_params.host_traddr = (char *)
				libnvme_ctrl_get_host_traddr(c);
		if (!fctx->ctrl_params.host_iface)
			fctx->ctrl_params.host_iface = (char *)
				libnvme_ctrl_get_host_iface(c);
	}
} else {
	/*
	 * No controller found, fall back to create one.
	 * But that controller cannot be persistent.
	 */
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found%s\n"
, fctx->device, fctx->persistent ? ", ignoring --persistent"
 : "")
		"ctrl device %s not found%s\n", fctx->device,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found%s\n"
, fctx->device, fctx->persistent ? ", ignoring --persistent"
 : "")
		fctx->persistent ? ", ignoring --persistent" : "")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found%s\n"
, fctx->device, fctx->persistent ? ", ignoring --persistent"
 : "");
	fctx->persistent = false0;
}
}

if (!c && !force) {
c = lookup_ctrl(h, fctx);
if (c)
	fctx->persistent = true1;
}
if (!c) {
/* No device or non-matching device, create a new controller */
ret = nvmf_create_discovery_ctrl(ctx, fctx, h, &c);
if (ret) {
	if (ret != -ENVME_CONNECT_IGNORED)
		libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-ret))
			 "failed to add controller, error %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-ret))
			 libnvme_strerror(-ret))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-ret));
	return ret;
}
}

ret = _nvmf_discovery(ctx, fctx, connect, c);
if (!(fctx->persistent || is_persistent_discovery_ctrl(h, c)))
libnvmf_disconnect_ctrl(c);
libnvme_free_ctrl(c);

return ret;
3157}

3159__libnvme_public__attribute__((visibility("default"))) int libnvmf_connect(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx)
3161{
struct libnvme_host *h;
struct libnvme_ctrl *c;
int err;

err = lookup_host(ctx, fctx, &h);
if (err)
return err;

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

c = lookup_ctrl(h, fctx);
if (c && libnvme_ctrl_get_name(c) &&
   !fctx->ctrl_params.cfg.duplicate_connect) {
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 -EALREADY114;
}

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

if (fctx->hostkey) {
libnvme_ctrl_set_dhchap_host_key(c, fctx->hostkey);
if (fctx->ctrlkey)
	libnvme_ctrl_set_dhchap_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);

/*
* We are connecting to a discovery controller, so let's treat
* this as a persistent connection and specify a KATO.
*/
if (!strcmp(fctx->ctrl_params.subsysnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery")) {
fctx->persistent = true1;

set_discovery_kato(fctx);
}

err = libnvme_add_ctrl(fctx, h, c);
if (err) {
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;
}

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

return 0;
3220}