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

Bug Summary

File:	.build-ci/../libnvme/test/../src/nvme/fabrics.c
Warning:	line 1174, column 30 Access to field 'transport' 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-redhat-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name test-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 static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -fcoverage-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -resource-dir /usr/bin/../lib/clang/22 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I libnvme/test/test-fabrics.p -I libnvme/test -I ../libnvme/test -I . -I .. -I ccan -I ../ccan -I libnvme/src -I ../libnvme/src -I shared -I ../shared -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/bin/../lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/16/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu99 -ferror-limit 19 -fgnuc-version=4.2.1 -fgnu89-inline -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-opt-analyze-headers -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-08-08-045408-589-1 -x c ../libnvme/test/test-fabrics.c

../libnvme/test/test-fabrics.c

→

1// SPDX-License-Identifier: LGPL-2.1-or-later
2/**
* This file is part of libnvme.
* Copyright (c) 2024 Dell Inc.
*
* Authors: Martin Belanger <Martin.Belanger@dell.com>
*
* Unit tests for static helper functions in src/nvme/fabrics.c.
*
* Accessing static functions requires including the source file directly
* because static functions are not exported from the shared library.
* Defining 'static' to nothing makes them visible in this translation
* unit.  The duplicate non-static symbols that fabrics.c also defines
* (e.g. trtypes[], arg_str()) are harmless: GNU ld does not report
* multiple-definition errors between a .o file and a shared library,
* and at run time the main-executable definition takes precedence.
*/
18#define static	/* expose static functions for unit testing */
19#include "../src/nvme/fabrics.c"

21#include <stdlib.h>

23/* -------------------------------------------------------------------------
* Test infrastructure
* -------------------------------------------------------------------------
*/
27static int test_rc;

29#define PASS"[PASS]\n" "[PASS]\n"
30#define FAIL"[FAIL]\n" "[FAIL]\n"

32#define CHECK(cond, fmt, ...)do { if (cond) { printf("  " fmt " " "[PASS]\n", ...); } else
 { printf("  " fmt " " "[FAIL]\n", ...); test_rc = 1; } } while
 (0)						\
do {								\
if (cond) {						\
	printf("  " fmt " " PASS"[PASS]\n", ##__VA_ARGS__);	\
} else {						\
	printf("  " fmt " " FAIL"[FAIL]\n", ##__VA_ARGS__);	\
	test_rc = EXIT_FAILURE1;				\
}							\
} while (0)

42/* -------------------------------------------------------------------------
* strchomp — strip trailing spaces
* -------------------------------------------------------------------------
*/
46static bool_Bool test_strchomp(void)
47{
bool_Bool pass = true1;
char s[32];

printf("\ntest_strchomp:\n");

strncpy(s, "hello   ", sizeof(s));
strchomp(s, 8);
pass = !strcmp(s, "hello");
CHECK(pass, "trailing spaces removed: \"%s\"", s)do { if (pass) { printf("  " "trailing spaces removed: \"%s\""
 " " "[PASS]\n", s); } else { printf("  " "trailing spaces removed: \"%s\""
 " " "[FAIL]\n", s); test_rc = 1; } } while (0);

strncpy(s, "hello", sizeof(s));
strchomp(s, 5);
pass = !strcmp(s, "hello");
CHECK(pass, "no trailing spaces (unchanged): \"%s\"", s)do { if (pass) { printf("  " "no trailing spaces (unchanged): \"%s\""
 " " "[PASS]\n", s); } else { printf("  " "no trailing spaces (unchanged): \"%s\""
 " " "[FAIL]\n", s); test_rc = 1; } } while (0);

strncpy(s, "   ", sizeof(s));
strchomp(s, 3);
pass = (s[0] == '\0');
CHECK(pass, "all spaces → empty string")do { if (pass) { printf("  " "all spaces → empty string" " "
 "[PASS]\n"); } else { printf("  " "all spaces → empty string"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);

strncpy(s, "x", sizeof(s));
strchomp(s, 0);
pass = (s[0] == 'x');
CHECK(pass, "max=0 → no change")do { if (pass) { printf("  " "max=0 → no change" " " "[PASS]\n"
); } else { printf("  " "max=0 → no change" " " "[FAIL]\n")
; test_rc = 1; } } while (0);

return pass;
74}

76/* -------------------------------------------------------------------------
* hostid_from_hostnqn — extract UUID from a hostnqn string
* -------------------------------------------------------------------------
*/
80static bool_Bool test_hostid_from_hostnqn(void)
81{
const char *id;
bool_Bool pass = true1;

printf("\ntest_hostid_from_hostnqn:\n");

id = hostid_from_hostnqn(NULL((void*)0));
pass = (id == NULL((void*)0));
CHECK(pass, "NULL input → NULL")do { if (pass) { printf("  " "NULL input → NULL" " " "[PASS]\n"
); } else { printf("  " "NULL input → NULL" " " "[FAIL]\n")
; test_rc = 1; } } while (0);

id = hostid_from_hostnqn("nqn.2014-08.org.nvmexpress:no-uuid-here");
pass = (id == NULL((void*)0));
CHECK(pass, "no uuid: tag → NULL")do { if (pass) { printf("  " "no uuid: tag → NULL" " " "[PASS]\n"
); } else { printf("  " "no uuid: tag → NULL" " " "[FAIL]\n"
); test_rc = 1; } } while (0);

id = hostid_from_hostnqn(
"nqn.2014-08.org.nvmexpress:uuid:9ba1651a-ed36-11f0-9858-6c1ff71ba506");
pass = (id && !strcmp(id, "9ba1651a-ed36-11f0-9858-6c1ff71ba506"));
CHECK(pass, "valid NQN → UUID \"%s\"", id ? id : "(null)")do { if (pass) { printf("  " "valid NQN → UUID \"%s\"" " " "[PASS]\n"
, id ? id : "(null)"); } else { printf("  " "valid NQN → UUID \"%s\""
 " " "[FAIL]\n", id ? id : "(null)"); test_rc = 1; } } while (
0);

id = hostid_from_hostnqn("prefix:uuid:abc-123");
pass = (id && !strcmp(id, "abc-123"));
CHECK(pass, "arbitrary prefix → \"abc-123\"")do { if (pass) { printf("  " "arbitrary prefix → \"abc-123\""
 " " "[PASS]\n"); } else { printf("  " "arbitrary prefix → \"abc-123\""
 " " "[FAIL]\n"); test_rc = 1; } } while (0);

return pass;
105}

107/* -------------------------------------------------------------------------
* __add_bool_argument — append a boolean flag to an argument string
* -------------------------------------------------------------------------
*/
111static bool_Bool test_add_bool_argument(void)
112{
char *argstr;
bool_Bool pass = true1;
int ret;

printf("\ntest___add_bool_argument:\n");

argstr = strdup("start");

ret = __add_bool_argument(&argstr, "flag", false0);
pass = (ret == 0 && !strcmp(argstr, "start"));
CHECK(pass, "arg=false → no change: \"%s\"", argstr)do { if (pass) { printf("  " "arg=false → no change: \"%s\""
 " " "[PASS]\n", argstr); } else { printf("  " "arg=false → no change: \"%s\""
 " " "[FAIL]\n", argstr); test_rc = 1; } } while (0);

ret = __add_bool_argument(&argstr, "flag", true1);
pass = (ret == 0 && !strcmp(argstr, "start,flag"));
CHECK(pass, "arg=true → appended: \"%s\"", argstr)do { if (pass) { printf("  " "arg=true → appended: \"%s\"" " "
 "[PASS]\n", argstr); } else { printf("  " "arg=true → appended: \"%s\""
 " " "[FAIL]\n", argstr); test_rc = 1; } } while (0);

free(argstr);
return pass;
131}

133/* -------------------------------------------------------------------------
* __add_hex_argument — append a hex-formatted integer argument
* -------------------------------------------------------------------------
*/
137static bool_Bool test_add_hex_argument(void)
138{
char *argstr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest___add_hex_argument:\n");

argstr = strdup("s");

ret = __add_hex_argument(&argstr, "v", -1, false0);
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "arg<0 → no change")do { if (p) { printf("  " "arg<0 → no change" " " "[PASS]\n"
); } else { printf("  " "arg<0 → no change" " " "[FAIL]\n"
); test_rc = 1; } } while (0);
pass &= p;

ret = __add_hex_argument(&argstr, "v", 0, false0);
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "arg=0 allow_zero=false → no change")do { if (p) { printf("  " "arg=0 allow_zero=false → no change"
 " " "[PASS]\n"); } else { printf("  " "arg=0 allow_zero=false → no change"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = __add_hex_argument(&argstr, "v", 0, true1);
p = (ret == 0 && !strcmp(argstr, "s,v=0x00000000"));
CHECK(p, "arg=0 allow_zero=true → \"%s\"", argstr)do { if (p) { printf("  " "arg=0 allow_zero=true → \"%s\"" " "
 "[PASS]\n", argstr); } else { printf("  " "arg=0 allow_zero=true → \"%s\""
 " " "[FAIL]\n", argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
argstr = strdup("s");
ret = __add_hex_argument(&argstr, "key", 0x1234abcd, false0);
p = (ret == 0 && !strcmp(argstr, "s,key=0x1234abcd"));
CHECK(p, "arg=0x1234abcd → \"%s\"", argstr)do { if (p) { printf("  " "arg=0x1234abcd → \"%s\"" " " "[PASS]\n"
, argstr); } else { printf("  " "arg=0x1234abcd → \"%s\"" " "
 "[FAIL]\n", argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
return pass;
171}

173/* -------------------------------------------------------------------------
* __add_int_argument — append a decimal integer argument
* -------------------------------------------------------------------------
*/
177static bool_Bool test_add_int_argument(void)
178{
char *argstr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest___add_int_argument:\n");

argstr = strdup("s");

ret = __add_int_argument(&argstr, "n", -1, false0);
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "arg<0 → no change")do { if (p) { printf("  " "arg<0 → no change" " " "[PASS]\n"
); } else { printf("  " "arg<0 → no change" " " "[FAIL]\n"
); test_rc = 1; } } while (0);
pass &= p;

ret = __add_int_argument(&argstr, "n", 0, false0);
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "arg=0 allow_zero=false → no change")do { if (p) { printf("  " "arg=0 allow_zero=false → no change"
 " " "[PASS]\n"); } else { printf("  " "arg=0 allow_zero=false → no change"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = __add_int_argument(&argstr, "n", 0, true1);
p = (ret == 0 && !strcmp(argstr, "s,n=0"));
CHECK(p, "arg=0 allow_zero=true → \"%s\"", argstr)do { if (p) { printf("  " "arg=0 allow_zero=true → \"%s\"" " "
 "[PASS]\n", argstr); } else { printf("  " "arg=0 allow_zero=true → \"%s\""
 " " "[FAIL]\n", argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
argstr = strdup("s");
ret = __add_int_argument(&argstr, "n", 42, false0);
p = (ret == 0 && !strcmp(argstr, "s,n=42"));
CHECK(p, "arg=42 → \"%s\"", argstr)do { if (p) { printf("  " "arg=42 → \"%s\"" " " "[PASS]\n",
 argstr); } else { printf("  " "arg=42 → \"%s\"" " " "[FAIL]\n"
, argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
return pass;
211}

213/* -------------------------------------------------------------------------
* __add_int_or_minus_one_argument — like _int but also allows -1
* -------------------------------------------------------------------------
*/
217static bool_Bool test_add_int_or_minus_one_argument(void)
218{
char *argstr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest___add_int_or_minus_one_argument:\n");

argstr = strdup("s");

ret = __add_int_or_minus_one_argument(&argstr, "n", -2);
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "arg=-2 → no change")do { if (p) { printf("  " "arg=-2 → no change" " " "[PASS]\n"
); } else { printf("  " "arg=-2 → no change" " " "[FAIL]\n"
); test_rc = 1; } } while (0);
pass &= p;

ret = __add_int_or_minus_one_argument(&argstr, "n", -1);
p = (ret == 0 && !strcmp(argstr, "s,n=-1"));
CHECK(p, "arg=-1 → \"%s\"", argstr)do { if (p) { printf("  " "arg=-1 → \"%s\"" " " "[PASS]\n",
 argstr); } else { printf("  " "arg=-1 → \"%s\"" " " "[FAIL]\n"
, argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
argstr = strdup("s");
ret = __add_int_or_minus_one_argument(&argstr, "n", 0);
p = (ret == 0 && !strcmp(argstr, "s,n=0"));
CHECK(p, "arg=0 → \"%s\"", argstr)do { if (p) { printf("  " "arg=0 → \"%s\"" " " "[PASS]\n", argstr
); } else { printf("  " "arg=0 → \"%s\"" " " "[FAIL]\n", argstr
); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
argstr = strdup("s");
ret = __add_int_or_minus_one_argument(&argstr, "n", 7);
p = (ret == 0 && !strcmp(argstr, "s,n=7"));
CHECK(p, "arg=7 → \"%s\"", argstr)do { if (p) { printf("  " "arg=7 → \"%s\"" " " "[PASS]\n", argstr
); } else { printf("  " "arg=7 → \"%s\"" " " "[FAIL]\n", argstr
); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
return pass;
253}

255/* -------------------------------------------------------------------------
* __add_argument — append a string argument; skip NULL/"none"/empty
* -------------------------------------------------------------------------
*/
259static bool_Bool test_add_argument(void)
260{
char *argstr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest___add_argument:\n");

argstr = strdup("s");

ret = __add_argument(&argstr, "a", NULL((void*)0));
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "NULL → no change")do { if (p) { printf("  " "NULL → no change" " " "[PASS]\n"
); } else { printf("  " "NULL → no change" " " "[FAIL]\n");
 test_rc = 1; } } while (0);
pass &= p;

ret = __add_argument(&argstr, "a", "");
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "empty string → no change")do { if (p) { printf("  " "empty string → no change" " " "[PASS]\n"
); } else { printf("  " "empty string → no change" " " "[FAIL]\n"
); test_rc = 1; } } while (0);
pass &= p;

ret = __add_argument(&argstr, "a", "none");
p = (ret == 0 && !strcmp(argstr, "s"));
CHECK(p, "\"none\" → no change")do { if (p) { printf("  " "\"none\" → no change" " " "[PASS]\n"
); } else { printf("  " "\"none\" → no change" " " "[FAIL]\n"
); test_rc = 1; } } while (0);
pass &= p;

ret = __add_argument(&argstr, "transport", "tcp");
p = (ret == 0 && !strcmp(argstr, "s,transport=tcp"));
CHECK(p, "\"tcp\" → \"%s\"", argstr)do { if (p) { printf("  " "\"tcp\" → \"%s\"" " " "[PASS]\n"
, argstr); } else { printf("  " "\"tcp\" → \"%s\"" " " "[FAIL]\n"
, argstr); test_rc = 1; } } while (0);
pass &= p;

free(argstr);
return pass;
291}

293/* -------------------------------------------------------------------------
* inet4_pton — parse an IPv4 address string into a sockaddr_storage
* -------------------------------------------------------------------------
*/
297static bool_Bool test_inet4_pton(void)
298{
struct sockaddr_storage addr;
struct sockaddr_in *a4 = (struct sockaddr_in *)&addr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest_inet4_pton:\n");

memset(&addr, 0, sizeof(addr));
ret = inet4_pton("192.168.1.1", 4420, &addr);
p = (ret == 0 &&
    a4->sin_family == AF_INET2 &&
    ntohs(a4->sin_port)__bswap_16 (a4->sin_port) == 4420);
CHECK(p, "\"192.168.1.1\":4420 → ret=%d family=%d port=%d",do { if (p) { printf("  " "\"192.168.1.1\":4420 → ret=%d family=%d port=%d"
 " " "[PASS]\n", ret, a4->sin_family, __bswap_16 (a4->sin_port
)); } else { printf("  " "\"192.168.1.1\":4420 → ret=%d family=%d port=%d"
 " " "[FAIL]\n", ret, a4->sin_family, __bswap_16 (a4->sin_port
)); test_rc = 1; } } while (0)
    ret, a4->sin_family, ntohs(a4->sin_port))do { if (p) { printf("  " "\"192.168.1.1\":4420 → ret=%d family=%d port=%d"
 " " "[PASS]\n", ret, a4->sin_family, __bswap_16 (a4->sin_port
)); } else { printf("  " "\"192.168.1.1\":4420 → ret=%d family=%d port=%d"
 " " "[FAIL]\n", ret, a4->sin_family, __bswap_16 (a4->sin_port
)); test_rc = 1; } } while (0);
pass &= p;

memset(&addr, 0, sizeof(addr));
ret = inet4_pton("0.0.0.0", 0, &addr);
p = (ret == 0 && a4->sin_family == AF_INET2);
CHECK(p, "\"0.0.0.0\":0 → ret=%d", ret)do { if (p) { printf("  " "\"0.0.0.0\":0 → ret=%d" " " "[PASS]\n"
, ret); } else { printf("  " "\"0.0.0.0\":0 → ret=%d" " " "[FAIL]\n"
, ret); test_rc = 1; } } while (0);
pass &= p;

ret = inet4_pton("not-an-ip", 4420, &addr);
p = (ret == -EINVAL22);
CHECK(p, "invalid string → -EINVAL (got %d)", ret)do { if (p) { printf("  " "invalid string → -EINVAL (got %d)"
 " " "[PASS]\n", ret); } else { printf("  " "invalid string → -EINVAL (got %d)"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

ret = inet4_pton("999.999.999.999", 4420, &addr);
p = (ret == -EINVAL22);
CHECK(p, "out-of-range octets → -EINVAL (got %d)", ret)do { if (p) { printf("  " "out-of-range octets → -EINVAL (got %d)"
 " " "[PASS]\n", ret); } else { printf("  " "out-of-range octets → -EINVAL (got %d)"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* string longer than INET_ADDRSTRLEN */
ret = inet4_pton(
"1234567890.1234567890.1234567890.1234567890",
0, &addr);
p = (ret == -EINVAL22);
CHECK(p, "too-long string → -EINVAL (got %d)", ret)do { if (p) { printf("  " "too-long string → -EINVAL (got %d)"
 " " "[PASS]\n", ret); } else { printf("  " "too-long string → -EINVAL (got %d)"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

return pass;
340}

342/* -------------------------------------------------------------------------
* inet_pton_with_scope — parse IPv4 or IPv6 (with optional %iface scope)
* -------------------------------------------------------------------------
*/
346static bool_Bool test_inet_pton_with_scope(struct libnvme_global_ctx *ctx)
347{
struct sockaddr_storage addr;
bool_Bool pass = true1, p;
int ret;

printf("\ntest_inet_pton_with_scope:\n");

/* IPv4 via AF_INET */
ret = inet_pton_with_scope(ctx, AF_INET2, "10.0.0.1", "4420", &addr);
p = (ret == 0);
CHECK(p, "AF_INET \"10.0.0.1\":4420 → ret=%d", ret)do { if (p) { printf("  " "AF_INET \"10.0.0.1\":4420 → ret=%d"
 " " "[PASS]\n", ret); } else { printf("  " "AF_INET \"10.0.0.1\":4420 → ret=%d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* IPv4 rejected when asking for AF_INET6 */
ret = inet_pton_with_scope(ctx, AF_INET610, "10.0.0.1", "4420", &addr);
p = (ret != 0);
CHECK(p, "AF_INET6 rejects IPv4 → ret=%d (non-zero expected)", ret)do { if (p) { printf("  " "AF_INET6 rejects IPv4 → ret=%d (non-zero expected)"
 " " "[PASS]\n", ret); } else { printf("  " "AF_INET6 rejects IPv4 → ret=%d (non-zero expected)"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* Plain IPv6 via AF_INET6 */
ret = inet_pton_with_scope(ctx, AF_INET610, "2001:db8::1", "4420", &addr);
p = (ret == 0);
CHECK(p, "AF_INET6 \"2001:db8::1\" → ret=%d", ret)do { if (p) { printf("  " "AF_INET6 \"2001:db8::1\" → ret=%d"
 " " "[PASS]\n", ret); } else { printf("  " "AF_INET6 \"2001:db8::1\" → ret=%d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* Plain IPv6 via AF_UNSPEC */
ret = inet_pton_with_scope(ctx, AF_UNSPEC0, "fe80::1", "4420", &addr);
p = (ret == 0);
CHECK(p, "AF_UNSPEC \"fe80::1\" → ret=%d", ret)do { if (p) { printf("  " "AF_UNSPEC \"fe80::1\" → ret=%d" " "
 "[PASS]\n", ret); } else { printf("  " "AF_UNSPEC \"fe80::1\" → ret=%d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* Scoped link-local via lo (always present) */
ret = inet_pton_with_scope(ctx, AF_UNSPEC0, "fe80::1%lo", "4420", &addr);
p = (ret == 0);
CHECK(p, "AF_UNSPEC \"fe80::1%%lo\" (scoped): ret=%d", ret)do { if (p) { printf("  " "AF_UNSPEC \"fe80::1%%lo\" (scoped): ret=%d"
 " " "[PASS]\n", ret); } else { printf("  " "AF_UNSPEC \"fe80::1%%lo\" (scoped): ret=%d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* Scoped address for non-link-local: scope is ignored by inet6_pton */
ret = inet_pton_with_scope(ctx, AF_UNSPEC0, "2001:db8::1", NULL((void*)0), &addr);
p = (ret == 0);
CHECK(p, "AF_UNSPEC \"2001:db8::1\" trsvcid=NULL → ret=%d", ret)do { if (p) { printf("  " "AF_UNSPEC \"2001:db8::1\" trsvcid=NULL → ret=%d"
 " " "[PASS]\n", ret); } else { printf("  " "AF_UNSPEC \"2001:db8::1\" trsvcid=NULL → ret=%d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

/* Port overflow */
ret = inet_pton_with_scope(ctx, AF_INET2, "10.0.0.1", "99999", &addr);
p = (ret == -ERANGE34);
CHECK(p, "port overflow (99999) → -ERANGE (got %d)", ret)do { if (p) { printf("  " "port overflow (99999) → -ERANGE (got %d)"
 " " "[PASS]\n", ret); } else { printf("  " "port overflow (99999) → -ERANGE (got %d)"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

return pass;
397}

399/* -------------------------------------------------------------------------
* traddr_is_hostname — decide whether traddr is a hostname (not an IP)
*
* This is the key regression test: scoped IPv6 addresses like
* "fe80::1%eth0" must NOT be classified as hostnames.  Before this was
* caught, a proposed change replaced inet_pton_with_scope() with plain
* inet_pton(), which fails on scoped addresses and mis-classifies them
* as hostnames.
* -------------------------------------------------------------------------
*/
409static bool_Bool test_traddr_is_hostname(struct libnvme_global_ctx *ctx)
410{
bool_Bool pass = true1, p;

printf("\ntest_traddr_is_hostname:\n");

415#define TRADDR_TEST(transport_, traddr_, expected, label)		\
do {								\
p = (traddr_is_hostname(ctx, transport_,		\
			traddr_) == (expected));	\
CHECK(p, "%-38s → %s", label,				\do { if (p) { printf("  " "%-38s → %s" " " "[PASS]\n", label
, expected ? "hostname" : "IP"); } else { printf("  " "%-38s → %s"
 " " "[FAIL]\n", label, expected ? "hostname" : "IP"); test_rc
 = 1; } } while (0)
      expected ? "hostname" : "IP")do { if (p) { printf("  " "%-38s → %s" " " "[PASS]\n", label
, expected ? "hostname" : "IP"); } else { printf("  " "%-38s → %s"
 " " "[FAIL]\n", label, expected ? "hostname" : "IP"); test_rc
 = 1; } } while (0);			\
pass &= p;						\
} while (0)

/* Plain IPv4 */
TRADDR_TEST("tcp",  "192.168.1.10", false0, "IPv4 address (tcp)");
TRADDR_TEST("rdma", "192.168.1.10", false0, "IPv4 address (rdma)");

/* Plain IPv6 */
TRADDR_TEST("tcp", "fe80::1",     false0, "IPv6 link-local (no scope)");
TRADDR_TEST("tcp", "2001:db8::1", false0, "IPv6 global unicast");
TRADDR_TEST("tcp", "::1",         false0, "IPv6 loopback");

/*
* Scoped IPv6 - the regression case.
* Must be classified as an IP address, not a hostname.
* Plain inet_pton() would fail here and wrongly return true.
*/
TRADDR_TEST("tcp",  "fe80::1%lo", false0, "scoped IPv6 (lo, exists)");
TRADDR_TEST("rdma", "fe80::1%lo", false0, "scoped IPv6 (lo, rdma)");

/*
* A zone naming a nonexistent interface is still numeric; zone
* validity is the kernel's call, same as host_iface.
*/
TRADDR_TEST("tcp", "fe80::1%nonexistent0", false0,
    "scoped IPv6 (bad zone)");

/* Hostnames */
TRADDR_TEST("tcp",  "storage.example.com", true1, "FQDN hostname");
TRADDR_TEST("tcp",  "nvme-target",         true1, "short hostname");
TRADDR_TEST("rdma", "storage.example.com",
    true1, "FQDN hostname (rdma)");

/* "none" - reserved keyword, must not be treated as a hostname */
TRADDR_TEST("tcp", "none", false0, "literal \"none\"");

/* Transports where the check is skipped entirely */
TRADDR_TEST("pcie", "192.168.1.10",        false0, "IPv4 on pcie");
TRADDR_TEST("fc",   "fe80::1%lo",          false0, "scoped IPv6 (fc)");
TRADDR_TEST("loop", "storage.example.com", false0, "hostname on loop");

/* NULL traddr */
TRADDR_TEST("tcp", NULL((void*)0), false0, "NULL traddr");

465#undef TRADDR_TEST

return pass;
468}

470/* -------------------------------------------------------------------------
* nvmf_sanitize_addrs — reject hostnames, canonicalize numeric addresses
* -------------------------------------------------------------------------
*/
474static bool_Bool test_nvmf_sanitize_addrs(struct libnvme_global_ctx *ctx)
475{
struct libnvme_ctrl_params params = { .transport = "tcp" };
libnvme_ctrl_t c;
bool_Bool pass = true1, p;
int ret;

printf("\ntest_nvmf_sanitize_addrs:\n");

/*
* Creation never resolves and never rejects -- a hostname host_traddr
* is stored verbatim; rejection happens at connect (single policy
* point).
*/
params.subsysnqn = "nqn.2024-01.com.example:test";
params.traddr = "192.168.1.10";
params.host_traddr = "storage.example.com";
ret = libnvme_create_ctrl(ctx, &params, &c);
1
Value assigned to 'c'→
p = !ret && c && !strcmp(libnvme_ctrl_get_host_traddr(c),
2
←
Assuming 'ret' is 0→
3
←
Assuming pointer value is null→
4
←
Assuming 'c' is null→
	"storage.example.com");
CHECK(p, "hostname host_traddr stored verbatim at creation")do { if (p) { printf("  " "hostname host_traddr stored verbatim at creation"
 " " "[PASS]\n"); } else { printf("  " "hostname host_traddr stored verbatim at creation"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
7
←
Passing null pointer value via 2nd parameter 'c'→
8
←
Calling 'nvmf_sanitize_addrs'→
p = ret == -ENVME_CONNECT_TRADDR;
CHECK(p, "hostname host_traddr rejected at connect: %d", ret)do { if (p) { printf("  " "hostname host_traddr rejected at connect: %d"
 " " "[PASS]\n", ret); } else { printf("  " "hostname host_traddr rejected at connect: %d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

libnvme_free_ctrl(c);

/* A hostname traddr is rejected the same way. */
params.traddr = "storage.example.com";
params.host_traddr = NULL((void*)0);
ret = libnvme_create_ctrl(ctx, &params, &c);
p = !ret && c != NULL((void*)0);
CHECK(p, "ctrl created with hostname traddr")do { if (p) { printf("  " "ctrl created with hostname traddr"
 " " "[PASS]\n"); } else { printf("  " "ctrl created with hostname traddr"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
p = ret == -ENVME_CONNECT_TRADDR;
CHECK(p, "hostname traddr rejected at connect: %d", ret)do { if (p) { printf("  " "hostname traddr rejected at connect: %d"
 " " "[PASS]\n", ret); } else { printf("  " "hostname traddr rejected at connect: %d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

libnvme_free_ctrl(c);

/* An uncompressed IPv6 traddr is canonicalized. */
params.traddr = "2001:0db8:0000:0000:0000:0000:0000:0001";
ret = libnvme_create_ctrl(ctx, &params, &c);
p = !ret && c != NULL((void*)0);
CHECK(p, "ctrl created with uncompressed IPv6 traddr")do { if (p) { printf("  " "ctrl created with uncompressed IPv6 traddr"
 " " "[PASS]\n"); } else { printf("  " "ctrl created with uncompressed IPv6 traddr"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
p = !ret && !strcmp(libnvme_ctrl_get_traddr(c), "2001:db8::1");
CHECK(p, "uncompressed IPv6 traddr canonicalized: %s",do { if (p) { printf("  " "uncompressed IPv6 traddr canonicalized: %s"
 " " "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf
("  " "uncompressed IPv6 traddr canonicalized: %s" " " "[FAIL]\n"
, libnvme_ctrl_get_traddr(c)); test_rc = 1; } } while (0)
     libnvme_ctrl_get_traddr(c))do { if (p) { printf("  " "uncompressed IPv6 traddr canonicalized: %s"
 " " "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf
("  " "uncompressed IPv6 traddr canonicalized: %s" " " "[FAIL]\n"
, libnvme_ctrl_get_traddr(c)); test_rc = 1; } } while (0);
pass &= p;

libnvme_free_ctrl(c);

/*
* A scoped IPv6 traddr passes through verbatim even when the zone
* names a nonexistent interface -- zone validity is the kernel's
* call, same as host_iface.
*/
params.traddr = "fe80::1%nonexistent0";
ret = libnvme_create_ctrl(ctx, &params, &c);
p = !ret && c != NULL((void*)0);
CHECK(p, "ctrl created with bad-zone scoped IPv6 traddr")do { if (p) { printf("  " "ctrl created with bad-zone scoped IPv6 traddr"
 " " "[PASS]\n"); } else { printf("  " "ctrl created with bad-zone scoped IPv6 traddr"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
p = !ret && !strcmp(libnvme_ctrl_get_traddr(c), "fe80::1%nonexistent0");
CHECK(p, "bad-zone scoped IPv6 traddr accepted verbatim: %s",do { if (p) { printf("  " "bad-zone scoped IPv6 traddr accepted verbatim: %s"
 " " "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf
("  " "bad-zone scoped IPv6 traddr accepted verbatim: %s" " "
 "[FAIL]\n", libnvme_ctrl_get_traddr(c)); test_rc = 1; } } while
 (0)
     libnvme_ctrl_get_traddr(c))do { if (p) { printf("  " "bad-zone scoped IPv6 traddr accepted verbatim: %s"
 " " "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf
("  " "bad-zone scoped IPv6 traddr accepted verbatim: %s" " "
 "[FAIL]\n", libnvme_ctrl_get_traddr(c)); test_rc = 1; } } while
 (0);
pass &= p;

libnvme_free_ctrl(c);

/* fc: a WWN traddr is left untouched (not an IP transport). */
params.transport = "fc";
params.traddr = "nn-0x1:pn-0x2";
ret = libnvme_create_ctrl(ctx, &params, &c);
p = !ret && c != NULL((void*)0);
CHECK(p, "ctrl created with fc WWN traddr")do { if (p) { printf("  " "ctrl created with fc WWN traddr" " "
 "[PASS]\n"); } else { printf("  " "ctrl created with fc WWN traddr"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
p = !ret && !strcmp(libnvme_ctrl_get_traddr(c), "nn-0x1:pn-0x2");
CHECK(p, "fc WWN traddr left untouched: %s",do { if (p) { printf("  " "fc WWN traddr left untouched: %s" " "
 "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf("  "
 "fc WWN traddr left untouched: %s" " " "[FAIL]\n", libnvme_ctrl_get_traddr
(c)); test_rc = 1; } } while (0)
     libnvme_ctrl_get_traddr(c))do { if (p) { printf("  " "fc WWN traddr left untouched: %s" " "
 "[PASS]\n", libnvme_ctrl_get_traddr(c)); } else { printf("  "
 "fc WWN traddr left untouched: %s" " " "[FAIL]\n", libnvme_ctrl_get_traddr
(c)); test_rc = 1; } } while (0);
pass &= p;

libnvme_free_ctrl(c);

/* loop: no traddr at all -- nothing to sanitize. */
params.transport = "loop";
params.traddr = NULL((void*)0);
ret = libnvme_create_ctrl(ctx, &params, &c);
p = !ret && c != NULL((void*)0);
CHECK(p, "ctrl created for loop transport")do { if (p) { printf("  " "ctrl created for loop transport" " "
 "[PASS]\n"); } else { printf("  " "ctrl created for loop transport"
 " " "[FAIL]\n"); test_rc = 1; } } while (0);
pass &= p;

ret = nvmf_sanitize_addrs(ctx, c);
p = ret == 0;
CHECK(p, "loop transport (no traddr) sanitizes cleanly: %d", ret)do { if (p) { printf("  " "loop transport (no traddr) sanitizes cleanly: %d"
 " " "[PASS]\n", ret); } else { printf("  " "loop transport (no traddr) sanitizes cleanly: %d"
 " " "[FAIL]\n", ret); test_rc = 1; } } while (0);
pass &= p;

libnvme_free_ctrl(c);

return pass;
585}

587/* -------------------------------------------------------------------------
* unescape_uri — decode percent-encoded characters in a URI fragment
* -------------------------------------------------------------------------
*/
591static bool_Bool test_unescape_uri(void)
592{
char *out;
bool_Bool pass = true1, p;

printf("\ntest_unescape_uri:\n");

out = unescape_uri("hello%20world", -1);
p = out && !strcmp(out, "hello world");
CHECK(p, "%%20 → space: \"%s\"", out ? out : "(null)")do { if (p) { printf("  " "%%20 → space: \"%s\"" " " "[PASS]\n"
, out ? out : "(null)"); } else { printf("  " "%%20 → space: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0);
pass &= p;
free(out);

out = unescape_uri("path%2Fsegment", -1);
p = out && !strcmp(out, "path/segment");
CHECK(p, "%%2F → /: \"%s\"", out ? out : "(null)")do { if (p) { printf("  " "%%2F → /: \"%s\"" " " "[PASS]\n"
, out ? out : "(null)"); } else { printf("  " "%%2F → /: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0);
pass &= p;
free(out);

out = unescape_uri("no-escapes", -1);
p = out && !strcmp(out, "no-escapes");
CHECK(p, "no escapes → unchanged: \"%s\"", out ? out : "(null)")do { if (p) { printf("  " "no escapes → unchanged: \"%s\"" " "
 "[PASS]\n", out ? out : "(null)"); } else { printf("  " "no escapes → unchanged: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0);
pass &= p;
free(out);

/* Truncate via explicit length */
out = unescape_uri("hello%20world", 5);
p = out && !strcmp(out, "hello");
CHECK(p, "len=5 → \"%s\"", out ? out : "(null)")do { if (p) { printf("  " "len=5 → \"%s\"" " " "[PASS]\n", out
 ? out : "(null)"); } else { printf("  " "len=5 → \"%s\"" " "
 "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while (0
);
pass &= p;
free(out);

/* Invalid percent sequence — passed through verbatim */
out = unescape_uri("bad%xychars", -1);
p = out && !strcmp(out, "bad%xychars");
CHECK(p, "invalid %%xy → verbatim: \"%s\"", out ? out : "(null)")do { if (p) { printf("  " "invalid %%xy → verbatim: \"%s\""
 " " "[PASS]\n", out ? out : "(null)"); } else { printf("  " "invalid %%xy → verbatim: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0);
pass &= p;
free(out);

/* Truncated percent at end of string */
out = unescape_uri("end%2", -1);
p = out && !strcmp(out, "end%2");
CHECK(p, "truncated %% at end -> verbatim: \"%s\"",do { if (p) { printf("  " "truncated %% at end -> verbatim: \"%s\""
 " " "[PASS]\n", out ? out : "(null)"); } else { printf("  " "truncated %% at end -> verbatim: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0)
     out ? out : "(null)")do { if (p) { printf("  " "truncated %% at end -> verbatim: \"%s\""
 " " "[PASS]\n", out ? out : "(null)"); } else { printf("  " "truncated %% at end -> verbatim: \"%s\""
 " " "[FAIL]\n", out ? out : "(null)"); test_rc = 1; } } while
 (0);
pass &= p;
free(out);

return pass;
639}

641/* -------------------------------------------------------------------------
* main
* -------------------------------------------------------------------------
*/
645int main(int argc, char *argv[])
646{
struct libnvme_global_ctx *ctx;

test_rc = EXIT_SUCCESS0;

/*
* A real context is needed for functions that call libnvme_msg()
* on error paths (inet6_pton, traddr_is_hostname).  Use LOG_ERR
* so test output stays clean during normal runs.
*/
ctx = libnvme_create_global_ctx();
if (!ctx) {
fprintf(stderrstderr, "failed to create libnvme context\n");
return EXIT_FAILURE1;
}
libnvme_set_logging_level(ctx, LIBNVME_LOG_ERR, false0, false0);

test_strchomp();
test_hostid_from_hostnqn();
test_add_bool_argument();
test_add_hex_argument();
test_add_int_argument();
test_add_int_or_minus_one_argument();
test_add_argument();
test_inet4_pton();
test_inet_pton_with_scope(ctx);
test_traddr_is_hostname(ctx);
test_nvmf_sanitize_addrs(ctx);
test_unescape_uri();

libnvme_free_global_ctx(ctx);

if (test_rc == EXIT_SUCCESS0)
printf("\nAll tests passed.\n");
else
printf("\nSOME TESTS FAILED.\n");
return test_rc;
683}

←

../libnvme/test/../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 <sys/param.h>
29#include <sys/stat.h>
30#include <sys/types.h>

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

37#include <compiler-attributes.h>

39#include <libnvme.h>

41#include "cleanup.h"
42#include "cleanup-linux.h"
43#include "private.h"
44#include "private-fabrics.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}

76#define NVMF_HOSTID_SIZE37	37

78#define NVMF_HOSTNQN_FILE"/usr/local/etc" "/nvme/hostnqn"	SYSCONFDIR"/usr/local/etc" "/nvme/hostnqn"
79#define NVMF_HOSTID_FILE"/usr/local/etc" "/nvme/hostid"	SYSCONFDIR"/usr/local/etc" "/nvme/hostid"

81static int uuid_from_device_tree(char *system_uuid)
82{
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int f = -1;
ssize_t len;

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

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

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

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

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

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

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

return true1;
121}

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

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

return len;
137}

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

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

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

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

191#define PATH_DMI_PROD_UUID"/sys/class/dmi/id/product_uuid"  "/sys/class/dmi/id/product_uuid"

193/**
* uuid_from_product_uuid() - Get system UUID from product_uuid
* @system_uuid: Where to save the system UUID.
*
* Return: 0 on success, -ENXIO otherwise.
*/
199static int uuid_from_product_uuid(char *system_uuid)
200{
__cleanup_file__attribute__((cleanup(shr_cleanup_file))) FILE *stream = NULL((void*)0);

stream = fopen(PATH_DMI_PROD_UUID"/sys/class/dmi/id/product_uuid", "re");
if (!stream)
return -ENXIO6;

system_uuid[0] = '\0';

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

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

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

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

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

return 0;
229}

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

252__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostid(void)
253{
int ret;
char uuid_str[NVME_UUID_LEN_STRING37];
unsigned char uuid[NVME_UUID_LEN16];

ret = uuid_from_dmi(uuid_str);
if (ret < 0)
ret = uuid_from_device_tree(uuid_str);
if (ret < 0) {
if (libnvme_random_uuid(uuid) < 0)
	memset(uuid, 0, NVME_UUID_LEN16);
libnvme_uuid_to_string(uuid, uuid_str);
}

return strdup(uuid_str);
268}

270__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostnqn_from_hostid(char *hostid)
271{
char *hid = NULL((void*)0);
char *hostnqn;
int ret;

if (!hostid)
hostid = hid = libnvmf_generate_hostid();

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

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

285__shr_public__attribute__((visibility("default"))) char *libnvmf_generate_hostnqn(void)
286{
return libnvmf_generate_hostnqn_from_hostid(NULL((void*)0));
288}

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

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

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

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

308__shr_public__attribute__((visibility("default"))) char *libnvmf_read_hostnqn(struct libnvme_global_ctx *ctx)
309{
if (!ctx)
return NULL((void*)0);

if (ctx->hostnqn) {
if (!strcmp(ctx->hostnqn, ""))
	return NULL((void*)0);
return strdup(ctx->hostnqn);
}

return nvmf_read_file(NVMF_HOSTNQN_FILE"/usr/local/etc" "/nvme/hostnqn", NVMF_NQN_SIZE223);
320}

322__shr_public__attribute__((visibility("default"))) char *libnvmf_read_hostid(struct libnvme_global_ctx *ctx)
323{
if (!ctx)
return NULL((void*)0);

if (ctx->hostid) {
if (!strcmp(ctx->hostid, ""))
	return NULL((void*)0);
return strdup(ctx->hostid);
}

return nvmf_read_file(NVMF_HOSTID_FILE"/usr/local/etc" "/nvme/hostid", NVMF_HOSTID_SIZE37);
334}

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

if (!ctx)
return -EINVAL22;

/* command line argumments */
if (hostid_arg)
hid = strdup(hostid_arg);
if (hostnqn_arg)
hnqn = strdup(hostnqn_arg);

/* first host already resolved in ctx->hosts, if any */
h = libnvme_first_host(ctx);
if (h) {
if (!hid)
	hid = shr_xstrdup(libnvme_host_get_hostid(h));
if (!hnqn)
	hnqn = shr_xstrdup(libnvme_host_get_hostnqn(h));
}

/* /etc/nvme/hostid and/or /etc/nvme/hostnqn */
if (!hid)
hid = libnvmf_read_hostid(ctx);
if (!hnqn)
hnqn = libnvmf_read_hostnqn(ctx);

/* incomplete configuration, thus derive hostid from hostnqn */
if (!hid && hnqn)
hid = libnvme_hostid_from_hostnqn(hnqn);

/*
* fallback to use either DMI information or device-tree. If all
* fails generate one
*/
if (!hid) {
hid = libnvmf_generate_hostid();
if (!hid)
	return -ENOMEM12;

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

/* incomplete configuration, thus derive hostnqn from hostid */
if (!hnqn) {
hnqn = libnvmf_generate_hostnqn_from_hostid(hid);
if (!hnqn)
	return -ENOMEM12;
}

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

if (hostid) {
*hostid = hid;
hid = NULL((void*)0);
}
if (hostnqn) {
*hostnqn = hnqn;
hnqn = NULL((void*)0);
}

return 0;
411}

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

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

425static 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",
431};

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

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

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

449static 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",
462};

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

469static 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",
488};

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

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

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

506static 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",
512};

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

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

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

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

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

538void libnvmf_default_config(struct libnvme_fabrics_config *cfg)
539{
cfg->tos = -1;
cfg->ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO600;
542}

544__shr_public__attribute__((visibility("default"))) int libnvmf_context_create(struct libnvme_global_ctx *ctx,
bool_Bool (*decide_retry)(struct libnvmf_context *fctx, int err,
	void *user_data),
void (*connected)(struct libnvmf_context *fctx,
	struct libnvme_ctrl *c, void *user_data),
void (*already_connected)(struct libnvmf_context *fctx,
	struct libnvme_host *host, const char *subsysnqn,
	const char *transport, const char *traddr,
	const char *trsvcid, void *user_data),
void *user_data, struct libnvmf_context **fctxp)
554{
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;
573}

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

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

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

return 0;
596}



600__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_connection(
struct libnvmf_context *fctx, const char *subsysnqn,
const char *transport, const char *traddr, const char *trsvcid,
const char *host_traddr, const char *host_iface)
604{
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;
613}

615static const char *hostid_from_hostnqn(const char *hostnqn)
616{
const char *match;

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

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

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

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

if (!hostnqn)
return -EINVAL22;

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

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

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

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

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

return 0;
662}

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

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

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

680__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_crypto(struct libnvmf_context *fctx,
const char *hostkey, const char *ctrlkey,
const char *keyring, const char *tls_key,
const char *tls_key_identity)
684{
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(shr_freep))) unsigned char *raw_secret = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *encoded_key = NULL((void*)0);
int key_len = 32;

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

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

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

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

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

return 0;
726}

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

return 0;
734}

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

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

return fd;
757}

759static void write_devid_file(struct libnvmf_context *fctx, int fd,
libnvme_ctrl_t c)
761{
if (fd < 0 || !c)
return;

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

772__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_io_queues(
struct libnvmf_context *fctx, int nr_io_queues,
int nr_write_queues, int nr_poll_queues,
int queue_size, bool_Bool disable_sqflow)
776{
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;
784}

786__shr_public__attribute__((visibility("default"))) int libnvmf_context_set_reconnect_policy(
struct libnvmf_context *fctx, int ctrl_loss_tmo,
int reconnect_delay, int fast_io_fail_tmo)
789{
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;
795}

797/*
* 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.
*/
803static 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,
826};

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

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

880static int __add_bool_argument(char **argstr, char *tok, bool_Bool arg)
881{
char *nstr;

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

return 0;
893}

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

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

925static int __add_int_or_minus_one_argument(char **argstr, char *tok, int arg)
926{
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;
938}

940static int __add_argument(char **argstr, const char *tok, const char *arg)
941{
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;
953}

955static int __nvmf_supported_options(struct libnvme_global_ctx *ctx);
956#define nvmf_check_option(ctx, tok)({ !__nvmf_supported_options(ctx) && ctx->options->
tok; })					\
957({									\
!__nvmf_supported_options(ctx) && ctx->options->tok;		\
959})

961#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;
 })			\
962({									\
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;								\
975})

977#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
; })		\
978({									\
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;								\
992})

994#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
; })		\
995({									\
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;								\
1009})

1011#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
; })		\
1012({									\
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;								\
1025})

1027#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; })				\
1028({									\
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;								\
1041})

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

1060static int inet6_pton(struct libnvme_global_ctx *ctx, const char *src, uint16_t port,
      struct sockaddr_storage *addr)
1062{
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(shr_freep))) char *tmp = strdup(src);
if (!tmp) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "cannot copy: %s\n", src)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "cannot copy: %s\n"
, src);
return -ENOMEM12;
}

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

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

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

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

1099/**
* 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.
*/
1109static int inet_pton_with_scope(struct libnvme_global_ctx *ctx, int af,
		const char *src, const char * trsvcid,
		struct sockaddr_storage *addr)
1112{
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;
1145}

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

return !libnvmf_traddr_is_numeric(traddr);
1158}

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

if (traddr_is_hostname(ctx, c->transport, c->traddr)) {
9
←
Access to field 'transport' results in a dereference of a null pointer (loaded from variable 'c')
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr)
	"traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr)
	c->traddr)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "traddr '%s' is not a numeric address; hostname resolution is the caller's responsibility\n"
, c->traddr);
return -ENVME_CONNECT_TRADDR;
}

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

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

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

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

libnvmf_tid_free(tid);

return 0;
1218}

1220static int build_options(libnvme_host_t h, libnvme_ctrl_t c, char **argstr)
1221{
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)
libnvme_ctrl_get_dhchap_host_key(c, &hostkey, NULL((void*)0));

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

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

if (c->cfg.concat && !hostkey) {
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "required argument [--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 = __libnvmf_import_keys_from_config(h, c,
	&keyring_id, &key_id);
if (ret)
	return ret;

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

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

return 0;
1349}

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

1357static int __nvmf_supported_options(struct libnvme_global_ctx *ctx)
1358{
char buf[0x1000], *options, *p, *v;
__cleanup_fd__attribute__((cleanup(shr_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;
1443}

1445/* Parse the kernel instance number out of a ctrl's name ("nvme3" -> 3). */
1446static int ctrl_instance(libnvme_ctrl_t c)
1447{
int instance = -1;
const char *name;

if (!c)
return instance;

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

return instance;
1459}

1461/*
* 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.
*/
1466static void registry_update_on_connect(struct libnvme_global_ctx *ctx,
		       int instance)
1468{
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));
1480}

1482static int __nvmf_add_ctrl(struct libnvme_global_ctx *ctx, const char *argstr)
1483{
__cleanup_fd__attribute__((cleanup(shr_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;
1546}


1549__shr_public__attribute__((visibility("default"))) int libnvmf_create_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_ctrl_t *cp)
1551{
return libnvme_create_ctrl(ctx, &fctx->ctrl_params, cp);
1553}

1555__shr_public__attribute__((visibility("default"))) int libnvmf_add_ctrl(libnvme_host_t h, libnvme_ctrl_t c)
1556{
libnvme_subsystem_t s;
__cleanup_free__attribute__((cleanup(shr_freep))) char *argstr = NULL((void*)0);
int ret;

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

/* carry over config from an existing ctrl on the same subsystem */
s = libnvme_lookup_subsystem(h, NULL((void*)0), libnvme_ctrl_get_subsysnqn(c));
if (s) {
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_host_iface(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.
	 */
	if (libnvme_ctrl_get_dhchap_host_key(fc, &key,
					      NULL((void*)0)) == 0)
		libnvme_ctrl_set_dhchap_host_key(c, key);
	if (libnvme_ctrl_get_dhchap_ctrl_key(fc, &key,
					      NULL((void*)0)) == 0)
		libnvme_ctrl_set_dhchap_ctrl_key(c, key);
	if (libnvme_ctrl_get_keyring(fc, &key, NULL((void*)0)) == 0)
		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);
ret = nvmf_sanitize_addrs(h->ctx, c);
if (ret)
return ret;

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

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

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

1625__shr_public__attribute__((visibility("default"))) int libnvmf_connect_ctrl(libnvme_ctrl_t c)
1626{
__cleanup_free__attribute__((cleanup(shr_freep))) char *argstr = NULL((void*)0);
int ret;

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

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

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

return 0;
1643}

1645__shr_public__attribute__((visibility("default"))) int libnvmf_disconnect_ctrl(libnvme_ctrl_t c)
1646{
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;
1661}

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

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

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

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

return excluded;
1725}

1727static 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)
1731{
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);

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

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

1853/*
* 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.
*/
1858#define DISCOVERY_HEADER_LEN20 20

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

1958out_free_log:
libnvme_free(log);
return err;
1961}

1963static void sanitize_discovery_log_entry(struct libnvme_global_ctx *ctx,
struct nvmf_disc_log_entry *e)
1965{
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, ',')_Generic (0 ? (e->traddr) : (void *) 1, const void *: (const
 char *) (strchr (e->traddr, ',')), default: strchr (e->
traddr, ','));

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

1984__shr_public__attribute__((visibility("default"))) int libnvmf_get_discovery_log(libnvme_ctrl_t ctrl,
		    const struct libnvmf_discovery_args *args,
		    struct nvmf_discovery_log **logp)
1987{
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;
2007}


2010/**
* 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
*/
2020static __u32 nvmf_get_tel(const char *hostsymname)
2021{
__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;
2034}

2036/**
* 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.
*/
2048static 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)
2051{
__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);
2088}

2090/**
* 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
*/
2112static 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)
2115{
struct libnvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) struct nvmf_dim_data *dim = NULL((void*)0);
struct libnvme_transport_handle *hdl = libnvme_ctrl_get_transport_handle(c);
struct libnvme_passthru_cmd cmd;
struct nvmf_ext_die  *die;
__u32 tdl;
__u32 tel;
int ret;

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

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

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

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

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

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

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

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

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

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

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

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

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

2197/**
* 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.
*/
2211static __u8 nvme_get_adrfam(libnvme_ctrl_t c)
2212{
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;
2223}

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

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

2238/**
* 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.
*/
2246static int nvme_fetch_cntrltype_dctype_from_id(libnvme_ctrl_t c)
2247{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ctrl *id = NULL((void*)0);
const char *val;
int ret;

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

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

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

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

2277__shr_public__attribute__((visibility("default"))) bool_Bool libnvmf_is_registration_supported(libnvme_ctrl_t c)
2278{
const char *cntrltype, *dctype;

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

libnvme_ctrl_get_dctype(c, &dctype, NULL((void*)0));
return !strcmp(dctype, "ddc") || !strcmp(dctype, "cdc");
2288}

2290__shr_public__attribute__((visibility("default"))) int libnvmf_register_ctrl(
libnvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
2292{
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);
2302}

2304#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'))
2307#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))

2310/* returns newly allocated string */
2311static char *unescape_uri(const char *str, int len)
2312{
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;
2330}

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

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

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

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

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

/* split userinfo */
host = strrchr(authority, '@')_Generic (0 ? (authority) : (void *) 1, const void *: (const char
 *) (strrchr (authority, '@')), default: 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, '#')_Generic (0 ? (path) : (void *) 1, const void *: (const char *
) (strrchr (path, '#')), default: strrchr (path, '#'));
if (e) {
	uri->fragment = unescape_uri(e + 1, 0);
	*e = '\0';
}
/* separate the query string */
e = strrchr(path, '?')_Generic (0 ? (path) : (void *) 1, const void *: (const char *
) (strrchr (path, '?')), default: strrchr (path, '?'));
if (e) {
	uri->query = unescape_uri(e + 1, 0);
	*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;
2424}

2426__shr_public__attribute__((visibility("default"))) void libnvmf_uri_free(struct libnvmf_uri *uri)
2427{
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);
2442}

2444static libnvme_ctrl_t lookup_ctrl(libnvme_host_t h, struct libnvmf_context *fctx)
2445{
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);
2456}

2458__shr_public__attribute__((visibility("default"))) int libnvmf_get_owner_from_tid(struct libnvme_global_ctx *ctx,
const struct libnvmf_tid *tid, char **owner)
2460{
struct libnvme_ctrl_params params = { 0 };
libnvme_subsystem_t s;
libnvme_host_t h;
libnvme_ctrl_t c = NULL((void*)0);
int ret;

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

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

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

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

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

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

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

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

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

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

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

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

return ret;
2531}

2533static int setup_connection(struct libnvmf_context *fctx, struct libnvme_host *h,
bool_Bool discovery)
2535{
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;
2545}


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

/* Set kato to NVMF_DEF_DISC_TMO for persistent controllers */
if (fctx->persistent == LIBNVMF_TRISTATE_TRUE &&
   !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 != LIBNVMF_TRISTATE_TRUE &&
 (fctx->ctrl_params.cfg.keep_alive_tmo > 0))
fctx->ctrl_params.cfg.keep_alive_tmo = 0;

return tmo;
2563}

2565static 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)
2568{
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);
}
2591}

2593static bool_Bool dc_should_connect(struct libnvmf_context *fctx,
struct nvmf_disc_log_entry *e, bool_Bool *pdisconnect)
2595{
bool_Bool disconnect;
__u16 eflags;

if (e->subtype == NVME_NQN_NVME) {
*pdisconnect = false0;
return fctx->connect;
}

eflags = le16_to_cpu(e->eflags);

/* Discovery controller returns duplicate information. */
if (eflags & NVMF_DISC_EFLAGS_DUPRETINFO)
return false0;

if (!strcmp(e->subnqn, NVME_DISC_SUBSYS_NAME"nqn.2014-08.org.nvmexpress.discovery")) {
/*
 * Implicit persistent discovery controller.
 * Keep it only if persistence is enabled.
 */
disconnect = fctx->persistent != LIBNVMF_TRISTATE_TRUE;
} else {
/*
 * Explicit persistent discovery controller.
 * Keep it only if EPCSD is supported and enabled.
 */
disconnect = !(eflags & NVMF_DISC_EFLAGS_EPCSD) ||
	     fctx->epcsd == LIBNVMF_TRISTATE_FALSE;
}

*pdisconnect = disconnect;
return true1;
2627}

2629static int _nvmf_discover(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_ctrl *c)
2631{
__cleanup_free__attribute__((cleanup(shr_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) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(err))
	"failed to get discovery log: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(err))
	libnvme_strerror(err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to get discovery log: %s\n"
, libnvme_strerror(err));
return err;
}

numrec = le64_to_cpu(log->numrec);

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

for (int i = 0; i < numrec; i++) {
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 };
struct libnvmf_context nfctx = *fctx;

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;

/* 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 (!dc_should_connect(&nfctx, e, &disconnect))
	continue;

err = nvmf_connect_disc_entry(h, e, &nfctx, &discover, &child);

if (child) {
	if (discover) {
		set_discovery_kato(&nfctx);
		_nvmf_discover(ctx, &nfctx, child);
	}

	if (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;
2707}

2709__shr_public__attribute__((visibility("default"))) const char *libnvmf_get_default_trsvcid(const char *transport,
bool_Bool discovery_ctrl)
2711{
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);
2726}

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

2733retry:
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;
2741}

2743static int __create_discovery_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, libnvme_host_t h,
struct libnvme_ctrl **ctrl)
2746{
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;
2775}

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

2838#define NBFT_SYSFS_FILENAME"NBFT*"	"NBFT*"

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

2845__shr_public__attribute__((visibility("default"))) int libnvmf_nbft_read_files(
struct libnvme_global_ctx *ctx, char *path,
struct nbft_file_entry **head)
2848{
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;
2883}

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

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

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

head = next;
}
2899}

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

2927static 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)
2931{
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;

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

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

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

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

ret = libnvmf_add_ctrl(h, c);

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

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

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

return 0;
2993}

2995static int nbft_discovery(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnbft_discovery *dd,
struct libnvme_host *h, struct libnvme_ctrl *c)
2998{
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;
3089}

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

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

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

3161__shr_public__attribute__((visibility("default"))) int libnvmf_discover_nbft(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
3163{
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;

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

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

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

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

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

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

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

/* Subsystem Namespace Descriptor List */
for (ss = entry->nbft->subsystem_ns_list; ss && *ss; ss++)
	for (i = 0; i < (*ss)->num_hfis; i++) {
		struct libnvmf_context nfctx = *fctx;

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

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

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

		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(shr_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;

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

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

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

	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), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index)
			"Discovery Descriptor %d: could not find host interface for HFI %d\n",__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index)
			(*dd)->index, hfi->index)__libnvme_msg(ctx, LIBNVME_LOG_INFO, ((void*)0), "Discovery Descriptor %d: could not find host interface for HFI %d\n"
, (*dd)->index, hfi->index);

	/* 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;
	}
}
}
3415out_free:
libnvmf_nbft_free(ctx, entry);
return ret;
3418}

3420static struct libnvme_ctrl *discover_lookup_ctrl_by_device(
struct libnvme_global_ctx *ctx, struct libnvmf_context *fctx)
3422{
struct libnvme_ctrl *c;
int err;

err = libnvme_scan_ctrl(ctx, fctx->device, &c);
if (err) {
/*
 * 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 == LIBNVMF_TRISTATE_TRUE
 ? ", 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 == LIBNVMF_TRISTATE_TRUE
 ? ", ignoring --persistent" : "")
	fctx->persistent == LIBNVMF_TRISTATE_TRUE ?__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found%s\n"
, fctx->device, fctx->persistent == LIBNVMF_TRISTATE_TRUE
 ? ", ignoring --persistent" : "")
		", ignoring --persistent" : "")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "ctrl device %s not found%s\n"
, fctx->device, fctx->persistent == LIBNVMF_TRISTATE_TRUE
 ? ", ignoring --persistent" : "");

fctx->persistent = LIBNVMF_TRISTATE_FALSE;

return NULL((void*)0);
}

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

fctx->persistent = LIBNVMF_TRISTATE_FALSE;

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

/*
* If the controller device is found it must be persistent, and
* shouldn't be disconnected on exit.
*/
fctx->persistent = LIBNVMF_TRISTATE_TRUE;

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

return c;
3484}

3486static int discover_lookup_ctrl(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx, struct libnvme_host *h,
struct libnvme_ctrl **ctrl)
3489{
struct libnvme_ctrl *c = NULL((void*)0);
int err;

if (fctx->device)
c = discover_lookup_ctrl_by_device(ctx, fctx);

if (!c) {
c = lookup_ctrl(h, fctx);
if (c) {
	/*
	 * Do not disconnect after use, because it was not
	 * created by us.
	 */
	fctx->persistent = LIBNVMF_TRISTATE_TRUE;
}
}

if (!c)
return 0;

if (!libnvme_ctrl_get_transport_handle(c)) {
/*
 * When we found an existing controller it might not have a
 * device handle yet
 */
err = libnvme_open(ctx, c->name, &c->hdl);
if (err) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open %s\n"
, c->name)
		"failed to open %s\n", c->name)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to open %s\n"
, c->name);

	return err;
}
}

*ctrl = c;
return 0;
3526}

3528__shr_public__attribute__((visibility("default"))) int libnvmf_discover(struct libnvme_global_ctx *ctx,
struct libnvmf_context *fctx)
3530{
struct libnvme_ctrl *c = NULL((void*)0);
struct libnvme_host *h;
int err;

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

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

if (!fctx->force) {
/*
 * When --force is used, always create a controller, otherwise
 * try to lookup an already existing controller first.
 */
err = discover_lookup_ctrl(ctx, fctx, h, &c);
if (err) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to lookup controller, error %s\n"
, libnvme_strerror(-err))
		 "failed to lookup controller, error %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to lookup controller, error %s\n"
, libnvme_strerror(-err))
		 libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to lookup controller, error %s\n"
, libnvme_strerror(-err));
	return err;
}
}

if (!c) {
/*
 * No existing controller or --force has been used, thus create
 * a new controller.
 */
err = nvmf_create_discovery_ctrl(ctx, fctx, h, &c);
if (err) {
	if (err != -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(-err))
			 "failed to add controller, error %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-err))
			 libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "failed to add controller, error %s\n"
, libnvme_strerror(-err));
	return err;
}
}

err = _nvmf_discover(ctx, fctx, c);
libnvme_free_ctrl(c);

return err;
3576}

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

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

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

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

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

write_devid_file(fctx, devid_fd, c);
if (instance >= 0)
	registry_update_on_connect(ctx, instance);
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 = LIBNVMF_TRISTATE_TRUE;

set_discovery_kato(fctx);
}

err = libnvme_add_ctrl(fctx, h, c);
if (err) {
/*
 * Kernel-level race: something else connected between our
 * scan and this ioctl. @c is our own unconnected draft, not
 * the winner -- rescan to find it.
 */
if (err == -ENVME_CONNECT_ALREADY &&
    libnvme_scan_topology(ctx, NULL((void*)0), NULL((void*)0)) == 0) {
	libnvme_ctrl_t winner = lookup_ctrl(h, fctx);
	int instance = ctrl_instance(winner);

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

libnvme_msg(ctx, LIBNVME_LOG_ERR, "could not add new controller: %s\n",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not add new controller: %s\n"
, libnvme_strerror(-err))
	libnvme_strerror(-err))__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "could not add new controller: %s\n"
, libnvme_strerror(-err));
libnvme_free_ctrl(c);
return err;
}

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

return 0;
3668}