/*

 * iSCSI sysfs

 *

 * Copyright (C) 2006 Mike Christie

 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.

 *

 * 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.

 */

#include <fcntl.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <errno.h>

#include <dirent.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include "log.h"

#include "initiator.h"

#include "transport.h"

#include "idbm.h"

#include "idbm_fields.h"

#include "version.h"

#include "iscsi_sysfs.h"

#include "sysdeps.h"

#include "iscsi_settings.h"

#include "iface.h"

#include "session_info.h"

#include "host.h"

#include "iscsi_err.h"

#include "flashnode.h"

/*

 * TODO: remove the _DIR defines and search for subsys dirs like

 *  is done in sysfs.c.

 */

#define ISCSI_TRANSPORT_DIR	"/sys/class/iscsi_transport"

#define ISCSI_SESSION_DIR	"/sys/class/iscsi_session"

#define ISCSI_HOST_DIR		"/sys/class/iscsi_host"

#define ISCSI_FLASHNODE_DIR	"/sys/bus/iscsi_flashnode/devices"

#define ISCSI_SESSION_SUBSYS		"iscsi_session"

#define ISCSI_CONN_SUBSYS		"iscsi_connection"

#define ISCSI_HOST_SUBSYS		"iscsi_host"

#define ISCSI_TRANSPORT_SUBSYS		"iscsi_transport"

#define ISCSI_IFACE_SUBSYS		"iscsi_iface"

#define ISCSI_FLASHNODE_SUBSYS		"iscsi_flashnode"

#define SCSI_HOST_SUBSYS		"scsi_host"

#define SCSI_SUBSYS			"scsi"

#define ISCSI_SESSION_ID		"session%d"

#define ISCSI_CONN_ID			"connection%d:0"

#define ISCSI_HOST_ID			"host%d"

#define ISCSI_FLASHNODE_SESS		"flashnode_sess-%d:%d"

#define ISCSI_FLASHNODE_CONN		"flashnode_conn-%d:%d:0"

/*

 * TODO: make this into a real API and check inputs better and add doc.

 */

static int num_transports;

LIST_HEAD(transports);

void free_transports(void)

{

	struct iscsi_transport *t, *tmp;

	list_for_each_entry_safe(t, tmp, &transports, list) {

		list_del(&t->list);

		free(t);

	}

}

static int trans_filter(const struct dirent *dir)

{

	return strcmp(dir->d_name, ".") && strcmp(dir->d_name, "..");

}

static int read_transports(void)

{

	struct dirent **namelist;

	int i, n, found;

	struct iscsi_transport *t;

	log_debug(7, "in %s", __FUNCTION__);

	n = scandir(ISCSI_TRANSPORT_DIR, &namelist, trans_filter,

		    alphasort);

	if (n < 0) {

		log_error("Could not scan %s.", ISCSI_TRANSPORT_DIR);

		return n;

	}

	for (i = 0; i < n; i++) {

		found = 0;

		list_for_each_entry(t, &transports, list) {

			if (!strcmp(t->name, namelist[i]->d_name)) {

				found = 1;

				break;

			}

		}

		if (!found) {

			/* copy new transport */

			t = malloc(sizeof(*t));

			if (!t)

				continue;

			log_debug(7, "Adding new transport %s",

				  namelist[i]->d_name);

			INIT_LIST_HEAD(&t->sessions);

			INIT_LIST_HEAD(&t->list);

			strlcpy(t->name, namelist[i]->d_name,

				ISCSI_TRANSPORT_NAME_MAXLEN);

			if (set_transport_template(t)) {

				free(t);

				return -1;

			}

		} else

			log_debug(7, "Updating transport %s",

				  namelist[i]->d_name);

		if (sysfs_get_uint64(t->name, ISCSI_TRANSPORT_SUBSYS,

				     "handle", &t->handle)) {

			if (list_empty(&t->list))

				free(t);

			else

				log_error("Could not update %s.",

					  t->name);

			continue;

		}

		if (sysfs_get_uint(t->name, ISCSI_TRANSPORT_SUBSYS,

				  "caps", &t->caps)) {

			if (list_empty(&t->list))

				free(t);

			else

				log_error("Could not update %s.",

					  t->name);

			continue;

		}

		/*

		 * tmp hack for qla4xx compat

		 */

		if (!strcmp(t->name, "qla4xxx")) {

			t->caps |= CAP_DATA_PATH_OFFLOAD;

		}

		if (list_empty(&t->list))

			list_add_tail(&t->list, &transports);

	}

	for (i = 0; i < n; i++)

		free(namelist[i]);

	free(namelist);

	num_transports = n;

	return 0;

}

/* caller must check lengths */

void iscsi_sysfs_get_auth_conf(int sid, struct iscsi_auth_config *conf)

{

	char id[NAME_SIZE];

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

	snprintf(id, sizeof(id), ISCSI_SESSION_ID, sid);

	sysfs_get_str(id, ISCSI_SESSION_SUBSYS, "username", conf->username,

		      sizeof(conf->username));

	sysfs_get_str(id, ISCSI_SESSION_SUBSYS, "username_in",

		      conf->username_in, sizeof(conf->username_in));

	sysfs_get_str(id, ISCSI_SESSION_SUBSYS, "password",

		      (char *)conf->password, sizeof(conf->password));

	if (strlen((char *)conf->password))

		conf->password_length = strlen((char *)conf->password);

	sysfs_get_str(id, ISCSI_SESSION_SUBSYS, "password_in",

		      (char *)conf->password_in, sizeof(conf->password_in));

	if (strlen((char *)conf->password_in))

		conf->password_in_length = strlen((char *)conf->password_in);

}

/* called must check for -1=invalid value */

void iscsi_sysfs_get_negotiated_conn_conf(int sid,

				struct iscsi_conn_operational_config *conf)

{

	char id[NAME_SIZE];

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

	snprintf(id, sizeof(id), ISCSI_CONN_ID, sid);

	sysfs_get_int(id, ISCSI_CONN_SUBSYS, "data_digest", &conf->DataDigest);

	sysfs_get_int(id, ISCSI_CONN_SUBSYS, "header_digest",

		      &conf->HeaderDigest);

	sysfs_get_int(id, ISCSI_CONN_SUBSYS, "max_xmit_dlength",

		      &conf->MaxXmitDataSegmentLength);

	sysfs_get_int(id, ISCSI_CONN_SUBSYS, "max_recv_dlength",

		       &conf->MaxRecvDataSegmentLength);

}

/* called must check for -1=invalid value */

void iscsi_sysfs_get_negotiated_session_conf(int sid,

				struct iscsi_session_operational_config *conf)

{

	char id[NAME_SIZE];

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

	snprintf(id, sizeof(id), ISCSI_SESSION_ID, sid);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "data_pdu_in_order",

		      &conf->DataPDUInOrder);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "data_seq_in_order",

		      &conf->DataSequenceInOrder);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "erl", &conf->ERL);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "first_burst_len",

		       &conf->FirstBurstLength);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "max_burst_len",

		      &conf->MaxBurstLength);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "immediate_data",

		      &conf->ImmediateData);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "initial_r2t",

		      &conf->InitialR2T);

	sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "max_outstanding_r2t",

		      &conf->MaxOutstandingR2T);

}

/*

 * iscsi_sysfs_session_user_created - return if session was setup by userspace

 * @sid: id of session to test

 *

 * Returns -1 if we could not tell due to kernel not supporting the

 * feature. 0 is returned if kernel created it. And 1 is returned

 * if userspace created it.

 */

int iscsi_sysfs_session_user_created(int sid)

{

	char id[NAME_SIZE];

	pid_t pid;

	snprintf(id, sizeof(id), ISCSI_SESSION_ID, sid);

	if (sysfs_get_int(id, ISCSI_SESSION_SUBSYS, "creator", &pid))

		return -1;

	if (pid == -1)

		return 0;

	else

		return 1;

}

uint32_t iscsi_sysfs_get_host_no_from_sid(uint32_t sid, int *err)

{

	struct sysfs_device *session_dev, *host_dev;

	char devpath[PATH_SIZE];

	char id[NAME_SIZE];

	*err = 0;

	snprintf(id, sizeof(id), "session%u", sid);

	if (!sysfs_lookup_devpath_by_subsys_id(devpath, sizeof(devpath),

					       ISCSI_SESSION_SUBSYS, id)) {

		log_error("Could not lookup devpath for %s. Possible sysfs "

			  "incompatibility.", id);

		*err = ISCSI_ERR_SYSFS_LOOKUP;

		return 0;

	}

	session_dev = sysfs_device_get(devpath);

	if (!session_dev) {

		log_error("Could not get dev for %s. Possible sysfs "

			  "incompatibility.", id);

		*err = ISCSI_ERR_SYSFS_LOOKUP;

		return 0;

	}

	/*

	 * 2.6.27 moved from scsi_host to scsi for the subsys when

	 * sysfs compat is not on.

	 */

	host_dev = sysfs_device_get_parent_with_subsystem(session_dev,

							  SCSI_SUBSYS);

	if (!host_dev) {

		struct sysfs_device *dev_parent;

		dev_parent = sysfs_device_get_parent(session_dev);

		while (dev_parent != NULL) {

			if (strncmp(dev_parent->kernel, "host", 4) == 0) {

				host_dev = dev_parent;

				break;

			}

			dev_parent = sysfs_device_get_parent(dev_parent);

		}

		if (!host_dev) {

			log_error("Could not get host dev for %s. Possible "

				  "sysfs incompatibility.", id);

			*err = ISCSI_ERR_SYSFS_LOOKUP;

			return 0;

		}

	}

	return atol(host_dev->kernel_number);

}

/* TODO: merge and make macro */

static int __get_host_no_from_netdev(void *data, struct host_info *info)

{

	struct host_info *ret_info = data;

	if (!strcmp(ret_info->iface.netdev, info->iface.netdev)) {

		ret_info->host_no = info->host_no;

		return 1;

	}

	return 0;

}

static uint32_t get_host_no_from_netdev(char *netdev, int *rc)

{

	uint32_t host_no = -1;

	struct host_info *info;

	int nr_found, local_rc;

	*rc = 0;

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

	if (!info) {

		*rc = ISCSI_ERR_NOMEM;

		return -1;

	}

	strcpy(info->iface.netdev, netdev);

	local_rc = iscsi_sysfs_for_each_host(info, &nr_found,

					     __get_host_no_from_netdev);

	if (local_rc == 1)

		host_no = info->host_no;

	else

		*rc = ISCSI_ERR_HOST_NOT_FOUND;

	free(info);

	return host_no;

}

static int __get_host_no_from_hwaddress(void *data, struct host_info *info)

{

	struct host_info *ret_info = data;

	if (!strcasecmp(ret_info->iface.hwaddress, info->iface.hwaddress)) {

		ret_info->host_no = info->host_no;

		return 1;

	}

	return 0;

}

uint32_t iscsi_sysfs_get_host_no_from_hwaddress(char *hwaddress, int *rc)

{

	uint32_t host_no = -1;

	struct host_info *info;

	int nr_found, local_rc;

	*rc = 0;

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

	if (!info) {

		*rc = ISCSI_ERR_NOMEM;

		return -1;

	}

	strcpy(info->iface.hwaddress, hwaddress);

	local_rc = iscsi_sysfs_for_each_host(info, &nr_found,

					__get_host_no_from_hwaddress);

	if (local_rc == 1)

		host_no = info->host_no;

	else

		*rc = ISCSI_ERR_HOST_NOT_FOUND;

	free(info);

	return host_no;

}

static int __get_host_no_from_ipaddress(void *data, struct host_info *info)

{

	struct host_info *ret_info = data;

	if (!strcmp(ret_info->iface.ipaddress, info->iface.ipaddress)) {

		ret_info->host_no = info->host_no;

		return 1;

	}

	return 0;

}

static uint32_t get_host_no_from_ipaddress(char *address, int *rc)

{

	uint32_t host_no = -1;

	struct host_info *info;

	int nr_found;

	int local_rc;

	*rc = 0;

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

	if (!info) {

		*rc = ISCSI_ERR_NOMEM;

		return -1;

	}

	strcpy(info->iface.ipaddress, address);

	local_rc = iscsi_sysfs_for_each_host(info, &nr_found,

					     __get_host_no_from_ipaddress);

	if (local_rc == 1)

		host_no = info->host_no;

	else

		*rc = ISCSI_ERR_HOST_NOT_FOUND;

	free(info);

	return host_no;

}

uint32_t iscsi_sysfs_get_host_no_from_hwinfo(struct iface_rec *iface, int *rc)

{

	int tmp_rc;

	uint32_t host_no = -1;

	if (strlen(iface->hwaddress) &&

	    strcasecmp(iface->hwaddress, DEFAULT_HWADDRESS))

		host_no = iscsi_sysfs_get_host_no_from_hwaddress(

						iface->hwaddress, &tmp_rc);

	else if (strlen(iface->netdev) &&

		strcasecmp(iface->netdev, DEFAULT_NETDEV))

		host_no = get_host_no_from_netdev(iface->netdev, &tmp_rc);

	else if (strlen(iface->ipaddress) &&

		 strcasecmp(iface->ipaddress, DEFAULT_IPADDRESS))

		host_no = get_host_no_from_ipaddress(iface->ipaddress, &tmp_rc);

	else

		tmp_rc = ISCSI_ERR_INVAL;

	*rc = tmp_rc;

	return host_no;

}

/*

 * Read the flash node attributes based on host and flash node index.

 */

int iscsi_sysfs_get_flashnode_info(struct flashnode_rec *fnode,

				   uint32_t host_no,

				   uint32_t flashnode_idx)

{

	char sess_id[NAME_SIZE] = {'\0'};

	char conn_id[NAME_SIZE] = {'\0'};

	char fnode_path[PATH_SIZE] = {'\0'};

	struct iscsi_transport *t;

	int ret = 0;

	t = iscsi_sysfs_get_transport_by_hba(host_no);

	if (!t)

		log_debug(7, "could not get transport name for host%d",

			  host_no);

	else

		strlcpy(fnode->transport_name, t->name,

			ISCSI_TRANSPORT_NAME_MAXLEN);

	snprintf(sess_id, sizeof(sess_id), ISCSI_FLASHNODE_SESS, host_no,

		 flashnode_idx);

	snprintf(fnode_path, sizeof(fnode_path), ISCSI_FLASHNODE_DIR"/%s",

		 sess_id);

	if (access(fnode_path, F_OK) != 0)

		return errno;

	snprintf(conn_id, sizeof(conn_id), ISCSI_FLASHNODE_CONN, host_no,

		 flashnode_idx);

	snprintf(fnode_path, sizeof(fnode_path), ISCSI_FLASHNODE_DIR"/%s",

		 conn_id);

	if (access(fnode_path, F_OK) != 0)

		return errno;

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "is_fw_assigned_ipv6",

			&((fnode->conn[0]).is_fw_assigned_ipv6));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "portal_type",

		      (fnode->sess).portal_type,

		      sizeof((fnode->sess).portal_type));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "auto_snd_tgt_disable",

			&((fnode->sess).auto_snd_tgt_disable));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "discovery_session",

			&((fnode->sess).discovery_session));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "entry_enable",

			&((fnode->sess).entry_enable));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "header_digest",

			&((fnode->conn[0]).header_digest_en));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "data_digest",

			&((fnode->conn[0]).data_digest_en));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "immediate_data",

			&((fnode->sess).immediate_data));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "initial_r2t",

			&((fnode->sess).initial_r2t));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "data_seq_in_order",

			&((fnode->sess).data_seq_in_order));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "data_pdu_in_order",

			&((fnode->sess).data_pdu_in_order));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "chap_auth",

			&((fnode->sess).chap_auth_en));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "snack_req",

			&((fnode->conn[0]).snack_req_en));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "discovery_logout",

			&((fnode->sess).discovery_logout_en));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "bidi_chap",

			&((fnode->sess).bidi_chap_en));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS,

			"discovery_auth_optional",

			&((fnode->sess).discovery_auth_optional));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "erl",

			&((fnode->sess).erl));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_timestamp_stat",

			&((fnode->conn[0]).tcp_timestamp_stat));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_nagle_disable",

			&((fnode->conn[0]).tcp_nagle_disable));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_wsf_disable",

			&((fnode->conn[0]).tcp_wsf_disable));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_timer_scale",

			&((fnode->conn[0]).tcp_timer_scale));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_timestamp_enable",

			&((fnode->conn[0]).tcp_timestamp_en));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "fragment_disable",

			&((fnode->conn[0]).fragment_disable));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "max_recv_dlength",

		       &((fnode->conn[0]).max_recv_dlength));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "max_xmit_dlength",

		       &((fnode->conn[0]).max_xmit_dlength));

	sysfs_get_uint(sess_id, ISCSI_FLASHNODE_SUBSYS, "first_burst_len",

		       &((fnode->sess).first_burst_len));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "def_time2wait",

			 &((fnode->sess).def_time2wait));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "def_time2retain",

			 &((fnode->sess).def_time2retain));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "max_outstanding_r2t",

			 &((fnode->sess).max_outstanding_r2t));

	sysfs_get_uint16(conn_id, ISCSI_FLASHNODE_SUBSYS, "keepalive_tmo",

			 &((fnode->conn[0]).keepalive_tmo));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "isid",

		      (fnode->sess).isid, sizeof((fnode->sess).isid));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "tsid",

			 &((fnode->sess).tsid));

	sysfs_get_uint16(conn_id, ISCSI_FLASHNODE_SUBSYS, "port",

			 &((fnode->conn[0]).port));

	sysfs_get_uint(sess_id, ISCSI_FLASHNODE_SUBSYS, "max_burst_len",

		       &((fnode->sess).max_burst_len));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "def_taskmgmt_tmo",

			 &((fnode->sess).def_taskmgmt_tmo));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "targetalias",

		      (fnode->sess).targetalias,

		      sizeof((fnode->sess).targetalias));

	sysfs_get_str(conn_id, ISCSI_FLASHNODE_SUBSYS, "ipaddress",

		      (fnode->conn[0]).ipaddress,

		      sizeof((fnode->conn[0]).ipaddress));

	sysfs_get_str(conn_id, ISCSI_FLASHNODE_SUBSYS, "redirect_ipaddr",

		      (fnode->conn[0]).redirect_ipaddr,

		      sizeof((fnode->conn[0]).redirect_ipaddr));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "max_segment_size",

		       &((fnode->conn[0]).max_segment_size));

	sysfs_get_uint16(conn_id, ISCSI_FLASHNODE_SUBSYS, "local_port",

			 &((fnode->conn[0]).local_port));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "ipv4_tos",

			&((fnode->conn[0]).ipv4_tos));

	sysfs_get_uint8(conn_id, ISCSI_FLASHNODE_SUBSYS, "ipv6_traffic_class",

			&((fnode->conn[0]).ipv6_traffic_class));

	sysfs_get_uint16(conn_id, ISCSI_FLASHNODE_SUBSYS, "ipv6_flow_label",

			 &((fnode->conn[0]).ipv6_flow_lbl));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "targetname",

		      (fnode->sess).targetname,

		      sizeof((fnode->sess).targetname));

	sysfs_get_str(conn_id, ISCSI_FLASHNODE_SUBSYS, "link_local_ipv6",

		      (fnode->conn[0]).link_local_ipv6,

		      sizeof((fnode->conn[0]).link_local_ipv6));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS,

			 "discovery_parent_idx",

			 &((fnode->sess).discovery_parent_idx));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS,

		      "discovery_parent_type",

		      (fnode->sess).discovery_parent_type,

		      sizeof((fnode->sess).discovery_parent_type));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "tpgt",

			 &((fnode->sess).tpgt));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_xmit_wsf",

		       &((fnode->conn[0]).tcp_xmit_wsf));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "tcp_recv_wsf",

		       &((fnode->conn[0]).tcp_recv_wsf));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "chap_out_idx",

			 &((fnode->sess).chap_out_idx));

	sysfs_get_uint16(sess_id, ISCSI_FLASHNODE_SUBSYS, "chap_in_idx",

			 &((fnode->sess).chap_in_idx));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "username",

		      (fnode->sess).username, sizeof((fnode->sess).username));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "username_in",

		      (fnode->sess).username_in,

		      sizeof((fnode->sess).username_in));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "password",

		      (fnode->sess).password, sizeof((fnode->sess).password));

	sysfs_get_str(sess_id, ISCSI_FLASHNODE_SUBSYS, "password_in",

		      (fnode->sess).password_in,

		      sizeof((fnode->sess).password_in));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "statsn",

		       &((fnode->conn[0]).stat_sn));

	sysfs_get_uint(conn_id, ISCSI_FLASHNODE_SUBSYS, "exp_statsn",

		       &((fnode->conn[0]).exp_stat_sn));

	sysfs_get_uint8(sess_id, ISCSI_FLASHNODE_SUBSYS, "is_boot_target",

			&((fnode->sess).is_boot_target));

	return ret;

}

/*

 * For each flash node of the given host, perform operation specified in fn.

 */

int iscsi_sysfs_for_each_flashnode(void *data, uint32_t host_no, int *nr_found,

				   iscsi_sysfs_flashnode_op_fn *fn)

{

	struct dirent **namelist;

	int rc = 0, i, n;

	struct flashnode_rec *fnode;

	uint32_t flashnode_idx;

	uint32_t hostno;

	fnode = malloc(sizeof(*fnode));

	if (!fnode)

		return ISCSI_ERR_NOMEM;

	n = scandir(ISCSI_FLASHNODE_DIR, &namelist, trans_filter, alphasort);

	if (n <= 0)

		goto free_fnode;

	for (i = 0; i < n; i++) {

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

		if (!strncmp(namelist[i]->d_name, "flashnode_conn",

			     strlen("flashnode_conn")))

			continue;

		if (sscanf(namelist[i]->d_name, ISCSI_FLASHNODE_SESS,

			   &hostno, &flashnode_idx) != 2) {

			log_error("Invalid iscsi target dir: %s",

				  namelist[i]->d_name);

			break;

		}

		if (host_no != hostno)

			continue;

		rc = iscsi_sysfs_get_flashnode_info(fnode, host_no,

						    flashnode_idx);

		if (rc)

			break;

		rc = fn(data, fnode, host_no, flashnode_idx);

		if (rc != 0)

			break;

		(*nr_found)++;

	}

	for (i = 0; i < n; i++)

		free(namelist[i]);

	free(namelist);

free_fnode:

	free(fnode);

	return rc;

}

static int iscsi_sysfs_read_boot(struct iface_rec *iface, char *session)

{

	char boot_root[BOOT_NAME_MAXLEN], boot_nic[BOOT_NAME_MAXLEN];

	char boot_name[BOOT_NAME_MAXLEN], boot_content[BOOT_NAME_MAXLEN];

	/* Extract boot info */

	strlcpy(boot_name, "boot_target", sizeof(boot_name));

	if (sysfs_get_str(session, ISCSI_SESSION_SUBSYS, boot_name,

			  boot_content, BOOT_NAME_MAXLEN))

		return -1;

	strlcpy(boot_name, "boot_nic", sizeof(boot_name));

	if (sysfs_get_str(session, ISCSI_SESSION_SUBSYS, boot_name, boot_nic,

			  BOOT_NAME_MAXLEN))

		return -1;

	strlcpy(boot_name, "boot_root", sizeof(boot_name));

	if (sysfs_get_str(session, ISCSI_SESSION_SUBSYS, boot_name, boot_root,

			  BOOT_NAME_MAXLEN))

		return -1;

	/* If all boot_root/boot_target/boot_nic exist, then extract the

	   info from the boot nic */

	if (sysfs_get_str(boot_nic, boot_root, "vlan", boot_content,

			  BOOT_NAME_MAXLEN))

		log_debug(5, "could not read %s/%s/vlan", boot_root, boot_nic);

	else

		iface->vlan_id = atoi(boot_content);

	if (sysfs_get_str(boot_nic, boot_root, "subnet-mask",

			  iface->subnet_mask, NI_MAXHOST))

		log_debug(5, "could not read %s/%s/subnet", boot_root,

			  boot_nic);

	if (sysfs_get_str(boot_nic, boot_root, "gateway",

			  iface->gateway, NI_MAXHOST))

		log_debug(5, "could not read %s/%s/gateway", boot_root,

			  boot_nic);

	log_debug(5, "sysfs read boot returns %s/%s/ vlan = %d subnet = %s",

		  boot_root, boot_nic, iface->vlan_id, iface->subnet_mask);

	return 0;

}

/*

 * Read in iface settings based on host and session values. If

 * session is not passed in, then the ifacename will not be set. And

 * if the session is not passed in then iname will only be set for

 * qla4xxx.

 */

static int iscsi_sysfs_read_iface(struct iface_rec *iface, int host_no,

				  char *session, char *iface_kern_id)

{

	uint32_t tmp_host_no, iface_num;

	char host_id[NAME_SIZE];

	struct iscsi_transport *t;

	int ret, iface_type;

	t = iscsi_sysfs_get_transport_by_hba(host_no);

	if (!t)

		log_debug(7, "could not get transport name for host%d",

			  host_no);

	else

		strcpy(iface->transport_name, t->name);

	snprintf(host_id, sizeof(host_id), ISCSI_HOST_ID, host_no);

	/*

	 * backward compat

	 * If we cannot get the address we assume we are doing the old

	 * style and use default.

	 */

	ret = sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "hwaddress",

			    iface->hwaddress, sizeof(iface->hwaddress));

	if (ret)

		log_debug(7, "could not read hwaddress for host%d", host_no);

	if (iface_kern_id)

		ret = sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS,

				    "ipaddress",

				    iface->ipaddress, sizeof(iface->ipaddress));

	else

		/* if not found just print out default */

		ret = sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "ipaddress",

				    iface->ipaddress, sizeof(iface->ipaddress));

	if (ret)

		log_debug(7, "could not read local address for host%d",

			  host_no);

	/* if not found just print out default */

	ret = sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "netdev",

			    iface->netdev, sizeof(iface->netdev));

	if (ret)

		log_debug(7, "could not read netdev for host%d", host_no);

	/*

	 * For drivers like qla4xxx we can only set the iname at the

	 * host level because we cannot create different initiator ports

	 * (cannot set isid either). The LLD also exports the iname at the

	 * hba level so apps can see it, but we no longer set the iname for

	 * each iscsid controlled host since bnx2i cxgbi can support multiple

	 * initiator names and of course software iscsi can support anything.

	 */

	ret = 1;

	memset(iface->iname, 0, sizeof(iface->iname));

	if (session) {

		ret = sysfs_get_str(session, ISCSI_SESSION_SUBSYS,

				    "initiatorname",

				    iface->iname, sizeof(iface->iname));

		/*

		 * qlaxxx will not set this at the session level so we

		 * always drop down for it.

		 *

		 * And.

		 *

		 * For older kernels/tools (2.6.26 and below and 2.0.870)

		 * we will not have a session level initiator name, so

		 * we will drop down.

		 */

	}

	if (ret) {

		ret = sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "initiatorname",

				    iface->iname, sizeof(iface->iname));

		if (ret)

			/*

			 * default iname is picked up later from

			 * initiatorname.iscsi if software/partial-offload.

			 *

			 * TODO: we should make it easier to get the

			 * global iname so we can just fill it in here.

			 */

			log_debug(7, "Could not read initiatorname for "

				  "host%d", host_no);

		/* optional so do not return error */

		ret = 0;

	}

	sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "port_state",

		      iface->port_state, sizeof(iface->port_state));

	sysfs_get_str(host_id, ISCSI_HOST_SUBSYS, "port_speed",

		      iface->port_speed, sizeof(iface->port_speed));

	/*

	 * this is on the session, because we support multiple bindings

	 * per device.

	 */

	memset(iface->name, 0, sizeof(iface->name));

	if (session) {

		/*

		 * this was added after 2.0.869 so we could be doing iscsi_tcp

		 * session binding, but there may not be an ifacename set

		 * if binding is not used.

		 */

		ret = sysfs_get_str(session, ISCSI_SESSION_SUBSYS, "ifacename",

				    iface->name, sizeof(iface->name));

		if (ret) {

			log_debug(7, "could not read iface name for "

				  "session %s", session);

			/*

			 * if the ifacename file is not there then we are

			 * using a older kernel and can try to find the

			 * binding by the net info which was used on these

			 * older kernels.

			 */

			if (iface_get_by_net_binding(iface, iface))

				log_debug(7, "Could not find iface for session "

					  "bound to:" iface_fmt "",

					  iface_str(iface));

		}

	}

	if (session && t->template->use_boot_info)

		iscsi_sysfs_read_boot(iface, session);

	if (!iface_kern_id)

		goto done;

	strlcpy(iface->name, iface_kern_id, sizeof(iface->name));

	if (!strncmp(iface_kern_id, "ipv4", 4)) {

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS, "bootproto",

			      iface->bootproto, sizeof(iface->bootproto));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS, "gateway",

			      iface->gateway, sizeof(iface->gateway));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS, "subnet",

			      iface->subnet_mask, sizeof(iface->subnet_mask));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS,

			      "dhcp_alt_client_id_en",

			      iface->dhcp_alt_client_id_state,

			      sizeof(iface->dhcp_alt_client_id_state));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS,

			      "dhcp_alt_client_id",

			      iface->dhcp_alt_client_id,

			      sizeof(iface->dhcp_alt_client_id));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS,

			      "dhcp_dns_address_en",

			      iface->dhcp_dns, sizeof(iface->dhcp_dns));

		sysfs_get_str(iface_kern_id, ISCSI_IFACE_SUBSYS,

			      "dhcp_learn_iqn_en",