/*

 * iSCSI Discovery Database Library

 *

 * Copyright (C) 2004 Dmitry Yusupov, Alex Aizman

 * Copyright (C) 2006 Mike Christie

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

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

#include <ctype.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <dirent.h>

#include <limits.h>

#include <fcntl.h>

#include <glob.h>

#include <sys/stat.h>

#include <sys/file.h>

#include <inttypes.h>

#include "idbm.h"

#include "idbm_fields.h"

#include "log.h"

#include "iscsi_util.h"

#include "iscsi_settings.h"

#include "transport.h"

#include "iscsi_sysfs.h"

#include "iface.h"

#include "sysdeps.h"

#include "fw_context.h"

#include "iscsi_err.h"

#define IDBM_HIDE	0    /* Hide parameter when print. */

#define IDBM_SHOW	1    /* Show parameter when print. */

#define IDBM_MASKED	2    /* Show "stars" instead of real value when print */

static struct idbm *db;

#define ARRAY_LEN(x) ( sizeof(x) / sizeof((x)[0]) )

#define __recinfo_str(_key, _info, _rec, _name, _show, _n, _mod) do { \

	_info[_n].type = TYPE_STR; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	if (strlen((char*)_rec->_name)) \

		strlcpy((char*)_info[_n].value, (char*)_rec->_name, \

			VALUE_MAXVAL); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while(0)

#define __recinfo_int(_key, _info, _rec, _name, _show, _n, _mod) do { \

	_info[_n].type = TYPE_INT; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	snprintf(_info[_n].value, VALUE_MAXVAL, "%" PRIi32, _rec->_name); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while(0)

#define __recinfo_uint8(_key, _info, _rec, _name, _show, _n, _mod) do { \

	_info[_n].type = TYPE_UINT8; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	snprintf(_info[_n].value, VALUE_MAXVAL, "%" PRIu8, _rec->_name); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while (0)

#define __recinfo_uint16(_key, _info, _rec, _name, _show, _n, _mod) do { \

	_info[_n].type = TYPE_UINT16; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	snprintf(_info[_n].value, VALUE_MAXVAL, "%" PRIu16, _rec->_name); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while (0)

#define __recinfo_uint32(_key, _info, _rec, _name, _show, _n, _mod) do { \

	_info[_n].type = TYPE_UINT32; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	snprintf(_info[_n].value, VALUE_MAXVAL, "%" PRIu32, _rec->_name); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while (0)

#define __recinfo_int_o2(_key,_info,_rec,_name,_show,_op0,_op1,_n, _mod) do { \

	_info[_n].type = TYPE_INT_O; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	if (_rec->_name == 0) strlcpy(_info[_n].value, _op0, VALUE_MAXVAL); \

	if (_rec->_name == 1) strlcpy(_info[_n].value, _op1, VALUE_MAXVAL); \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].opts[0] = _op0; \

	_info[_n].opts[1] = _op1; \

	_info[_n].numopts = 2; \

	_info[_n].can_modify = _mod; \

	_n++; \

} while(0)

#define __recinfo_int_o3(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_n,	\

			 _mod) do { \

	__recinfo_int_o2(_key,_info,_rec,_name,_show,_op0,_op1,_n, _mod); \

	_n--; \

	if (_rec->_name == 2) strlcpy(_info[_n].value, _op2, VALUE_MAXVAL);\

	_info[_n].opts[2] = _op2; \

	_info[_n].numopts = 3; \

	_n++; \

} while(0)

#define __recinfo_int_o4(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_op3,_n, \

			 _mod) do { \

	__recinfo_int_o3(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_n, _mod); \

	_n--; \

	if (_rec->_name == 3) strlcpy(_info[_n].value, _op3, VALUE_MAXVAL); \

	_info[_n].opts[3] = _op3; \

	_info[_n].numopts = 4; \

	_n++; \

} while(0)

#define __recinfo_int_o5(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_op3, \

			 _op4,_n, _mod) do { \

	__recinfo_int_o4(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_op3, \

			  _n,_mod); \

	_n--; \

	if (_rec->_name == 4) strlcpy(_info[_n].value, _op4, VALUE_MAXVAL); \

	_info[_n].opts[4] = _op4; \

	_info[_n].numopts = 5; \

	_n++; \

} while(0)

#define __recinfo_int_o6(_key,_info,_rec,_name,_show,_op0,_op1,_op2, \

			 _op3,_op4,_op5,_n,_mod) do { \

	__recinfo_int_o5(_key,_info,_rec,_name,_show,_op0,_op1,_op2,_op3, \

			 _op4,_n,_mod); \

	_n--; \

	if (_rec->_name == 5) strlcpy(_info[_n].value, _op5, VALUE_MAXVAL); \

	_info[_n].opts[5] = _op5; \

	_info[_n].numopts = 6; \

	_n++; \

} while(0)

#define __recinfo_int_list(_key,_info,_rec,_name,_show,_tbl,_n,_mod) do { \

	_info[_n].type = TYPE_INT_LIST; \

	strlcpy(_info[_n].name, _key, NAME_MAXVAL); \

	_info[_n].value[0] = '\0'; \

	for (unsigned long _i = 0; _i < ARRAY_LEN(_rec->_name); _i++) {	\

		if (_rec->_name[_i] != (unsigned)~0) {			\

			for (unsigned long _j = 0; _j < ARRAY_LEN(_tbl); _j++) {	\

				if (_tbl[_j].value == (int)_rec->_name[_i]) { \

					strcat(_info[_n].value, _tbl[_j].name); \

					strcat(_info[_n].value, ","); \

					break; \

				} \

			} \

		} \

	} \

	/* delete trailing ',' */ \

	if (strrchr(_info[_n].value, ',')) \

		*strrchr(_info[_n].value, ',') = '\0'; \

	_info[_n].data = &_rec->_name; \

	_info[_n].data_len = sizeof(_rec->_name); \

	_info[_n].visible = _show; \

	_info[_n].opts[0] = (void *)&_tbl; \

	_info[_n].numopts = ARRAY_LEN(_tbl); \

	_info[_n].can_modify = _mod; \

	_n++; \

} while (0)

static struct int_list_tbl {

	const char *name;

	int value;

} chap_algs [] = {

	{ "MD5", AUTH_CHAP_ALG_MD5 },

	{ "SHA1", AUTH_CHAP_ALG_SHA1 },

	{ "SHA256", AUTH_CHAP_ALG_SHA256 },

	{ "SHA3-256", AUTH_CHAP_ALG_SHA3_256 },

};

static int idbm_remove_disc_to_node_link(node_rec_t *rec, char *portal);

static void

idbm_recinfo_discovery(discovery_rec_t *r, recinfo_t *ri)

{

	int num = 0;

	__recinfo_int_o2(DISC_STARTUP, ri, r, startup, IDBM_SHOW,

			"manual", "automatic", num, 1);

	__recinfo_int_o6(DISC_TYPE, ri, r, type, IDBM_SHOW,

			"sendtargets", "isns", "offload_send_targets", "slp",

			"static", "fw", num, 0);

	switch (r->type) {

	case DISCOVERY_TYPE_SENDTARGETS:

		__recinfo_str(DISC_ST_ADDR, ri, r,

			address, IDBM_SHOW, num, 0);

		__recinfo_int(DISC_ST_PORT, ri, r,

			port, IDBM_SHOW, num, 0);

		__recinfo_int_o2(DISC_ST_AUTH_METHOD, ri, r,

			u.sendtargets.auth.authmethod,

			IDBM_SHOW, "None", "CHAP", num, 1);

		__recinfo_str(DISC_ST_USERNAME, ri, r,

			u.sendtargets.auth.username, IDBM_SHOW, num, 1);

		__recinfo_str(DISC_ST_PASSWORD, ri, r,

			u.sendtargets.auth.password, IDBM_MASKED, num, 1);

		__recinfo_int(DISC_ST_PASSWORD_LEN, ri, r,

			u.sendtargets.auth.password_length, IDBM_HIDE, num, 1);

		__recinfo_str(DISC_ST_USERNAME_IN, ri, r,

			u.sendtargets.auth.username_in, IDBM_SHOW, num, 1);

		__recinfo_str(DISC_ST_PASSWORD_IN, ri, r,

			u.sendtargets.auth.password_in, IDBM_MASKED, num, 1);

		__recinfo_int(DISC_ST_PASSWORD_IN_LEN, ri, r,

			u.sendtargets.auth.password_in_length, IDBM_HIDE,

			num, 1);

		/* reusing SESSION_CHAP_ALGS */

		__recinfo_int_list(SESSION_CHAP_ALGS, ri, r,

				   u.sendtargets.auth.chap_algs,

				   IDBM_SHOW, chap_algs, num, 1);

		__recinfo_int(DISC_ST_LOGIN_TMO, ri, r,

			u.sendtargets.conn_timeo.login_timeout,

			IDBM_SHOW, num, 1);

		__recinfo_int_o2(DISC_ST_USE_DISC_DAEMON, ri, r,

			u.sendtargets.use_discoveryd,

			IDBM_SHOW, "No", "Yes", num, 1);

		__recinfo_int(DISC_ST_DISC_DAEMON_POLL_INVAL, ri, r,

			u.sendtargets.discoveryd_poll_inval,

			IDBM_SHOW, num, 1);

		__recinfo_int(DISC_ST_REOPEN_MAX, ri, r,

			u.sendtargets.reopen_max,

			IDBM_SHOW, num, 1);

		__recinfo_int(DISC_ST_AUTH_TMO, ri, r,

			u.sendtargets.conn_timeo.auth_timeout,

			IDBM_SHOW, num, 1);

		__recinfo_int(DISC_ST_ACTIVE_TMO, ri, r,

			      u.sendtargets.conn_timeo.active_timeout,

			      IDBM_SHOW, num, 1);

		__recinfo_int(DISC_ST_MAX_RECV_DLEN, ri, r,

			      u.sendtargets.conn_conf.MaxRecvDataSegmentLength,

			      IDBM_SHOW, num, 1);

		break;

	case DISCOVERY_TYPE_ISNS:

		__recinfo_str(DISC_ISNS_ADDR, ri, r,

			address, IDBM_SHOW, num, 0);

		__recinfo_int(DISC_ISNS_PORT, ri, r,

			port, IDBM_SHOW, num, 0);

		__recinfo_int_o2(DISC_ISNS_USE_DISC_DAEMON, ri, r,

			u.isns.use_discoveryd,

			IDBM_SHOW, "No", "Yes", num, 1);

		__recinfo_int(DISC_ISNS_DISC_DAEMON_POLL_INVAL, ri, r,

			u.isns.discoveryd_poll_inval,

			IDBM_SHOW, num, 1);

		break;

	default:

		break;

	}

}

void

idbm_recinfo_node(node_rec_t *r, recinfo_t *ri)

{

	int num = 0, i;

	int iface_type;

	iface_type = iface_get_iptype(&r->iface);

	__recinfo_str(NODE_NAME, ri, r, name, IDBM_SHOW, num, 0);

	__recinfo_int(NODE_TPGT, ri, r, tpgt, IDBM_SHOW, num, 0);

	__recinfo_int_o3(NODE_STARTUP, ri, r, startup,

			IDBM_SHOW, "manual", "automatic", "onboot", num, 1);

	__recinfo_int_o2(NODE_LEADING_LOGIN, ri, r, leading_login, IDBM_SHOW,

			 "No", "Yes", num, 1);

	/*

	 * Note: because we do not add the iface.iscsi_ifacename to

	 * sysfs iscsiadm does some weird matching. We can change the iface

	 * values if a session is not running, but node record ifaces values

	 * have to be changed and so do the iface record ones.

	 *

	 * Users should nornmally not want to change the iface ones

	 * in the node record directly and instead do it through

	 * the iface mode which will do the right thing (although that

	 * needs some locking).

	 */

	__recinfo_str(IFACE_HWADDR, ri, r, iface.hwaddress, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_IPADDR, ri, r, iface.ipaddress, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_ISCSINAME, ri, r, iface.name, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_NETNAME, ri, r, iface.netdev, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_GATEWAY, ri, r, iface.gateway, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_SUBNET_MASK, ri, r, iface.subnet_mask, IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_PREFIX_LEN, ri, r, iface.prefix_len,

			IDBM_SHOW, num, 1);

	/*

	 * svn 780 compat: older versions used node.transport_name and

	 * rec->transport_name

	 */

	__recinfo_str(IFACE_TRANSPORTNAME, ri, r, iface.transport_name,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_INAME, ri, r, iface.iname, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_STATE, ri, r, iface.state, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_VLAN_ID, ri, r, iface.vlan_id, IDBM_SHOW, num,

			 1);

	__recinfo_uint8(IFACE_VLAN_PRIORITY, ri, r, iface.vlan_priority,

			IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_VLAN_STATE, ri, r, iface.vlan_state, IDBM_SHOW,

		      num, 1);

	__recinfo_int(IFACE_NUM, ri, r, iface.iface_num, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_MTU, ri, r, iface.mtu, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_PORT, ri, r, iface.port, IDBM_SHOW, num, 1);

	if (iface_type == ISCSI_IFACE_TYPE_IPV4) {

		__recinfo_str(IFACE_BOOT_PROTO, ri, r, iface.bootproto,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_ALT_CID, ri, r,

			      iface.dhcp_alt_client_id_state, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_DHCP_ALT_CID_STR, ri, r,

			      iface.dhcp_alt_client_id, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_DNS, ri, r, iface.dhcp_dns, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_DHCP_LEARN_IQN, ri, r,

			      iface.dhcp_learn_iqn, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_REQ_VID, ri, r,

			      iface.dhcp_req_vendor_id_state, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_DHCP_VID, ri, r, iface.dhcp_vendor_id_state,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_VID_STR, ri, r, iface.dhcp_vendor_id,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_SLP_DA, ri, r, iface.dhcp_slp_da,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_FRAGMENTATION, ri, r, iface.fragmentation,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_GRAT_ARP, ri, r, iface.gratuitous_arp,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_IN_FORWARD, ri, r,

			      iface.incoming_forwarding, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_TOS_STATE, ri, r, iface.tos_state,

			      IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_TOS, ri, r, iface.tos, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_TTL, ri, r, iface.ttl, IDBM_SHOW, num, 1);

	} else if (iface_type == ISCSI_IFACE_TYPE_IPV6) {

		__recinfo_str(IFACE_IPV6_AUTOCFG, ri, r, iface.ipv6_autocfg,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_LINKLOCAL_AUTOCFG, ri, r,

			      iface.linklocal_autocfg, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_ROUTER_AUTOCFG, ri, r, iface.router_autocfg,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_LINKLOCAL, ri, r, iface.ipv6_linklocal,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_ROUTER, ri, r, iface.ipv6_router,

			      IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_DUP_ADDR_DETECT_CNT, ri, r,

				iface.dup_addr_detect_cnt, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_FLOW_LABEL, ri, r, iface.flow_label,

				 IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_GRAT_NEIGHBOR_ADV, ri, r,

			      iface.gratuitous_neighbor_adv, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_HOP_LIMIT, ri, r, iface.hop_limit,

				IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_MLD, ri, r, iface.mld, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_REACHABLE_TMO, ri, r,

				 iface.nd_reachable_tmo, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_REXMIT_TIME, ri, r,

				 iface.nd_rexmit_time, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_STALE_TMO, ri, r, iface.nd_stale_tmo,

				 IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_RTR_ADV_LINK_MTU, ri, r,

				 iface.router_adv_link_mtu, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_TRAFFIC_CLASS, ri, r, iface.traffic_class,

				IDBM_SHOW, num, 1);

	}

	__recinfo_str(IFACE_DELAYED_ACK, ri, r, iface.delayed_ack, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_TCP_NAGLE, ri, r, iface.nagle, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TCP_WSF_STATE, ri, r, iface.tcp_wsf_state,

		      IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_TCP_WSF, ri, r, iface.tcp_wsf, IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_TCP_TIMER_SCALE, ri, r, iface.tcp_timer_scale,

			IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TCP_TIMESTAMP, ri, r, iface.tcp_timestamp,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_REDIRECT, ri, r, iface.redirect, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_DEF_TMF_TMO, ri, r, iface.def_task_mgmt_tmo,

			 IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_HDRDGST, ri, r, iface.header_digest, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_DATADGST, ri, r, iface.data_digest, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_IMM_DATA, ri, r, iface.immediate_data, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_INITIAL_R2T, ri, r, iface.initial_r2t, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_DSEQ_INORDER, ri, r, iface.data_seq_inorder,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DPDU_INORDER, ri, r, iface.data_pdu_inorder,

		      IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_ERL, ri, r, iface.erl, IDBM_SHOW, num, 1);

	__recinfo_uint32(IFACE_MAX_RECV_DLEN, ri, r, iface.max_recv_dlength,

			 IDBM_SHOW, num, 1);

	__recinfo_uint32(IFACE_FIRST_BURST, ri, r, iface.first_burst_len,

			 IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_MAX_R2T, ri, r, iface.max_out_r2t, IDBM_SHOW,

			 num, 1);

	__recinfo_uint32(IFACE_MAX_BURST, ri, r, iface.max_burst_len, IDBM_SHOW,

			 num, 1);

	__recinfo_str(IFACE_CHAP_AUTH, ri, r, iface.chap_auth, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_BIDI_CHAP, ri, r, iface.bidi_chap, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_STRICT_LOGIN_COMP, ri, r, iface.strict_login_comp,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DISCOVERY_AUTH, ri, r, iface.discovery_auth,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DISCOVERY_LOGOUT, ri, r, iface.discovery_logout,

		      IDBM_SHOW, num, 1);

	__recinfo_str(NODE_DISC_ADDR, ri, r, disc_address, IDBM_SHOW,

		      num, 0);

	__recinfo_int(NODE_DISC_PORT, ri, r, disc_port, IDBM_SHOW,

		      num, 0);

	__recinfo_int_o6(NODE_DISC_TYPE, ri, r, disc_type, IDBM_SHOW,

			 "send_targets", "isns", "offload_send_targets", "slp",

			 "static", "fw", num, 0);

	__recinfo_int(SESSION_INIT_CMDSN, ri, r,

		      session.initial_cmdsn, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_INIT_LOGIN_RETRY, ri, r,

		      session.initial_login_retry_max, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_XMIT_THREAD_PRIORITY, ri, r,

		      session.xmit_thread_priority, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_CMDS_MAX, ri, r,

		      session.cmds_max, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_QDEPTH, ri, r,

		       session.queue_depth, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_NR_SESSIONS, ri, r,

		       session.nr_sessions, IDBM_SHOW, num, 1);

	__recinfo_int_o2(SESSION_AUTH_METHOD, ri, r, session.auth.authmethod,

			 IDBM_SHOW, "None", "CHAP", num, 1);

	__recinfo_str(SESSION_USERNAME, ri, r,

		      session.auth.username, IDBM_SHOW, num, 1);

	__recinfo_str(SESSION_PASSWORD, ri, r,

		      session.auth.password, IDBM_MASKED, num, 1);

	__recinfo_int(SESSION_PASSWORD_LEN, ri, r,

		      session.auth.password_length, IDBM_HIDE, num, 1);

	__recinfo_str(SESSION_USERNAME_IN, ri, r,

		      session.auth.username_in, IDBM_SHOW, num, 1);

	__recinfo_str(SESSION_PASSWORD_IN, ri, r,

		      session.auth.password_in, IDBM_MASKED, num, 1);

	__recinfo_int(SESSION_PASSWORD_IN_LEN, ri, r,

		      session.auth.password_in_length, IDBM_HIDE, num, 1);

	__recinfo_int_list(SESSION_CHAP_ALGS, ri, r,

			   session.auth.chap_algs, IDBM_SHOW, chap_algs, num, 1);

	__recinfo_int(SESSION_REPLACEMENT_TMO, ri, r,

		      session.timeo.replacement_timeout,

		      IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_ABORT_TMO, ri, r,

		      session.err_timeo.abort_timeout,

		      IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_LU_RESET_TMO, ri, r,

		      session.err_timeo.lu_reset_timeout,

		      IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_TGT_RESET_TMO, ri, r,

		      session.err_timeo.tgt_reset_timeout,

		      IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_HOST_RESET_TMO, ri, r,

		      session.err_timeo.host_reset_timeout,

		      IDBM_SHOW, num, 1);

	__recinfo_int_o2(SESSION_FAST_ABORT, ri, r,

			 session.iscsi.FastAbort, IDBM_SHOW, "No", "Yes",

			 num, 1);

	__recinfo_int_o2(SESSION_INITIAL_R2T, ri, r,

			session.iscsi.InitialR2T, IDBM_SHOW,

			"No", "Yes", num, 1);

	__recinfo_int_o2(SESSION_IMM_DATA, ri, r,

			session.iscsi.ImmediateData,

			IDBM_SHOW, "No", "Yes", num, 1);

	__recinfo_int(SESSION_FIRST_BURST, ri, r,

		      session.iscsi.FirstBurstLength, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_MAX_BURST, ri, r,

		      session.iscsi.MaxBurstLength, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_DEF_TIME2RETAIN, ri, r,

		      session.iscsi.DefaultTime2Retain, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_DEF_TIME2WAIT, ri, r,

		      session.iscsi.DefaultTime2Wait, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_MAX_CONNS, ri, r,

		      session.iscsi.MaxConnections, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_MAX_R2T, ri, r,

		      session.iscsi.MaxOutstandingR2T, IDBM_SHOW, num, 1);

	__recinfo_int(SESSION_ERL, ri, r,

		      session.iscsi.ERL, IDBM_SHOW, num, 1);

	__recinfo_int_o2(SESSION_SCAN, ri, r,

			 session.scan, IDBM_SHOW, "manual", "auto",

			 num, 1);

	__recinfo_int(SESSION_REOPEN_MAX, ri, r,

			session.reopen_max, IDBM_SHOW, num, 1);

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

		char key[NAME_MAXVAL];

		sprintf(key, CONN_ADDR, i);

		__recinfo_str(key, ri, r, conn[i].address, IDBM_SHOW, num, 0);

		sprintf(key, CONN_PORT, i);

		__recinfo_int(key, ri, r, conn[i].port, IDBM_SHOW, num, 0);

		sprintf(key, CONN_STARTUP, i);

		__recinfo_int_o3(key, ri, r, conn[i].startup, IDBM_SHOW,

				 "manual", "automatic", "onboot", num, 1);

		sprintf(key, CONN_WINDOW_SIZE, i);

		__recinfo_int(key, ri, r, conn[i].tcp.window_size,

			      IDBM_SHOW, num, 1);

		sprintf(key, CONN_SERVICE_TYPE, i);

		__recinfo_int(key, ri, r, conn[i].tcp.type_of_service,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_LOGOUT_TMO, i);

		__recinfo_int(key, ri, r, conn[i].timeo.logout_timeout,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_LOGIN_TMO, i);

		__recinfo_int(key, ri, r, conn[i].timeo.login_timeout,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_AUTH_TMO, i);

		__recinfo_int(key, ri, r, conn[i].timeo.auth_timeout,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_NOP_INT, i);

		__recinfo_int(key, ri, r, conn[i].timeo.noop_out_interval,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_NOP_TMO, i);

		__recinfo_int(key, ri, r, conn[i].timeo.noop_out_timeout,

				IDBM_SHOW, num, 1);

		sprintf(key, CONN_MAX_XMIT_DLEN, i);

		__recinfo_int(key, ri, r,

			conn[i].iscsi.MaxXmitDataSegmentLength, IDBM_SHOW,

			num, 1);

		sprintf(key, CONN_MAX_RECV_DLEN, i);

		__recinfo_int(key, ri, r,

			conn[i].iscsi.MaxRecvDataSegmentLength, IDBM_SHOW,

			num, 1);

		sprintf(key, CONN_HDR_DIGEST, i);

		__recinfo_int_o4(key, ri, r, conn[i].iscsi.HeaderDigest,

				 IDBM_SHOW, "None", "CRC32C", "CRC32C,None",

				 "None,CRC32C", num, 1);

		sprintf(key, CONN_DATA_DIGEST, i);

		__recinfo_int_o4(key, ri, r, conn[i].iscsi.DataDigest, IDBM_SHOW,

				 "None", "CRC32C", "CRC32C,None",

				 "None,CRC32C", num, 1);

		sprintf(key, CONN_IFMARKER, i);

		__recinfo_int_o2(key, ri, r, conn[i].iscsi.IFMarker, IDBM_SHOW,

				"No", "Yes", num, 1);

		sprintf(key, CONN_OFMARKER, i);

		__recinfo_int_o2(key, ri, r, conn[i].iscsi.OFMarker, IDBM_SHOW,

				"No", "Yes", num, 1);

	}

}

void idbm_recinfo_iface(iface_rec_t *r, recinfo_t *ri)

{

	int num = 0;

	int iface_type;

	iface_type = iface_get_iptype(r);

	__recinfo_str(IFACE_ISCSINAME, ri, r, name, IDBM_SHOW, num, 0);

	__recinfo_str(IFACE_NETNAME, ri, r, netdev, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_IPADDR, ri, r, ipaddress, IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_PREFIX_LEN, ri, r, prefix_len, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_HWADDR, ri, r, hwaddress, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TRANSPORTNAME, ri, r, transport_name,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_INAME, ri, r, iname, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_STATE, ri, r, state, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_VLAN_ID, ri, r, vlan_id, IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_VLAN_PRIORITY, ri, r, vlan_priority,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_VLAN_STATE, ri, r, vlan_state, IDBM_SHOW, num, 1);

	__recinfo_int(IFACE_NUM, ri, r, iface_num, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_MTU, ri, r, mtu, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_PORT, ri, r, port, IDBM_SHOW, num, 1);

	if (iface_type == ISCSI_IFACE_TYPE_IPV4) {

		__recinfo_str(IFACE_BOOT_PROTO, ri, r, bootproto, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_SUBNET_MASK, ri, r, subnet_mask, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_GATEWAY, ri, r, gateway, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_ALT_CID, ri, r,

			      dhcp_alt_client_id_state, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_ALT_CID_STR, ri, r, dhcp_alt_client_id,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_DNS, ri, r, dhcp_dns, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_DHCP_LEARN_IQN, ri, r, dhcp_learn_iqn,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_REQ_VID, ri, r,

			      dhcp_req_vendor_id_state, IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_VID, ri, r, dhcp_vendor_id_state,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_VID_STR, ri, r, dhcp_vendor_id,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_DHCP_SLP_DA, ri, r, dhcp_slp_da, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_FRAGMENTATION, ri, r, fragmentation,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_GRAT_ARP, ri, r, gratuitous_arp, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_IN_FORWARD, ri, r, incoming_forwarding,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_TOS_STATE, ri, r, tos_state, IDBM_SHOW,

			      num, 1);

		__recinfo_uint8(IFACE_TOS, ri, r, tos, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_TTL, ri, r, ttl, IDBM_SHOW, num, 1);

	} else if (iface_type == ISCSI_IFACE_TYPE_IPV6) {

		__recinfo_str(IFACE_IPV6_AUTOCFG, ri, r, ipv6_autocfg,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_LINKLOCAL_AUTOCFG, ri, r, linklocal_autocfg,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_ROUTER_AUTOCFG, ri, r, router_autocfg,

			      IDBM_SHOW, num, 1);

		__recinfo_str(IFACE_LINKLOCAL, ri, r, ipv6_linklocal, IDBM_SHOW,

			      num, 1);

		__recinfo_str(IFACE_ROUTER, ri, r, ipv6_router, IDBM_SHOW,

			      num, 1);

		__recinfo_uint8(IFACE_DUP_ADDR_DETECT_CNT, ri, r,

				dup_addr_detect_cnt, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_FLOW_LABEL, ri, r, flow_label, IDBM_SHOW,

				 num, 1);

		__recinfo_str(IFACE_GRAT_NEIGHBOR_ADV, ri, r,

			      gratuitous_neighbor_adv, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_HOP_LIMIT, ri, r, hop_limit, IDBM_SHOW,

				num, 1);

		__recinfo_str(IFACE_MLD, ri, r, mld, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_REACHABLE_TMO, ri, r,

				 nd_reachable_tmo, IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_REXMIT_TIME, ri, r, nd_rexmit_time,

				 IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_ND_STALE_TMO, ri, r, nd_stale_tmo,

				 IDBM_SHOW, num, 1);

		__recinfo_uint32(IFACE_RTR_ADV_LINK_MTU, ri, r,

				 router_adv_link_mtu, IDBM_SHOW, num, 1);

		__recinfo_uint8(IFACE_TRAFFIC_CLASS, ri, r, traffic_class,

				IDBM_SHOW, num, 1);

	}

	__recinfo_str(IFACE_DELAYED_ACK, ri, r, delayed_ack, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TCP_NAGLE, ri, r, nagle, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TCP_WSF_STATE, ri, r, tcp_wsf_state, IDBM_SHOW,

		      num, 1);

	__recinfo_uint8(IFACE_TCP_WSF, ri, r, tcp_wsf, IDBM_SHOW, num, 1);

	__recinfo_uint8(IFACE_TCP_TIMER_SCALE, ri, r, tcp_timer_scale,

			IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_TCP_TIMESTAMP, ri, r, tcp_timestamp, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_REDIRECT, ri, r, redirect, IDBM_SHOW, num, 1);

	__recinfo_uint16(IFACE_DEF_TMF_TMO, ri, r, def_task_mgmt_tmo, IDBM_SHOW,

			 num, 1);

	__recinfo_str(IFACE_HDRDGST, ri, r, header_digest, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DATADGST, ri, r, data_digest, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_IMM_DATA, ri, r, immediate_data, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_INITIAL_R2T, ri, r, initial_r2t, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DSEQ_INORDER, ri, r, data_seq_inorder, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_DPDU_INORDER, ri, r, data_pdu_inorder, IDBM_SHOW,

		      num, 1);

	__recinfo_uint8(IFACE_ERL, ri, r, erl, IDBM_SHOW, num, 1);

	__recinfo_uint32(IFACE_MAX_RECV_DLEN, ri, r, max_recv_dlength,

			 IDBM_SHOW, num, 1);

	__recinfo_uint32(IFACE_FIRST_BURST, ri, r, first_burst_len, IDBM_SHOW,

			 num, 1);

	__recinfo_uint16(IFACE_MAX_R2T, ri, r, max_out_r2t, IDBM_SHOW, num, 1);

	__recinfo_uint32(IFACE_MAX_BURST, ri, r, max_burst_len, IDBM_SHOW,

			 num, 1);

	__recinfo_str(IFACE_CHAP_AUTH, ri, r, chap_auth, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_BIDI_CHAP, ri, r, bidi_chap, IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_STRICT_LOGIN_COMP, ri, r, strict_login_comp,

		      IDBM_SHOW, num, 1);

	__recinfo_str(IFACE_DISCOVERY_AUTH, ri, r, discovery_auth, IDBM_SHOW,

		      num, 1);

	__recinfo_str(IFACE_DISCOVERY_LOGOUT, ri, r, discovery_logout,

		      IDBM_SHOW, num, 1);

}

void idbm_recinfo_host_chap(struct iscsi_chap_rec *r, recinfo_t *ri)

{

	int num = 0;

	__recinfo_uint16(HOST_AUTH_INDEX, ri, r, chap_tbl_idx, IDBM_SHOW,

			 num, 1);

	if (r->chap_type == CHAP_TYPE_OUT) {

		__recinfo_str(HOST_AUTH_USERNAME, ri, r, username, IDBM_SHOW,

			      num, 1);

		__recinfo_str(HOST_AUTH_PASSWORD, ri, r, password, IDBM_MASKED,

			      num, 1);

		__recinfo_int(HOST_AUTH_PASSWORD_LEN, ri, r, password_length,

			      IDBM_HIDE, num, 1);

	} else {

		__recinfo_str(HOST_AUTH_USERNAME_IN, ri, r, username, IDBM_SHOW,

			      num, 1);

		__recinfo_str(HOST_AUTH_PASSWORD_IN, ri, r, password,

			      IDBM_MASKED, num, 1);

		__recinfo_int(HOST_AUTH_PASSWORD_IN_LEN, ri, r, password_length,

			      IDBM_HIDE, num, 1);

	}

}

void idbm_recinfo_flashnode(struct flashnode_rec *r, recinfo_t *ri)

{

	int num = 0;

	int i;

	__recinfo_uint8(FLASHNODE_SESS_AUTO_SND_TGT_DISABLE, ri, r,

			sess.auto_snd_tgt_disable, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_DISCOVERY_SESS, ri, r,

			sess.discovery_session, IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_PORTAL_TYPE, ri, r, sess.portal_type,

		      IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_ENTRY_EN, ri, r,

			sess.entry_enable, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_IMM_DATA_EN, ri, r, sess.immediate_data,

			IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_INITIAL_R2T_EN, ri, r, sess.initial_r2t,

			IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_DATASEQ_INORDER, ri, r,

			sess.data_seq_in_order, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_PDU_INORDER, ri, r,

			sess.data_pdu_in_order, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_CHAP_AUTH_EN, ri, r, sess.chap_auth_en,

			IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_DISCOVERY_LOGOUT_EN, ri, r,

			sess.discovery_logout_en, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_BIDI_CHAP_EN, ri, r, sess.bidi_chap_en,

			IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_DISCOVERY_AUTH_OPTIONAL, ri, r,

			sess.discovery_auth_optional, IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_ERL, ri, r, sess.erl, IDBM_SHOW, num, 1);

	__recinfo_uint32(FLASHNODE_SESS_FIRST_BURST, ri, r,

			 sess.first_burst_len, IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_DEF_TIME2WAIT, ri, r,

			 sess.def_time2wait, IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_DEF_TIME2RETAIN, ri, r,

			 sess.def_time2retain, IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_MAX_R2T, ri, r,

			 sess.max_outstanding_r2t, IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_ISID, ri, r, sess.isid, IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_TSID, ri, r, sess.tsid, IDBM_SHOW,

			 num, 1);

	__recinfo_uint32(FLASHNODE_SESS_MAX_BURST, ri, r, sess.max_burst_len,

			 IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_DEF_TASKMGMT_TMO, ri, r,

			 sess.def_taskmgmt_tmo, IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_ALIAS, ri, r, sess.targetalias, IDBM_SHOW,

		      num, 1);

	__recinfo_str(FLASHNODE_SESS_NAME, ri, r, sess.targetname, IDBM_SHOW,

		      num, 1);

	__recinfo_uint16(FLASHNODE_SESS_DISCOVERY_PARENT_IDX, ri, r,

			 sess.discovery_parent_idx, IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_DISCOVERY_PARENT_TYPE, ri, r,

		      sess.discovery_parent_type, IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_TPGT, ri, r, sess.tpgt, IDBM_SHOW,

			 num, 1);

	__recinfo_uint16(FLASHNODE_SESS_CHAP_OUT_IDX, ri, r, sess.chap_out_idx,

			 IDBM_SHOW, num, 1);

	__recinfo_uint16(FLASHNODE_SESS_CHAP_IN_IDX, ri, r, sess.chap_in_idx,

			 IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_USERNAME, ri, r, sess.username, IDBM_SHOW,

		      num, 1);

	__recinfo_str(FLASHNODE_SESS_USERNAME_IN, ri, r, sess.username_in,

		      IDBM_SHOW, num, 1);

	__recinfo_str(FLASHNODE_SESS_PASSWORD, ri, r, sess.password, IDBM_SHOW,

		      num, 1);

	__recinfo_str(FLASHNODE_SESS_PASSWORD_IN, ri, r, sess.password_in,

		      IDBM_SHOW, num, 1);

	__recinfo_uint8(FLASHNODE_SESS_IS_BOOT_TGT, ri, r, sess.is_boot_target,

			IDBM_SHOW, num, 1);

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

		char key[NAME_MAXVAL];

		sprintf(key, FLASHNODE_CONN_IS_FW_ASSIGNED_IPV6, i);

		__recinfo_uint8(key, ri, r, conn[i].is_fw_assigned_ipv6,

				IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_HDR_DGST_EN, i);

		__recinfo_uint8(key, ri, r, conn[i].header_digest_en, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_DATA_DGST_EN, i);

		__recinfo_uint8(key, ri, r, conn[i].data_digest_en, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_SNACK_REQ_EN, i);

		__recinfo_uint8(key, ri, r, conn[i].snack_req_en, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_TIMESTAMP_STAT, i);

		__recinfo_uint8(key, ri, r, conn[i].tcp_timestamp_stat,

				IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_NAGLE_DISABLE, i);

		__recinfo_uint8(key, ri, r, conn[i].tcp_nagle_disable,

				IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_WSF_DISABLE, i);

		__recinfo_uint8(key, ri, r, conn[i].tcp_wsf_disable, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_TIMER_SCALE, i);

		__recinfo_uint8(key, ri, r, conn[i].tcp_timer_scale, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_TIMESTAMP_EN, i);

		__recinfo_uint8(key, ri, r, conn[i].tcp_timestamp_en,

				IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_IP_FRAG_DISABLE, i);

		__recinfo_uint8(key, ri, r, conn[i].fragment_disable, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_MAX_XMIT_DLENGTH, i);

		__recinfo_uint32(key, ri, r, conn[i].max_xmit_dlength,

				 IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_MAX_RECV_DLENGTH, i);

		__recinfo_uint32(key, ri, r, conn[i].max_recv_dlength,

				 IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_KEEPALIVE_TMO, i);

		__recinfo_uint16(key, ri, r, conn[i].keepalive_tmo, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_PORT, i);

		__recinfo_uint16(key, ri, r, conn[i].port, IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_IPADDR, i);

		__recinfo_str(key, ri, r, conn[i].ipaddress, IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_REDIRECT_IPADDR, i);

		__recinfo_str(key, ri, r, conn[i].redirect_ipaddr, IDBM_SHOW,

			      num, 1);

		sprintf(key, FLASHNODE_CONN_MAX_SEGMENT_SIZE, i);

		__recinfo_uint32(key, ri, r, conn[i].max_segment_size,

				 IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_LOCAL_PORT, i);

		__recinfo_uint16(key, ri, r, conn[i].local_port, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_IPV4_TOS, i);

		__recinfo_uint8(key, ri, r, conn[i].ipv4_tos, IDBM_SHOW,

				num, 1);

		sprintf(key, FLASHNODE_CONN_IPV6_TC, i);

		__recinfo_uint8(key, ri, r, conn[i].ipv6_traffic_class,

				IDBM_SHOW, num, 1);

		sprintf(key, FLASHNODE_CONN_IPV6_FLOW_LABEL, i);

		__recinfo_uint16(key, ri, r, conn[i].ipv6_flow_lbl, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_LINK_LOCAL_IPV6, i);

		__recinfo_str(key, ri, r, conn[i].link_local_ipv6, IDBM_SHOW,

			      num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_XMIT_WSF, i);

		__recinfo_uint32(key, ri, r, conn[i].tcp_xmit_wsf, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_TCP_RECV_WSF, i);

		__recinfo_uint32(key, ri, r, conn[i].tcp_recv_wsf, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_STATSN, i);

		__recinfo_uint32(key, ri, r, conn[i].stat_sn, IDBM_SHOW,

				 num, 1);

		sprintf(key, FLASHNODE_CONN_EXP_STATSN, i);

		__recinfo_uint32(key, ri, r, conn[i].exp_stat_sn, IDBM_SHOW,

				 num, 1);

	}