/*

 * iSCSI Discovery

 *

 * Copyright (C) 2002 Cisco Systems, Inc.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published

 * by the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * General Public License for more details.

 *

 * See the file COPYING included with this distribution for more details.

 */

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <errno.h>

#include <netdb.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <poll.h>

#include <sys/time.h>

#include <sys/param.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include "local_strings.h"

#include "types.h"

#include "iscsi_proto.h"

#include "initiator.h"

#include "config.h"

#include "log.h"

#include "idbm.h"

#include "iscsi_settings.h"

#include "sysdeps.h"

#include "fw_context.h"

#include "iscsid_req.h"

#include "iscsi_util.h"

#include "transport.h"

#include "iscsi_sysfs.h"

#include "iscsi_ipc.h"

#include "iface.h"

#include "iscsi_timer.h"

#include "iscsi_err.h"

#ifdef ISNS_ENABLE

/* libisns includes */

#include <libisns/isns.h>

#include <libisns/paths.h>

#include <libisns/message.h>

#endif

#ifdef SLP_ENABLE

#include "iscsi-slp-discovery.h"

#endif

#define DISCOVERY_NEED_RECONNECT 0xdead0001

static char initiator_name[TARGET_NAME_MAXLEN + 1];

static char initiator_alias[TARGET_NAME_MAXLEN + 1];

static struct iscsi_ev_context ipc_ev_context;

static int request_initiator_name(int tmo)

{

	int rc;

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	memset(initiator_name, 0, sizeof(initiator_name));

	initiator_name[0] = '\0';

	memset(initiator_alias, 0, sizeof(initiator_alias));

	initiator_alias[0] = '\0';

	memset(&req, 0, sizeof(req));

	req.command = MGMT_IPC_CONFIG_INAME;

	rc = iscsid_exec_req(&req, &rsp, 1, tmo);

	if (rc)

		return rc;

	if (rsp.u.config.var[0] != '\0')

		strcpy(initiator_name, rsp.u.config.var);

	memset(&req, 0, sizeof(req));

	req.command = MGMT_IPC_CONFIG_IALIAS;

	rc = iscsid_exec_req(&req, &rsp, 0, tmo);

	if (rc)

		/* alias is optional so return ok */

		return 0;

	if (rsp.u.config.var[0] != '\0')

		strcpy(initiator_alias, rsp.u.config.var);

	return 0;

}

#ifdef ISNS_ENABLE

void discovery_isns_free_servername(void)

{

	if (isns_config.ic_server_name)

		free(isns_config.ic_server_name);

	isns_config.ic_server_name = NULL;

}

int discovery_isns_set_servername(char *address, int port)

{

	char *server;

	int len;

	if (port > USHRT_MAX) {

		log_error("Invalid port %d", port);

		return ISCSI_ERR_INVAL;

	}

	/* 5 for port and 1 for colon and 1 for null */

	len = strlen(address) + 7;

	server = calloc(1, len);

	if (!server)

		return ISCSI_ERR_NOMEM;

	snprintf(server, len, "%s:%d", address, port);

	isns_assign_string(&isns_config.ic_server_name, server);

	free(server);

	return 0;

}

int discovery_isns_query(struct discovery_rec *drec, const char *iname,

			 const char *targetname, struct list_head *rec_list)

{

	isns_attr_list_t key_attrs = ISNS_ATTR_LIST_INIT;

	isns_object_list_t objects = ISNS_OBJECT_LIST_INIT;

	isns_source_t *source;

	isns_simple_t *qry;

	isns_client_t *clnt;

	uint32_t status;

	int rc;

	isns_config.ic_security = 0;

	source = isns_source_create_iscsi(iname);

	if (!source)

		return ISCSI_ERR_NOMEM;

	clnt = isns_create_client(NULL, iname); 

	if (!clnt) {

		rc = ISCSI_ERR_NOMEM;

		goto free_src;

	}

	/* do not retry forever */

	isns_socket_set_disconnect_fatal(clnt->ic_socket);

	if (targetname)

		isns_attr_list_append_string(&key_attrs, ISNS_TAG_ISCSI_NAME,

					     targetname);

	else

		/* Query for all visible targets */

		isns_attr_list_append_uint32(&key_attrs,

					     ISNS_TAG_ISCSI_NODE_TYPE,

					     ISNS_ISCSI_TARGET_MASK);

	qry = isns_create_query2(clnt, &key_attrs, source);

	if (!qry) {

		rc = ISCSI_ERR_NOMEM;

		goto free_clnt;

	}

	isns_query_request_attr_tag(qry, ISNS_TAG_ISCSI_NAME);

	isns_query_request_attr_tag(qry, ISNS_TAG_ISCSI_NODE_TYPE);

	isns_query_request_attr_tag(qry, ISNS_TAG_PORTAL_IP_ADDRESS);

	isns_query_request_attr_tag(qry, ISNS_TAG_PORTAL_TCP_UDP_PORT);

	isns_query_request_attr_tag(qry, ISNS_TAG_PG_ISCSI_NAME);

	isns_query_request_attr_tag(qry, ISNS_TAG_PG_PORTAL_IP_ADDR);

	isns_query_request_attr_tag(qry, ISNS_TAG_PG_PORTAL_TCP_UDP_PORT);

	isns_query_request_attr_tag(qry, ISNS_TAG_PG_TAG);

	status = isns_client_call(clnt, &qry);

	switch (status) {

	case ISNS_SUCCESS:

		break;

	case ISNS_SOURCE_UNKNOWN:

		/* server requires that we are registered but we are not */

		rc = ISCSI_ERR_ISNS_REG_FAILED;

		goto free_query;

	default:

		log_error("iSNS discovery failed: %s", isns_strerror(status));

		rc = ISCSI_ERR_ISNS_QUERY;

		goto free_query;

	}

	status = isns_query_response_get_objects(qry, &objects);

	if (status) {

		log_error("Unable to extract object list from query "

			  "response: %s", isns_strerror(status));

		rc = ISCSI_ERR;

		goto free_query;

	}

	for (unsigned int i = 0; i < objects.iol_count; ++i) {

		isns_object_t *obj = objects.iol_data[i];

		const char *pg_tgt = NULL;

		struct in6_addr in_addr;

		uint32_t pg_port = ISCSI_LISTEN_PORT;

		uint32_t pg_tag = PORTAL_GROUP_TAG_UNKNOWN;

		char pg_addr[INET6_ADDRSTRLEN + 1];

		struct node_rec *rec;

		if (!isns_object_is_pg(obj))

			continue;

		if (!isns_object_get_string(obj, ISNS_TAG_PG_ISCSI_NAME,

					    &pg_tgt)) {

			log_debug(1, "Missing target name");

			continue;

		}

		if (!isns_object_get_ipaddr(obj, ISNS_TAG_PG_PORTAL_IP_ADDR,

					    &in_addr)) {

			log_debug(1, "Missing addr");

			continue;

		}

		if (IN6_IS_ADDR_V4MAPPED(&in_addr) ||

		    IN6_IS_ADDR_V4COMPAT(&in_addr)) {

			struct in_addr ipv4;

			ipv4.s_addr = in_addr.s6_addr32[3];

			inet_ntop(AF_INET, &ipv4, pg_addr, sizeof(pg_addr));

		} else

			inet_ntop(AF_INET6, &in_addr, pg_addr, sizeof(pg_addr));

		if (!isns_object_get_uint32(obj,

					    ISNS_TAG_PG_PORTAL_TCP_UDP_PORT,

					    &pg_port)) {

			log_debug(1, "Missing port");

			continue;

		}

		if (!isns_object_get_uint32(obj, ISNS_TAG_PG_TAG, &pg_tag)) {

			log_debug(1, "Missing tag");

			continue;

		}

		rec = calloc(1, sizeof(*rec));

		if (!rec) {

			rc = ISCSI_ERR_NOMEM;

			goto destroy_list;

		}

		idbm_node_setup_from_conf(rec);

		if (drec) {

			rec->disc_type = drec->type;

			rec->disc_port = drec->port;

			strcpy(rec->disc_address, drec->address);

		}

		strlcpy(rec->name, pg_tgt, TARGET_NAME_MAXLEN);

		rec->tpgt = pg_tag;

		rec->conn[0].port = pg_port;

		strlcpy(rec->conn[0].address, pg_addr, NI_MAXHOST);

		list_add_tail(&rec->list, rec_list);

	}

	rc = 0;

	isns_flush_events();

destroy_list:

	isns_object_list_destroy(&objects);

free_query:

	isns_simple_free(qry);

free_clnt:

	isns_client_destroy(clnt);

free_src:

	isns_source_release(source);

	return rc;

}

/*

 * discovery_isns_reg_node - register/deregister node

 * @iname: initiator name

 * @reg: bool indicating if we are supposed to register or deregister node.

 *

 * We do a very simple registration just so we can query.

 */

static int discovery_isns_reg_node(const char *iname, int op_reg)

{

	isns_simple_t *reg;

	isns_client_t *clnt;

	isns_source_t *source;

	int rc = 0, status;

	isns_config.ic_security = 0;

	log_debug(1, "trying to %s %s with iSNS server.",

		  op_reg ? "register" : "deregister", iname);

	source = isns_source_create_iscsi(iname);

	if (!source)

		return ISCSI_ERR_NOMEM;

	clnt = isns_create_client(NULL, iname); 

	if (!clnt) {

		rc = ISCSI_ERR_NOMEM;

		goto free_src;

	}

	reg = isns_simple_create(op_reg ? ISNS_DEVICE_ATTRIBUTE_REGISTER :

				 ISNS_DEVICE_DEREGISTER,

				 source, NULL);

	if (!reg) {

		rc = ISCSI_ERR_NOMEM;

		goto free_clnt;

	}

	isns_attr_list_append_string(&reg->is_operating_attrs,

				     ISNS_TAG_ISCSI_NAME, iname);

	if (op_reg)

		isns_attr_list_append_uint32(&reg->is_operating_attrs,

					     ISNS_TAG_ISCSI_NODE_TYPE,

					     ISNS_ISCSI_INITIATOR_MASK);

	status = isns_client_call(clnt, ®);

	if (status != ISNS_SUCCESS) {

		log_error("Could not %s %s with iSNS server: %s.",

			  reg ? "register" : "deregister", iname,

			  isns_strerror(status));

		rc = ISCSI_ERR_ISNS_REG_FAILED;

	} else

		log_debug(1, "%s %s with iSNS server successful.",

			  op_reg ? "register" : "deregister", iname);

free_clnt:

	isns_client_destroy(clnt);

free_src:

	isns_source_release(source);

	return rc;

}

int discovery_isns(void *data, struct iface_rec *iface,

		   struct list_head *rec_list)

{

	struct discovery_rec *drec = data;

	char *iname;

	int rc, registered = 0;

	if (iface && strlen(iface->iname))

		iname = iface->iname;

	else {

		rc = request_initiator_name(drec->iscsid_req_tmo);

		if (rc) {

			log_error("Cannot perform discovery. Initiatorname "

				  "required.");

			return rc;

		} else if (initiator_name[0] == '\0') {

			log_error("Cannot perform discovery. Invalid "

				  "Initiatorname.");

			return ISCSI_ERR_INVAL;

		}

		iname = initiator_name;

	}

	rc = discovery_isns_set_servername(drec->address, drec->port);

	if (rc)

		return rc;

retry:

	rc = discovery_isns_query(drec, iname, NULL, rec_list);

	if (!registered && rc == ISCSI_ERR_ISNS_REG_FAILED) {

		rc = discovery_isns_reg_node(iname, 1);

		if (!rc) {

			registered = 1;

			goto retry;

		}

	}

	if (registered)

		discovery_isns_reg_node(iname, 0);

	discovery_isns_free_servername();

	return rc;

}

#endif

int discovery_fw(void *data,

		 __attribute__((unused))struct iface_rec *iface,

		 struct list_head *rec_list)

{

	struct discovery_rec *drec = data;

	struct boot_context *bcontext;

	struct list_head targets;

	struct node_rec *rec;

	int rc;

	INIT_LIST_HEAD(&targets;;

	rc = fw_get_targets(&targets;;

	if (rc) {

		log_error("Could not get list of targets from firmware. "

			  "(err %d)", rc);

		return rc;

	}

	if (list_empty(&targets))

		return 0;

	/*

	 * TODO: Do we want to match the iface MAC/netdev with what is in

	 * the firmware or could the user want to bind based on what is

	 * in passed in or in the default ifaces?

	 */

	list_for_each_entry(bcontext, &targets, list) {

		rec = idbm_create_rec_from_boot_context(bcontext);

		if (!rec) {

			log_error("Could not convert firmware info to "

				  "node record.");

			rc = ISCSI_ERR_NOMEM;

			goto free_targets;

		}

		rec->disc_type = drec->type;

		list_add_tail(&rec->list, rec_list);

	}

free_targets:

	fw_free_targets(&targets;;

	return rc;

}

int discovery_offload_sendtargets(int host_no, int do_login,

				  discovery_rec_t *drec)

{

	struct sockaddr_storage ss;

	char default_port[NI_MAXSERV];

	iscsiadm_req_t req;

	iscsiadm_rsp_t rsp;

	int rc;

	log_debug(4, "offload st though host %d to %s", host_no,

		  drec->address);

	memset(&req, 0, sizeof(req));

	req.command = MGMT_IPC_SEND_TARGETS;

	req.u.st.host_no = host_no;

	req.u.st.do_login = do_login;

	/* resolve the DiscoveryAddress to an IP address */

	sprintf(default_port, "%d", drec->port);

	rc = resolve_address(drec->address, default_port, &ss);

	if (rc)

		return rc;

	req.u.st.ss = ss;

	/*

	 * We only know how ask qla4xxx to do discovery and login

	 * to what it finds. We are not able to get what it finds or

	 * is able to log into so we just send the command and proceed.

	 *

	 * There is a way to just use the hw to send a sendtargets command

	 * and get back the results. We should do this since it would

	 * allows us to then process the results like software iscsi.

	 */

	rc = iscsid_exec_req(&req, &rsp, 1, drec->iscsid_req_tmo);

	if (rc) {

		log_error("Could not offload sendtargets to %s.",

			  drec->address);

		iscsi_err_print_msg(rc);

		return rc;

	}

	return 0;

}

static int

iscsi_make_text_pdu(iscsi_session_t *session,

		    struct iscsi_hdr *hdr,

		    __attribute__((unused))char *data,

		    __attribute__((unused))int max_data_length)

{

	struct iscsi_text *text_pdu = (struct iscsi_text *)hdr;

	/* initialize the PDU header */

	memset(text_pdu, 0, sizeof (*text_pdu));

	text_pdu->opcode = ISCSI_OP_TEXT;

	text_pdu->itt = htonl(session->itt);

	text_pdu->ttt = ISCSI_RESERVED_TAG;

	text_pdu->cmdsn = htonl(session->cmdsn++);

	text_pdu->exp_statsn = htonl(session->conn[0].exp_statsn);

	return 1;

}

static int

request_targets(iscsi_session_t *session)

{

	char data[64];

	struct iscsi_text text;

	struct iscsi_hdr *hdr = (struct iscsi_hdr *) &tex;;

	memset(&text, 0, sizeof (text));

	memset(data, 0, sizeof (data));

	/* make a text PDU with SendTargets=All */

	if (!iscsi_make_text_pdu(session, hdr, data, sizeof (data))) {

		log_error("failed to make a SendTargets PDU");

		return 0;

	}

	if (!iscsi_add_text(hdr, data, sizeof (data), "SendTargets", "All")) {

		log_error("failed to add SendTargets text key");

		return 0;

	}

	text.ttt = ISCSI_RESERVED_TAG;

	text.flags = ISCSI_FLAG_CMD_FINAL;

	if (!iscsi_io_send_pdu(&session->conn[0], hdr, ISCSI_DIGEST_NONE, data,

		    ISCSI_DIGEST_NONE, session->conn[0].active_timeout)) {

		log_error("failed to send SendTargets PDU");

		return 0;

	}

	return 1;

}

static int

iterate_targets(iscsi_session_t *session, uint32_t ttt)

{

	char data[64];

	struct iscsi_text text;

	struct iscsi_hdr *pdu = (struct iscsi_hdr *) &tex;;

	memset(&text, 0, sizeof (text));

	memset(data, 0, sizeof (data));

	/* make an empty text PDU */

	if (!iscsi_make_text_pdu(session, pdu, data, sizeof (data))) {

		log_error("failed to make an empty text PDU");

		return 0;

	}

	text.ttt = ttt;

	text.flags = ISCSI_FLAG_CMD_FINAL;

	if (!iscsi_io_send_pdu(&session->conn[0], pdu, ISCSI_DIGEST_NONE, data,

		    ISCSI_DIGEST_NONE, session->conn[0].active_timeout)) {

		log_error("failed to send empty text PDU");

		return 0;

	}

	return 1;

}

static int add_portal(struct list_head *rec_list, discovery_rec_t *drec,

		      char *targetname, char *address, char *port, char *tag)

{

	struct sockaddr_storage ss;

	struct node_rec *rec;

	if (resolve_address(address, port, &ss)) {

		log_error("cannot resolve %s", address);

		return 0;

	}

	rec = calloc(1, sizeof(*rec));

	if (!rec)

		return 0;

	idbm_node_setup_from_conf(rec);

	rec->disc_type = drec->type;

	rec->disc_port = drec->port;

	strcpy(rec->disc_address, drec->address);

	strlcpy(rec->name, targetname, TARGET_NAME_MAXLEN);

	if (tag && *tag)

		rec->tpgt = atoi(tag);

	else

		rec->tpgt = PORTAL_GROUP_TAG_UNKNOWN;

	if (port && *port)

		rec->conn[0].port = atoi(port);

	else

		rec->conn[0].port = ISCSI_LISTEN_PORT;

	strlcpy(rec->conn[0].address, address, NI_MAXHOST);

	list_add_tail(&rec->list, rec_list);

	return 1;

}

static int

add_target_record(char *name, char *end, discovery_rec_t *drec,

		  struct list_head *rec_list)

{

	char *text = NULL;

	char *nul = name;

	size_t length;

	/* address = IPv4

	 * address = [IPv6]

	 * address = DNSname

	 * address = IPv4:port

	 * address = [IPv6]:port

	 * address = DNSname:port

	 * address = IPv4,tag

	 * address = [IPv6],tag

	 * address = DNSname,tag

	 * address = IPv4:port,tag

	 * address = [IPv6]:port,tag

	 * address = DNSname:port,tag

	 */

	log_debug(7, "adding target record %p, end %p", name, end);

	/* find the end of the name */

	while ((nul < end) && (*nul != '\0'))

		nul++;

	length = nul - name;

	if (length > TARGET_NAME_MAXLEN) {

		log_error("TargetName %s too long, ignoring", name);

		return 0;

	}

	text = name + length;

	/* skip NULs after the name */

	while ((text < end) && (*text == '\0'))

		text++;

	/* if no address is provided, use the default */

	if (text >= end) {

		if (drec->address == NULL) {

			log_error("no default address known for target %s",

				  name);

			return 0;

		} else {

			char default_port[NI_MAXSERV];

			sprintf(default_port, "%d", drec->port);

			if (!add_portal(rec_list, drec, name, drec->address,

				        default_port, NULL)) {

				log_error("failed to add default portal, "

					  "ignoring target %s", name);

				return 0;

			}

		}

		/* finished adding the default */

		return 1;

	}

	/* process TargetAddresses */

	while (text < end) {

		char *next = text + strlen(text) + 1;

		log_debug(7, "text %p, next %p, end %p, %s", text, next, end,

			 text);

		if (strncmp(text, "TargetAddress=", 14) == 0) {

			char *port = NULL;

			char *tag = NULL;

			char *address = text + 14;

			char *temp;

			if ((tag = strrchr(text, ','))) {

				*tag = '\0';

				tag++;

			}

			if ((port = strrchr(text, ':'))) {

				*port = '\0';

				port++;

			}

			if (*address == '[') {

				address++;

				if ((temp = strrchr(text, ']')))

					*temp = '\0';

			}

			if (!add_portal(rec_list, drec, name, address, port,

					tag)) {

				log_error("failed to add default portal, "

					 "ignoring target %s", name);

				return 0;

			}

		} else

			log_error("unexpected SendTargets data: %s",

			       text);

		text = next;

	}

	return 1;

}

static int

process_sendtargets_response(struct str_buffer *sendtargets,

			     int final, discovery_rec_t *drec,

			     struct list_head *rec_list)

{

	char *start = str_buffer_data(sendtargets);

	char *text = start;

	char *end = text + str_data_length(sendtargets);

	char *nul = end - 1;

	char *record = NULL;

	int num_targets = 0;

	if (start == end) {

		/* no SendTargets data */

		goto done;

	}

	/* scan backwards to find the last NUL in the data, to ensure we

	 * don't walk off the end.  Since key=value pairs can span PDU

	 * boundaries, we're not guaranteed that the end of the data has a

	 * NUL.

	 */

	while ((nul > start) && *nul)

		nul--;

	if (nul == start) {

		/* couldn't find anything we can process now,

		 * it's one big partial string

		 */

		goto done;

	}

	/* find the boundaries between target records (TargetName or final PDU)

	 */

	for (;;) {

		/* skip NULs */

		while ((text < nul) && (*text == '\0'))

			text++;

		if (text == nul)

			break;

		log_debug(7,

			 "processing sendtargets record %p, text %p, line %s",

			 record, text, text);

		/* look for the start of a new target record */

		if (strncmp(text, "TargetName=", 11) == 0) {

			if (record) {

				/* send the last record, which we just found

				 * the end of. don't bother passing the

				 * "TargetName=" prefix.

				 */

				if (!add_target_record(record + 11, text,

							drec, rec_list)) {

					log_error(

					       "failed to add target record");

					str_truncate_buffer(sendtargets, 0);

					goto done;

				}

				num_targets++;

			}

			record = text;

		}

		/* everything up til the next NUL must be part of the

		 * current target record

		 */

		while ((text < nul) && (*text != '\0'))

			text++;

	}

	if (record) {

		if (final) {

			/* if this is the last PDU of the text sequence,

			 * it also ends a target record

			 */

			log_debug(7,

				 "processing final sendtargets record %p, "

				 "line %s",

				 record, record);

			if (add_target_record (record + 11, text,

					       drec, rec_list)) {

				num_targets++;

				record = NULL;

				str_truncate_buffer(sendtargets, 0);

			} else {

				log_error("failed to add target record");

				str_truncate_buffer(sendtargets, 0);

				goto done;

			}

		} else {

			/* remove the parts of the sendtargets buffer we've

			 * processed, and move the parts we haven't to the

			 * beginning of the buffer.

			 */

			log_debug(7,

				 "processed %d bytes of sendtargets data, "

				 "%d remaining",

				 (int)(record - str_buffer_data(sendtargets)),

				 (int)(str_buffer_data(sendtargets) +

				 str_data_length(sendtargets) - record));

			str_remove_initial(sendtargets,

					   record - str_buffer_data(sendtargets));

		}

	}

      done:

	return 1;

}

static void iscsi_free_session(struct iscsi_session *session)

{

	list_del_init(&session->list);

	free(session);

}

static iscsi_session_t *

iscsi_alloc_session(struct iscsi_sendtargets_config *config,

		    struct iface_rec *iface, int *rc, int tmo)

{

	iscsi_session_t *session;

	*rc = 0;

	session = calloc(1, sizeof (*session));

	if (session == NULL) {

		*rc = ISCSI_ERR_NOMEM;

		return NULL;

	}

	session->t = iscsi_sysfs_get_transport_by_name(iface->transport_name);

	if (!session->t) {

		log_error("iSCSI driver %s is not loaded. Load the module "

			  "then retry the command.", iface->transport_name);

		*rc = ISCSI_ERR_TRANS_NOT_FOUND;

		goto fail;

	}

	INIT_LIST_HEAD(&session->list);

	/* initialize the session's leading connection */

	session->conn[0].id = 0;

	session->conn[0].socket_fd = -1;

	session->conn[0].session = session;

	session->conn[0].login_timeout = config->conn_timeo.login_timeout;

	session->conn[0].auth_timeout = config->conn_timeo.auth_timeout;

	session->conn[0].active_timeout = config->conn_timeo.active_timeout;

	session->conn[0].noop_out_timeout = 0;

	session->conn[0].noop_out_interval = 0;

	session->reopen_cnt = config->reopen_max + 1;

	iscsi_copy_operational_params(&session->conn[0], &config->session_conf,

				      &config->conn_conf);

	/* OUI and uniqifying number */

	session->isid[0] = DRIVER_ISID_0;

	session->isid[1] = DRIVER_ISID_1;

	session->isid[2] = DRIVER_ISID_2;

	session->isid[3] = 0;

	session->isid[4] = 0;

	session->isid[5] = 0;

	if (strlen(iface->iname)) {

		strcpy(initiator_name, iface->iname);

		/* MNC TODO add iface alias */

	} else {

		*rc = request_initiator_name(tmo);

		if (*rc) {

			log_error("Cannot perform discovery. Initiatorname "

				  "required.");

			goto fail;

		} else if (initiator_name[0] == '\0') {

			log_error("Cannot perform discovery. Invalid "

				  "Initiatorname.");

			*rc = ISCSI_ERR_INVAL;

			goto fail;

		}

	}

	iface_copy(&session->nrec.iface, iface);

	session->initiator_name = initiator_name;

	session->initiator_alias = initiator_alias;

	session->portal_group_tag = PORTAL_GROUP_TAG_UNKNOWN;

	session->type = ISCSI_SESSION_TYPE_DISCOVERY;

	session->id = INVALID_SESSION_ID;

	/* setup authentication variables for the session*/

	*rc = iscsi_setup_authentication(session, &config->auth);