/*

 * iSCSI flashnode helpers

 *

 * Copyright (C) 2013 QLogic Corporation.

 * Maintained by open-iscsi@googlegroups.com

 *

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

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <sys/stat.h>

#include <arpa/inet.h>

#include "log.h"

#include "idbm.h"

#include "iscsi_util.h"

#include "transport.h"

#include "iscsi_sysfs.h"

#include "list.h"

#include "sysdeps.h"

#include "idbm_fields.h"

#include "iscsi_err.h"

#include "iscsi_ipc.h"

#include "iscsi_netlink.h"

#include "flashnode.h"

#include "iscsi_settings.h"

char key[NAME_MAXVAL];

char *to_key(const char *fmt)

{

	int i = 0;

	memset(key, 0, sizeof(key));

	sprintf(key, fmt, i);

	return key;

}

int flashnode_info_print_flat(__attribute__((unused))void *data,

			      struct flashnode_rec *fnode,

			      __attribute__((unused))uint32_t host_no,

			      uint32_t flashnode_idx)

{

	printf("%s: [%d] ", fnode->transport_name, flashnode_idx);

	if (!strlen((char *)fnode->conn[0].ipaddress))

		printf("%s:", UNKNOWN_VALUE);

	else if (strchr((char *)fnode->conn[0].ipaddress, '.'))

		printf("%s:", fnode->conn[0].ipaddress);

	else

		printf("[%s]:", fnode->conn[0].ipaddress);

	if (!fnode->conn[0].port)

		printf("%s,", UNKNOWN_VALUE);

	else

		printf("%u,", fnode->conn[0].port);

	printf("%u ", fnode->sess.tpgt);

	if (!strlen(fnode->sess.targetname))

		printf("%s\n", UNKNOWN_VALUE);

	else

		printf("%s\n", fnode->sess.targetname);

	return 0;

}

static int flashnode_fill_isid(struct flashnode_rec *fnode, struct iovec *iov)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	uint8_t isid[6];

	len = sizeof(struct iscsi_flashnode_param_info) + 6;

	iov->iov_base = iscsi_nla_alloc(ISCSI_FLASHNODE_ISID, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = ISCSI_FLASHNODE_ISID;

	fnode_param->len = 6;

	sscanf(fnode->sess.isid, "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",

	       &isid[0], &isid[1], &isid[2], &isid[3], &isid[4], &isid[5]);

	memcpy(fnode_param->value, isid, fnode_param->len);

	return 0;

}

static int flashnode_fill_ipv4_addr(struct flashnode_rec *fnode,

				    struct iovec *iov, int param_type)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	int rc;

	len = sizeof(struct iscsi_flashnode_param_info) + 4;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = 4;

	switch (param_type) {

	case ISCSI_FLASHNODE_IPADDR:

		rc = inet_pton(AF_INET, (char *)fnode->conn[0].ipaddress,

			       fnode_param->value);

		break;

	case ISCSI_FLASHNODE_REDIRECT_IPADDR:

		rc = inet_pton(AF_INET, (char *)fnode->conn[0].redirect_ipaddr,

			       fnode_param->value);

		break;

	default:

		goto free;

	}

	if (rc <= 0)

		goto free;

	return 0;

free:

	free(iov->iov_base);

	iov->iov_base = NULL;

	iov->iov_len = 0;

	return 1;

}

static int flashnode_fill_ipv6_addr(struct flashnode_rec *fnode,

				    struct iovec *iov, int param_type)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	int rc;

	len = sizeof(struct iscsi_flashnode_param_info) + 16;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = 16;

	switch (param_type) {

	case ISCSI_FLASHNODE_IPADDR:

		rc = inet_pton(AF_INET6, (char *)fnode->conn[0].ipaddress,

			       fnode_param->value);

		break;

	case ISCSI_FLASHNODE_REDIRECT_IPADDR:

		rc = inet_pton(AF_INET6, (char *)fnode->conn[0].redirect_ipaddr,

			       fnode_param->value);

		break;

	case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:

		rc = inet_pton(AF_INET6, (char *)fnode->conn[0].link_local_ipv6,

			       fnode_param->value);

		break;

	default:

		goto free;

	}

	if (rc <= 0)

		goto free;

	return 0;

free:

	free(iov->iov_base);

	iov->iov_base = NULL;

	iov->iov_len = 0;

	return 1;

}

static int flashnode_fill_ipaddr(struct flashnode_rec *fnode, struct iovec *iov,

				 int param_type)

{

	int rc = 0;

	if (!strncmp(fnode->sess.portal_type, "ipv4", 4))

		rc = flashnode_fill_ipv4_addr(fnode, iov, param_type);

	else

		rc = flashnode_fill_ipv6_addr(fnode, iov, param_type);

	return rc;

}

static int flashnode_fill_uint8(__attribute__((unused))struct flashnode_rec *fnode,

				struct iovec *iov,

				int param_type, uint8_t val)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	len = sizeof(struct iscsi_flashnode_param_info) + 1;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = 1;

	fnode_param->value[0] = val;

	return 0;

}

static int flashnode_fill_uint16(__attribute__((unused))struct flashnode_rec *fnode,

				 struct iovec *iov,

				 int param_type, uint16_t val)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	len = sizeof(struct iscsi_flashnode_param_info) + 2;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = 2;

	memcpy(fnode_param->value, &val, fnode_param->len);

	return 0;

}

static int flashnode_fill_uint32(__attribute__((unused))struct flashnode_rec *fnode,

				 struct iovec *iov,

				 int param_type, uint32_t val)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	len = sizeof(struct iscsi_flashnode_param_info) + 4;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = 4;

	memcpy(fnode_param->value, &val, fnode_param->len);

	return 0;

}

static int flashnode_fill_str(__attribute__((unused))struct flashnode_rec *fnode,

			      struct iovec *iov,

			      int param_type, char *buf, int buflen)

{

	struct iscsi_flashnode_param_info *fnode_param;

	struct nlattr *attr;

	int len;

	len = sizeof(struct iscsi_flashnode_param_info) + buflen;

	iov->iov_base = iscsi_nla_alloc(param_type, len);

	if (!iov->iov_base)

		return 1;

	attr = iov->iov_base;

	iov->iov_len = NLA_ALIGN(attr->nla_len);

	fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);

	fnode_param->param = param_type;

	fnode_param->len = buflen;

	memcpy(fnode_param->value, buf, fnode_param->len);

	return 0;

}

int flashnode_build_config(struct list_head *params,

			   struct flashnode_rec *fnode, struct iovec *iovs)

{

	struct user_param *param;

	struct iovec *iov = NULL;

	int count = 0;

	int port = 3260;

	/* start at 2, because 0 is for nlmsghdr and 1 for event */

	iov = iovs + 2;

	list_for_each_entry(param, params, list) {

		if (!strcmp(param->name, FLASHNODE_SESS_AUTO_SND_TGT_DISABLE)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE,

			    fnode->sess.auto_snd_tgt_disable))

				count++;

		} else if (!strcmp(param->name,

				   FLASHNODE_SESS_DISCOVERY_SESS)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_DISCOVERY_SESS,

			    fnode->sess.discovery_session))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_ENTRY_EN)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_ENTRY_EN,

			    fnode->sess.entry_enable))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_IMM_DATA_EN)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_IMM_DATA_EN,

			    fnode->sess.immediate_data))

				count++;

		} else if (!strcmp(param->name,

				   FLASHNODE_SESS_INITIAL_R2T_EN)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_INITIAL_R2T_EN,

			    fnode->sess.initial_r2t))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DATASEQ_INORDER)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_DATASEQ_INORDER,

			    fnode->sess.data_seq_in_order))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_PDU_INORDER)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_PDU_INORDER,

			    fnode->sess.data_pdu_in_order))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_CHAP_AUTH_EN)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_CHAP_AUTH_EN,

			    fnode->sess.chap_auth_en))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DISCOVERY_LOGOUT_EN)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN,

			    fnode->sess.discovery_logout_en))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_BIDI_CHAP_EN )) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_BIDI_CHAP_EN,

			    fnode->sess.bidi_chap_en))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DISCOVERY_AUTH_OPTIONAL)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL,

			    fnode->sess.discovery_auth_optional))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_ERL)) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_ERL,

			    fnode->sess.erl))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DEF_TIME2WAIT)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_DEF_TIME2WAIT,

			    fnode->sess.def_time2wait))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DEF_TIME2RETAIN)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_DEF_TIME2RETAIN,

			    fnode->sess.def_time2retain))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_MAX_R2T)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_MAX_R2T,

			    fnode->sess.max_outstanding_r2t))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_TSID)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_TSID,

			    fnode->sess.tsid))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_MAX_BURST)) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_MAX_BURST,

			    fnode->sess.max_burst_len))

				count++;

		} else if (!strcmp(param->name,

				  FLASHNODE_SESS_DEF_TASKMGMT_TMO)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_DEF_TASKMGMT_TMO,

			    fnode->sess.def_taskmgmt_tmo))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_NAME)) {

			if (!flashnode_fill_str(fnode, &iov[count],

			    ISCSI_FLASHNODE_NAME,

			    fnode->sess.targetname,

			    sizeof(fnode->sess.targetname)))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_FIRST_BURST)) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_FIRST_BURST,

			    fnode->sess.first_burst_len))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_ISID)) {

			if (!flashnode_fill_isid(fnode, &iov[count]))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_ALIAS)) {

			if (!flashnode_fill_str(fnode, &iov[count],

			    ISCSI_FLASHNODE_ALIAS,

			    fnode->sess.targetalias,

			    sizeof(fnode->sess.targetalias)))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_TPGT)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_TPGT,

			    fnode->sess.tpgt))

				count++;

		} else if (!strcmp(param->name,

			  FLASHNODE_SESS_DISCOVERY_PARENT_IDX)) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX,

			    fnode->sess.discovery_parent_idx))

				count++;

		} else if (!strcmp(param->name,

			  FLASHNODE_SESS_DISCOVERY_PARENT_TYPE)) {

			if (!flashnode_fill_str(fnode, &iov[count],

			    ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE,

			    fnode->sess.discovery_parent_type,

			    sizeof(fnode->sess.discovery_parent_type)))

				count++;

		} else if (!strcmp(param->name, FLASHNODE_SESS_PORTAL_TYPE)) {

			if (!flashnode_fill_str(fnode, &iov[count],

			    ISCSI_FLASHNODE_PORTAL_TYPE,

			    fnode->sess.portal_type,

			    sizeof(fnode->sess.portal_type)))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_SESS_CHAP_OUT_IDX))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_CHAP_OUT_IDX,

			    fnode->sess.chap_out_idx))

				count++;

		} else if (!strcmp(param->name, to_key(FLASHNODE_CONN_PORT))) {

			if (fnode->conn[0].port)

				port = fnode->conn[0].port;

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_PORT, port))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IPADDR))) {

			if (!flashnode_fill_ipaddr(fnode, &iov[count],

						   ISCSI_FLASHNODE_IPADDR))

					count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_MAX_RECV_DLENGTH))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_MAX_RECV_DLENGTH,

			    fnode->conn[0].max_recv_dlength))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IS_FW_ASSIGNED_IPV6))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6,

			    fnode->conn[0].is_fw_assigned_ipv6))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_HDR_DGST_EN))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_HDR_DGST_EN,

			    fnode->conn[0].header_digest_en))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_DATA_DGST_EN))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_DATA_DGST_EN,

			    fnode->conn[0].data_digest_en))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_SNACK_REQ_EN))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_SNACK_REQ_EN,

			    fnode->conn[0].snack_req_en))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_TIMESTAMP_STAT))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT,

			    fnode->conn[0].tcp_timestamp_stat))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_NAGLE_DISABLE))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_NAGLE_DISABLE,

			    fnode->conn[0].tcp_nagle_disable))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_WSF_DISABLE))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_WSF_DISABLE,

			    fnode->conn[0].tcp_wsf_disable))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_TIMER_SCALE))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_TIMER_SCALE,

			    fnode->conn[0].tcp_timer_scale))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_TIMESTAMP_EN))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_TIMESTAMP_EN,

			    fnode->conn[0].tcp_timestamp_en))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IP_FRAG_DISABLE))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_IP_FRAG_DISABLE,

			    fnode->conn[0].fragment_disable))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_MAX_XMIT_DLENGTH))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_MAX_XMIT_DLENGTH,

			    fnode->conn[0].max_xmit_dlength))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_KEEPALIVE_TMO))) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_KEEPALIVE_TMO,

			    fnode->conn[0].keepalive_tmo))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_REDIRECT_IPADDR))) {

			if (!flashnode_fill_ipaddr(fnode, &iov[count],

					ISCSI_FLASHNODE_REDIRECT_IPADDR))

					count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_MAX_SEGMENT_SIZE))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_MAX_SEGMENT_SIZE,

			    fnode->conn[0].max_segment_size))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_LOCAL_PORT))) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_LOCAL_PORT,

			    fnode->conn[0].local_port))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IPV4_TOS))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_IPV4_TOS,

			    fnode->conn[0].ipv4_tos))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IPV6_TC))) {

			if (!flashnode_fill_uint8(fnode, &iov[count],

			    ISCSI_FLASHNODE_IPV6_TC,

			    fnode->conn[0].ipv6_traffic_class))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_IPV6_FLOW_LABEL))) {

			if (!flashnode_fill_uint16(fnode, &iov[count],

			    ISCSI_FLASHNODE_IPV6_FLOW_LABEL,

			    fnode->conn[0].ipv6_flow_lbl))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_LINK_LOCAL_IPV6))) {

			if (!flashnode_fill_ipv6_addr(fnode, &iov[count],

					ISCSI_FLASHNODE_LINK_LOCAL_IPV6))

					count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_XMIT_WSF))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_XMIT_WSF,

			    fnode->conn[0].tcp_xmit_wsf))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_TCP_RECV_WSF))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_TCP_RECV_WSF,

			    fnode->conn[0].tcp_recv_wsf))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_STATSN))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_STATSN,

			    fnode->conn[0].stat_sn))

				count++;

		} else if (!strcmp(param->name,

			  to_key(FLASHNODE_CONN_EXP_STATSN))) {

			if (!flashnode_fill_uint32(fnode, &iov[count],

			    ISCSI_FLASHNODE_EXP_STATSN,

			    fnode->conn[0].exp_stat_sn))

				count++;

		}

	}

	return count;

}