xref: /onnv-gate/usr/src/cmd/isns/isnsd/dump.c (revision 7836:4e95154b5b7a)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* This file is getting large unexpectly, a lex & yacc */
/* implementation is expected. */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>

#include "isns_server.h"
#include "isns_htab.h"
#include "isns_msgq.h"
#include "isns_obj.h"
#include "isns_func.h"
#include "isns_dd.h"
#include "isns_cache.h"
#include "isns_pdu.h"

#ifdef DEBUG
/*
 * external variables
 */
extern const int NUM_OF_CHILD[MAX_OBJ_TYPE];
extern const int TYPE_OF_CHILD[MAX_OBJ_TYPE][MAX_CHILD_TYPE];
extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];
extern const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE];

extern lookup_ctrl_t *setup_ddid_lcp(lookup_ctrl_t *, uint32_t);
extern lookup_ctrl_t *setup_ddsid_lcp(lookup_ctrl_t *, uint32_t);

/*
 * global variables
 */
int verbose_mc = 0;
int verbose_tc = 0;
int verbose_lock = 0;
int verbose_net = 0;
int verbose_parser = 0;

/*
 * local variables
 */
static void print_entity(char *, isns_obj_t *);
static void print_iscsi(char *, isns_obj_t *);
static void print_portal(char *, isns_obj_t *);
static void print_pg(char *, isns_obj_t *);
static void print_dd(char *, isns_obj_t *);
static void print_dds(char *, isns_obj_t *);
static void (*const print_func[MAX_OBJ_TYPE])(char *, isns_obj_t *) = {
	NULL,
	&print_entity,
	&print_iscsi,
	&print_portal,
	&print_pg,
	&print_dd,
	&print_dds
};
static int run_cmd(char *);

typedef struct {
	uint16_t func_id;
	char *fname;
} isnsp_fnames_t;
isnsp_fnames_t fnames[] = {
{ ISNS_DEV_ATTR_REG, "DevAttrReg" },
{ ISNS_DEV_ATTR_QRY, "DevAttrQry" },
{ ISNS_DEV_GET_NEXT, "DevGetNext" },
{ ISNS_DEV_DEREG, "DevDereg" },
{ ISNS_SCN_REG, "SCNReg" },
{ ISNS_SCN_DEREG, "SCNDereg" },
{ ISNS_DD_REG, "DDReg" },
{ ISNS_DD_DEREG, "DDDereg" },
{ ISNS_DDS_REG, "DDSReg" },
{ ISNS_DDS_DEREG, "DDSDereg" },
{ ISNS_SCN, "SCN" },
{ ISNS_ESI, "ESI" },
{ ISNS_HEARTBEAT, "Heartbeat" },
{ ISNS_DEV_ATTR_REG_RSP, "DevAttrRegRsp" },
{ ISNS_DEV_ATTR_QRY_RSP, "DevAttrQryRsp" },
{ ISNS_DEV_GET_NEXT_RSP, "DevGetNextRsp" },
{ ISNS_DEV_DEREG_RSP, "DevDeregRsp" },
{ ISNS_SCN_REG_RSP, "SCNRegRsp" },
{ ISNS_SCN_DEREG_RSP, "SCNDeregRsp" },
{ ISNS_SCN_RSP, "SCNRsp" },
{ ISNS_ESI_RSP, "ESIRsp" },
{ 0xFFFF, "Unknown" } };

static char *
get_func_name(
	uint16_t id
)
{
	int i = 0;
	isnsp_fnames_t *fp = &fnames[i ++];
	while (fp->func_id != 0xFFFF) {
		if (fp->func_id == id) {
			return (fp->fname);
		}
		fp = &fnames[i ++];
	}

	return ("UNKNOWN");
}

static char *
get_tlv_tag_name(
	uint32_t tag
)
{
	switch (tag) {
		case ISNS_DELIMITER_ATTR_ID:
			return ("Delimiter");
		case ISNS_EID_ATTR_ID:
			return ("Entity Identifier");
		case ISNS_ENTITY_PROTOCOL_ATTR_ID:
			return ("Entity Protocol");
		case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
			return ("Registration Period");
		case ISNS_TIMESTAMP_ATTR_ID:
			return ("Timestamp");
		case ISNS_PORTAL_IP_ADDR_ATTR_ID:
			return ("Portal IP Address");
		case ISNS_PORTAL_PORT_ATTR_ID:
			return ("Portal TCP/UDP Port");
		case ISNS_PORTAL_NAME_ATTR_ID:
			return ("Portal Symbolic Name");
		case ISNS_ESI_INTERVAL_ATTR_ID:
			return ("ESI Interval");
		case ISNS_ESI_PORT_ATTR_ID:
			return ("ESI Port");
		case ISNS_SCN_PORT_ATTR_ID:
			return ("SCN Port");
		case ISNS_PORTAL_SEC_BMP_ATTR_ID:
			return ("Portal Security Bitmap");
		case ISNS_ISCSI_NAME_ATTR_ID:
			return ("iSCSI Name");
		case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
			return ("iSCSI Node Type");
		case ISNS_ISCSI_ALIAS_ATTR_ID:
			return ("iSCSI Alias");
		case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
			return ("iSCSI Auth Method");
		case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
			return ("iSCSI SCN Bitmap");
		case ISNS_PG_ISCSI_NAME_ATTR_ID:
			return ("PG iSCSI Name");
		case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
			return ("PG Portal IP Addr");
		case ISNS_PG_PORTAL_PORT_ATTR_ID:
			return ("PG Portal TCP/UDP Port");
		case ISNS_PG_TAG_ATTR_ID:
			return ("PG Tag (PGT)");
		case ISNS_PG_INDEX_ATTR_ID:
			return ("PG Index");
		case ISNS_DD_NAME_ATTR_ID:
			return ("DD Name");
		case ISNS_DD_ID_ATTR_ID:
			return ("DD Index");
		case ISNS_DD_ISCSI_INDEX_ATTR_ID:
			return ("DD ISCSI Node Index");
		case ISNS_DD_ISCSI_NAME_ATTR_ID:
			return ("DD ISCSI Node Name");
		case ISNS_DD_SET_NAME_ATTR_ID:
			return ("DDS Name");
		case ISNS_DD_SET_ID_ATTR_ID:
			return ("DDS Index");
		case ISNS_DD_SET_STATUS_ATTR_ID:
			return ("DDS Status");
		default:
			return ("Unknown");
	}
}

static void
dump_pdu(
	isns_pdu_t *pdu,
	int flag
)
{
	short ver, id, len, flags, xid, seq;

	uint8_t *payload = pdu->payload;
	isns_resp_t *resp;

	/* convert the data */
	if (flag) {
		ver = ntohs(pdu->version);
		id = ntohs(pdu->func_id);
		len = ntohs(pdu->payload_len);
		flags = ntohs(pdu->flags) & 0xFFFF;
		xid = ntohs(pdu->xid);
		seq = ntohs(pdu->seq);
	} else {
		ver = pdu->version;
		id = pdu->func_id;
		len = pdu->payload_len;
		flags = pdu->flags & 0xFFFF;
		xid = pdu->xid;
		seq = pdu->seq;
	}

	/* print the pdu header */
	printf("iSNSP Version: %d\n", ver);
	printf("Function ID: %s\n", get_func_name(id));
	printf("PDU Length: %d\n", len);
	printf("Flags: %x\n", flags);
	printf("    %d... .... .... .... : ISNS_FLAG_CLIENT\n",
	    ((flags & ISNS_FLAG_CLIENT) == 0) ? 0 : 1);
	printf("    .%d.. .... .... .... : ISNS_FLAG_SERVER\n",
	    ((flags & ISNS_FLAG_SERVER) == 0) ? 0 : 1);
	printf("    ..%d. .... .... .... : ISNS_FLAG_AUTH_BLK_PRESENTED\n",
	    ((flags & ISNS_FLAG_AUTH_BLK_PRESENTED) == 0) ? 0 : 1);
	printf("    ...%d .... .... .... : ISNS_FLAG_REPLACE_REG\n",
	    ((flags & ISNS_FLAG_REPLACE_REG) == 0) ? 0 : 1);
	printf("    .... %d... .... .... : ISNS_FLAG_LAST_PDU\n",
	    ((flags & ISNS_FLAG_LAST_PDU) == 0) ? 0 : 1);
	printf("    .... .%d.. .... .... : ISNS_FLAG_FIRST_PDU\n",
	    ((flags & ISNS_FLAG_FIRST_PDU) == 0) ? 0 : 1);
	printf("Transaction ID: %d\n", xid);
	printf("Sequence ID: %d\n", seq);

	printf("Payload: ...\n");
	if (id & ISNS_RSP_MASK) {
		resp = (isns_resp_t *)payload;
		printf("    ErrorCode: %d\n", ntohl(resp->status));
		len -= 4;
		payload += 4;
	}

	/* print the payload */
	while (len > 0) {
		isns_tlv_t *tlvp;
		int t, l;
		uint8_t *v;
		char *s;
		int i;
		in6_addr_t *ip;
		char pbuff[256] = { 0 };

		tlvp = (isns_tlv_t *)payload;

		/* convert the data */
		t = ntohl(tlvp->attr_id);
		l = ntohl(tlvp->attr_len);
		v = &(tlvp->attr_value[0]);

		/* print payload */
		if (l > 0) {
			printf("%s: ", get_tlv_tag_name(t));
			switch (t) {
				case ISNS_EID_ATTR_ID:
				case ISNS_ISCSI_NAME_ATTR_ID:
				case ISNS_ISCSI_ALIAS_ATTR_ID:
				case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
				case ISNS_PG_ISCSI_NAME_ATTR_ID:
				case ISNS_DD_NAME_ATTR_ID:
				case ISNS_DD_SET_NAME_ATTR_ID:
					s = (char *)v;
					printf("%s\n", s);
					break;
				case ISNS_ENTITY_PROTOCOL_ATTR_ID:
					i = ntohl(*(uint32_t *)v);
					printf("%s (%d)\n",
					    ((i == 1) ? "No Protocol" :
					    ((i == 2) ? "iSCSI" :
					    ((i == 3) ? "iFCP" :
					    "Others"))),
					    i);
					break;
				case ISNS_PORTAL_IP_ADDR_ATTR_ID:
				case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
					ip = (in6_addr_t *)v;
					inet_ntop(AF_INET6, (void *)ip,
					    pbuff, sizeof (pbuff));
					printf("%s\n", pbuff);
					break;
				case ISNS_PORTAL_PORT_ATTR_ID:
				case ISNS_ESI_PORT_ATTR_ID:
				case ISNS_SCN_PORT_ATTR_ID:
					i = ntohl(*(uint32_t *)v);
					printf("%d\n", (i & 0x0000FFFF));
					printf("    .... .... %d... .... : "
					    "0=TCP\n",
					    ((i & 0x10000) == 0) ? 0 : 1);
					break;
				case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
					i = ntohl(*(uint32_t *)v);
					printf("0x%x\t", i);
					if (i & ISNS_CONTROL_NODE_TYPE) {
						printf("Control ");
					}
					if (i & ISNS_INITIATOR_NODE_TYPE) {
						printf("Initiator ");
					}
					if (i & ISNS_TARGET_NODE_TYPE) {
						printf("Target ");
					}
					printf("\n");
					break;
				case ISNS_PG_TAG_ATTR_ID:
				default:
					i = ntohl(*(uint32_t *)v);
					printf("%d\n", i);
					break;
			}
			printf("    Attribute Tag: %s (%d)\n",
			    get_tlv_tag_name(t), t);
			printf("    Attribute Length: %d\n", l);
		} else {
			printf("%s: (%d)\n", get_tlv_tag_name(t), t);
		}

		len -= (sizeof (uint32_t) * 2 + l);
		payload += (sizeof (uint32_t) * 2 + l);
	}
}

void
dump_pdu1(
	isns_pdu_t *pdu
)
{
	if (verbose_net) {
		printf("### PDU RECEIVED ###\n");
		dump_pdu(pdu, 0);
	}
}

void
dump_pdu2(
	isns_pdu_t *pdu
)
{
	if (verbose_net) {
		printf("### PDU SENT ###\n");
		dump_pdu(pdu, 1);
	}
}

void
dump_db(
)
{
#if 0
	isns_list_t *list, *lista, *listb;
	isns_dds_t *dds;
	isns_dd_t *dd;
	isns_iscsi2_t *iscsi2;

	printf("### DUMP DATABASE ###\n");
	/* dump dds(s) */
	list = dds_list;
	while (list != NULL) {
		dds = list->obj.dds;
		printf("[DDS:%d]%s(%s)\n", dds->id, dds->name,
		    dds->status ? "enabled" : "disabled");
		lista = dds->dd_list;
		/* dd(s) that belong to this dds */
		while (lista != NULL) {
			dd = lista->obj.dd;
			printf("\t[DD:%d]%s\n", dd->id, dd->name);
			lista = lista->next;
		}
		list = list->next;
	}
	/* dump dd(s) */
	list = dd_list;
	while (list != NULL) {
		dd = list->obj.dd;
		printf("[DD:%d]%s\n", dd->id, dd->name);
		/* dds(s) this dd belongs to */
		lista = dd->dds_list;
		while (lista != NULL) {
			dds = lista->obj.dds;
			printf("\t[DDS:%d]%s\n", dds->id, dds->name);
			lista = lista->next;
		}
		/* node(s) that this dd have */
		listb = dd->iscsi_list;
		while (listb != NULL) {
			iscsi2 = listb->obj.iscsi2;
			printf("\t[ISCSI:%d]%s\n", iscsi2->id, iscsi2->name);
			listb = listb->next;
		}
		list = list->next;
	}
	/* dump node(s) */
	list = iscsi_list;
	while (list != NULL) {
		iscsi2 = list->obj.iscsi2;
		printf("[ISCSI:%d]%s\n", iscsi2->id, iscsi2->name);
		lista = iscsi2->dd_list;
		/* dd(s) that this node belongs to */
		while (lista != NULL) {
			dd = lista->obj.dd;
			printf("\t[DD:%d]%s\n", dd->id, dd->name);
			lista = lista->next;
		}
		list = list->next;
	}
#endif
}

static void
test_cli_help(
)
{
	printf("list          - list all of storage node.\n");
	printf("list dd  [id] - list all of dd or one with member.\n");
	printf("list dds [id] - list all of dd-set or one with member.\n");

	printf("\n");
	printf("new dd  <name>  - create a dd with name.\n");
	printf("new dds <name>  - create a dd-set with name.\n");
	printf("new ddn  <id> <name>  - create a dd with id and name.\n");
	printf("new ddsn <id> <name>  - create a dd-set with id and name.\n");
	printf("del dd   <id>   - delete a dd.\n");
	printf("del dds  <id>   - delete a dd-set.\n");

	printf("\n");
	printf("add dd   <dd_id>  <node_name> - add a node to dd.\n");
	printf("add ddn  <dd_id>  <node_id>   - add a node to dd.\n");
	printf("add ddsn <dds_id> <dd_id>     - add a dd to dd-set.\n");
	printf("remove dd   <dd_id> <node_name> - remove a node from dd.\n");
	printf("remove ddn  <dd_id> <node_id>   - remove a node from dd.\n");
	printf("remove ddsn <dds_id> <dd_id>    - remove a dd from dd-set.\n");

	printf("\n");
	printf("enable  <dds_id> - enable a dd-set.\n");
	printf("disable <dds_id> - disable a dd-set.\n");

	printf("\n");
	printf("file <f> - loading command from a file.\n");
	printf("pause    - suspend batch until enter key is pressed.\n");

	printf("help   - print this help.\n");
	printf("quit   - stop iSNS server and quit.\n");
}

static enum {
	CMD_LIST, CMD_LISTNE, CMD_LISTP, CMD_LISTPG,
	CMD_LISTDD, CMD_LISTDDS, CMD_LISTDDN, CMD_LISTDDSN,
	CMD_NEWDD, CMD_NEWDDS, CMD_NEWDDN, CMD_NEWDDSN,
	CMD_DELDD, CMD_DELDDS,
	CMD_ENABLE, CMD_DISABLE,
	CMD_ADDDD, CMD_ADDDDN, CMD_ADDDDSN,
	CMD_REMDD, CMD_REMDDN, CMD_REMDDSN,
	CMD_VIEW,
	CMD_FILE, CMD_PAUSE,
	CMD_HELP,
	CMD_VERBOSE_MEMORY, CMD_VERBOSE_NET,
	CMD_VERBOSE_PARSER, CMD_VERBOSE_TIME,
	CMD_VERBOSE_LOCK,
	CMD_QUIT,
	CMD_NONE, CMD_INVALID
};

static int
getcmd(
	int *argc, int *argv, char *cmd
)
{
	int j = 0;
	char tmp[256] = { 0 };
	*argc = 0;
	while (*cmd == ' ') cmd ++;

	if (*cmd == 0) {
		return (CMD_NONE);
	} else if (*cmd == '?') {
		return (CMD_HELP);
	}

	/* list, list dd, list dds, list dd 0 */
	if (strncmp(cmd, "list ", 5) == 0) {
		cmd += 5;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0) {
			return (CMD_LIST);
		} else if (*cmd == 'p') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_LISTP);
			}
		} else if (*cmd == 'g') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_LISTPG);
			}
		} else if (*cmd == 'e') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_LISTNE);
			}
		} else if (strncmp(cmd, "dds ", 4) == 0) {
			cmd += 4;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_LISTDDS);
			}
			j = 0;
			while (*cmd >= '0' && *cmd <= '9') {
				tmp[j++] = *cmd ++;
			}
			tmp[j] = 0;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0 && j > 0) {
				argv[(*argc)++] = atoi(tmp);
				return (CMD_LISTDDSN);
			}
		} else if (strncmp(cmd, "dd ", 3) == 0) {
			cmd += 3;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_LISTDD);
			}
			j = 0;
			while (*cmd >= '0' && *cmd <= '9') {
				tmp[j++] = *cmd ++;
			}
			tmp[j] = 0;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0 && j > 0) {
				argv[(*argc)++] = atoi(tmp);
				return (CMD_LISTDDN);
			}
		}
		return (CMD_INVALID);
	}

	/* view 0 */
	if (strncmp(cmd, "view ", 5) == 0) {
		cmd += 5;
		while (*cmd == ' ') cmd ++;
		j = 0;
		while (*cmd >= '0' && *cmd <= '9') {
			tmp[j++] = *cmd ++;
		}
		tmp[j] = 0;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0 && j > 0) {
			argv[(*argc)++] = atoi(tmp);
			return (CMD_VIEW);
		}
		return (CMD_INVALID);
	}

	/* add dd name */
	/* add ddn/ddsn id id */
	if (strncmp(cmd, "add ", 4) == 0) {
		int addcmd = CMD_INVALID;
		cmd += 4;
		while (*cmd == ' ') cmd ++;
		if (strncmp(cmd, "dd ", 3) == 0) {
			cmd += 3;
			addcmd = CMD_ADDDD;
		} else if (strncmp(cmd, "ddn ", 4) == 0) {
			cmd += 4;
			addcmd = CMD_ADDDDN;
		} else if (strncmp(cmd, "ddsn ", 5) == 0) {
			cmd += 5;
			addcmd = CMD_ADDDDSN;
		} else {
			return (CMD_INVALID);
		}
		while (*cmd == ' ') cmd ++;
		j = 0;
		while (*cmd >= '0' && *cmd <= '9') {
			tmp[j++] = *cmd ++;
		}
		tmp[j] = 0;
		if (j > 0) {
			argv[(*argc)++] = atoi(tmp);
		} else {
			return (CMD_INVALID);
		}
		while (*cmd == ' ') cmd ++;
		if (*cmd != 0) {
			switch (addcmd) {
			case CMD_ADDDDN:
			case CMD_ADDDDSN:
				j = 0;
				while (*cmd >= '0' && *cmd <= '9') {
					tmp[j++] = *cmd ++;
				}
				tmp[j] = 0;
				while (*cmd == ' ') cmd ++;
				if (*cmd == 0 && j > 0) {
					argv[(*argc)++] = atoi(tmp);
				} else {
					return (CMD_INVALID);
				}
				break;
			case CMD_ADDDD:
				j = strlen(cmd);
				while (j > 0) {
					/* get rid of trail blank space */
					if (cmd[j - 1] == ' ') {
						cmd[--j] = 0;
					} else {
						break;
					}
				}
				if (j > 0) {
					cmd[j] = 0;
					argv[(*argc)++] = (int)cmd;
				} else {
					return (CMD_INVALID);
				}
				break;
			}
			return (addcmd);
		}
		return (CMD_INVALID);
	}

	/* remove dd name */
	/* remove ddn/ddsn id id */
	if (strncmp(cmd, "remove ", 7) == 0) {
		int rmcmd = CMD_INVALID;
		cmd += 7;
		while (*cmd == ' ') cmd ++;
		if (strncmp(cmd, "dd ", 3) == 0) {
			cmd += 3;
			while (*cmd == ' ') cmd ++;
			rmcmd = CMD_REMDD;
		} else if (strncmp(cmd, "ddn ", 4) == 0) {
			cmd += 4;
			while (*cmd == ' ') cmd ++;
			rmcmd = CMD_REMDDN;
		} else if (strncmp(cmd, "ddsn ", 5) == 0) {
			cmd += 5;
			while (*cmd == ' ') cmd ++;
			rmcmd = CMD_REMDDSN;
		} else {
			return (CMD_INVALID);
		}
		j = 0;
		while (*cmd >= '0' && *cmd <= '9') {
			tmp[j++] = *cmd ++;
		}
		tmp[j] = 0;
		if (j > 0) {
			argv[(*argc)++] = atoi(tmp);
		} else {
			return (CMD_INVALID);
		}
		while (*cmd == ' ') cmd ++;
		if (*cmd != 0) {
			switch (rmcmd) {
			case CMD_REMDDN:
			case CMD_REMDDSN:
				j = 0;
				while (*cmd >= '0' && *cmd <= '9') {
					tmp[j++] = *cmd ++;
				}
				tmp[j] = 0;
				while (*cmd == ' ') cmd ++;
				if (*cmd == 0 && j > 0) {
					argv[(*argc)++] = atoi(tmp);
				} else {
					return (CMD_INVALID);
				}
				break;
			case CMD_REMDD:
				j = strlen(cmd);
				while (j > 0) {
					/* get rid of trail blank space */
					if (cmd[j - 1] == ' ') {
						cmd[--j] = 0;
					} else {
						break;
					}
				}
				if (j > 0) {
					cmd[j] = 0;
					argv[(*argc)++] = (int)cmd;
				} else {
					return (CMD_INVALID);
				}
				break;
			}
			return (rmcmd);
		}
		return (CMD_INVALID);
	}

	/* new dd, new dds */
	if (strncmp(cmd, "new ", 4) == 0) {
		int newcmd = CMD_INVALID;
		cmd += 4;
		while (*cmd == ' ') cmd ++;
		if (strncmp(cmd, "dd ", 3) == 0) {
			cmd += 3;
			newcmd = CMD_NEWDD;
		} else if (strncmp(cmd, "dds ", 4) == 0) {
			cmd += 4;
			newcmd = CMD_NEWDDS;
		} else if (strncmp(cmd, "ddn ", 4) == 0) {
			cmd += 4;
			newcmd = CMD_NEWDDN;
		} else if (strncmp(cmd, "ddsn ", 5) == 0) {
			cmd += 5;
			newcmd = CMD_NEWDDSN;
		}
		if (newcmd != CMD_INVALID) {
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (newcmd);
			}
			switch (newcmd) {
			case CMD_NEWDDN:
			case CMD_NEWDDSN:
				j = 0;
				while (*cmd >= '0' && *cmd <= '9') {
					tmp[j++] = *cmd ++;
				}
				tmp[j] = 0;
				if (*cmd == ' ' && j > 0) {
					argv[(*argc)++] = atoi(tmp);
				} else {
					return (CMD_INVALID);
				}
			case CMD_NEWDD:
			case CMD_NEWDDS:
				while (*cmd == ' ') cmd ++;
				if (*cmd != 0) {
					j = strlen(cmd);
				} else {
					j = 0;
				}
				while (j > 0) {
					/* get rid of trail blank space */
					if (cmd[j - 1] == ' ') {
						cmd[--j] = 0;
					} else {
						break;
					}
				}
				if (j > 0) {
					cmd[j] = 0;
					argv[(*argc)++] = (int)cmd;
				}
			}
			return (newcmd);
		}
		return (CMD_INVALID);
	}

	/* del dd, del dds, disable 0 */
	if (strncmp(cmd, "del ", 4) == 0) {
		int delcmd = CMD_INVALID;
		cmd += 4;
		while (*cmd == ' ') cmd ++;
		if (strncmp(cmd, "dds ", 4) == 0) {
			cmd += 4;
			delcmd = CMD_DELDDS;
		} else if (strncmp(cmd, "dd ", 3) == 0) {
			cmd += 3;
			delcmd = CMD_DELDD;
		}
		if (delcmd != CMD_INVALID) {
			while (*cmd == ' ') cmd ++;
			j = 0;
			while (*cmd >= '0' && *cmd <= '9') {
				tmp[j++] = *cmd ++;
			}
			tmp[j] = 0;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0 && j > 0) {
				argv[(*argc)++] = atoi(tmp);
				return (delcmd);
			}
		}
		return (CMD_INVALID);
	}

	/* enable 0 */
	if (strncmp(cmd, "enable ", 7) == 0) {
		cmd += 7;
		while (*cmd == ' ') cmd ++;
		j = 0;
		while (*cmd >= '0' && *cmd <= '9') {
			tmp[j++] = *cmd ++;
		}
		tmp[j] = 0;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0 && j > 0) {
			argv[(*argc)++] = atoi(tmp);
			return (CMD_ENABLE);
		}
		return (CMD_INVALID);
	}

	/* disable 0 */
	if (strncmp(cmd, "disable ", 8) == 0) {
		cmd += 8;
		while (*cmd == ' ') cmd ++;
		j = 0;
		while (*cmd >= '0' && *cmd <= '9') {
			tmp[j++] = *cmd ++;
		}
		tmp[j] = 0;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0 && j > 0) {
			argv[(*argc)++] = atoi(tmp);
			return (CMD_DISABLE);
		}
		return (CMD_INVALID);
	}

	/* file */
	if (strncmp(cmd, "file ", 5) == 0) {
		cmd += 5;
		while (*cmd == ' ') cmd ++;
		if (*cmd != 0) {
			j = strlen(cmd);
		} else {
			j = 0;
		}
		while (j > 0) {
			/* get rid of trail blank space */
			if (cmd[j - 1] == ' ') {
				cmd[--j] = 0;
			} else {
				break;
			}
		}
		if (j > 0) {
			cmd[j] = 0;
			argv[(*argc)++] = (int)cmd;
			return (CMD_FILE);
		}
		return (CMD_INVALID);
	}

	/* pause */
	if (strncmp(cmd, "pause ", 6) == 0) {
		cmd += 6;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0) {
			return (CMD_PAUSE);
		}
		return (CMD_INVALID);
	}

	/* help */
	if (strncmp(cmd, "help ", 5) == 0) {
		cmd += 5;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0) {
			return (CMD_HELP);
		}
		return (CMD_INVALID);
	}

	/* verbose */
	if (strncmp(cmd, "verbose ", 8) == 0) {
		cmd += 8;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0) {
			return (CMD_VERBOSE_PARSER);
		} else if (*cmd == 'm') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_VERBOSE_MEMORY);
			}
		} else if (*cmd == 'n') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_VERBOSE_NET);
			}
		} else if (*cmd == 'p') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_VERBOSE_PARSER);
			}
		} else if (*cmd == 't') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_VERBOSE_TIME);
			}
		} else if (*cmd == 'l') {
			cmd ++;
			while (*cmd == ' ') cmd ++;
			if (*cmd == 0) {
				return (CMD_VERBOSE_LOCK);
			}
		}
		return (CMD_INVALID);
	}

	/* quit */
	if (strncmp(cmd, "quit ", 5) == 0) {
		cmd += 5;
		while (*cmd == ' ') cmd ++;
		if (*cmd == 0) {
			return (CMD_QUIT);
		}
		return (CMD_INVALID);
	}

	return (CMD_INVALID);
}

static void
print_entity(
	char *ident,
	isns_obj_t *obj
)
{
	uint32_t uid;
	uchar_t *eid;
	uint32_t *cuid;
	int i, num;

	eid = obj->attrs[
	    ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)].value.ptr;
	uid = get_obj_uid(obj);

	if (ident != NULL) {
		printf("%s%d\t%s\n", ident, uid, (const char *)eid);
	} else {
		printf("%d\t%s\n", uid, (const char *)eid);
	}

	i = 0;
	while (i < NUM_OF_CHILD[obj->type]) {
		cuid = get_child_n(obj, i);
		if (ident != NULL) {
			printf("%s\t%s%d:", "child", i);
		} else {
			printf("\t%s%d:", "child", i);
		}
		if (cuid != NULL) {
			num = *cuid ++;
		} else {
			num = 0;
		}
		while (num > 0) {
			printf("\t%d", *cuid ++);
			num --;
		}
		printf("\n");
		i ++;
	}
}

static void
print_iscsi(
	char *ident,
	isns_obj_t *obj
)
{
	uchar_t *name = obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)]
	    .value.ptr;
	uchar_t *alias = obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_ALIAS_ATTR_ID)]
	    .value.ptr;
	uint32_t type = obj->attrs[
	    ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui;
	uint32_t uid = get_obj_uid(obj);
	uint32_t puid = get_parent_uid(obj);

	if (!alias) {
		alias = (uchar_t *)"-";
	}

	if (ident != NULL) {
		printf("%s%d[%d]\t%s\n", ident,
		    uid, puid, (const char *)name);
		printf("%s\t%s", ident, alias);
	} else {
		printf("%d[%d]\t%s\n",
		    uid, puid, (const char *)name);
		printf("\t%s", alias);
	}
	if (IS_TYPE_TARGET(type)) {
		printf("\tTarget");
	}
	if (IS_TYPE_INITIATOR(type)) {
		printf("\tInitiator");
	}
	if (IS_TYPE_CONTROL(type)) {
		printf("\tControl");
	}
	if (IS_TYPE_UNKNOWN(type)) {
		printf("\t-");
	}
	printf("\n");
}

static void
print_portal(
	char *ident,
	isns_obj_t *obj
)
{
	char pbuff[256] = { 0 };
	in6_addr_t *ip = obj->attrs[
	    ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
	uint32_t port = obj->attrs[
	    ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)].value.ui;
	uint32_t uid = get_obj_uid(obj);
	uint32_t puid = get_parent_uid(obj);

	inet_ntop(AF_INET6, (void *)ip, pbuff, sizeof (pbuff));
	if (ident != NULL) {
		printf("%s%d[%d]\t%s:%d", ident,
		    uid, puid, pbuff, PORT_NUMBER(port));
	} else {
		printf("%d[%d]\t%s:%d",
		    uid, puid, pbuff, PORT_NUMBER(port));
	}
	printf(" %s\n", IS_PORT_UDP(port) ? "UDP" : "TCP");
}

static void
print_pg(
	char *ident,
	isns_obj_t *obj
)
{
	uint32_t ref;
	int i;

	char pbuff[256] = { 0 };
	uchar_t *name = obj->attrs[ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID)]
	    .value.ptr;
	in6_addr_t *ip = obj->attrs[
	    ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
	uint32_t port = obj->attrs[
	    ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID)].value.ui;
	uint32_t tag = obj->attrs[
	    ATTR_INDEX_PG(ISNS_PG_TAG_ATTR_ID)].value.ui;
	uint32_t uid = get_obj_uid(obj);
	uint32_t puid = get_parent_uid(obj);

	inet_ntop(AF_INET6, (void *)ip, pbuff, sizeof (pbuff));
	if (ident != NULL) {
		printf("%s%d[%d]\t[%d] %s\n", ident,
		    uid, puid, tag, (const char *)name);
		printf("%s\t%s:%d", ident, pbuff, PORT_NUMBER(port));
	} else {
		printf("%d[%d]\t[%d] %s\n",
		    uid, puid, tag, (const char *)name);
		printf("\t%s:%d", pbuff, PORT_NUMBER(port));
	}
	printf(" %s\n", IS_PORT_UDP(port) ? "UDP" : "TCP");

	if (NUM_OF_REF[obj->type] > 0) {
		if (ident != NULL) {
			printf("%s\t%s:", "ref");
		} else {
			printf("\t%s:", "ref");
		}
	}
	i = 0;
	while (i < NUM_OF_REF[obj->type]) {
		ref = get_ref_n(obj, i);
		printf("\t%d", ref);
		i ++;
	}
	if (i > 0) {
		printf("\n");
	}
}

static void
print_dd(
	char *ident,
	isns_obj_t *obj
)
{
	uchar_t *name = obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)]
	    .value.ptr;
	uint32_t uid = obj->attrs[UID_ATTR_INDEX[OBJ_DD]].value.ui;

	if (ident != NULL) {
		printf("%s%d\t%s\n", ident, uid, (const char *)name);
	} else {
		printf("%d\t%s\n", uid, (const char *)name);
	}
}

static void
print_dds(
	char *ident,
	isns_obj_t *obj
)
{
	uchar_t *name = obj->attrs[ATTR_INDEX_DDS(
	    ISNS_DD_SET_NAME_ATTR_ID)].value.ptr;
	uint32_t uid = obj->attrs[UID_ATTR_INDEX[OBJ_DDS]].value.ui;
	uint32_t enabled = obj->attrs[ATTR_INDEX_DDS(
	    ISNS_DD_SET_STATUS_ATTR_ID)].value.ui;

	if (ident != NULL) {
		printf("%s%d\t%s\t\t(%s)\n", ident, uid,
		    (const char *)name, enabled ? "enabled" : "disabled");
	} else {
		printf("%d\t%s\t\t(%s)\n", uid,
		    (const char *)name, enabled ? "enabled" : "disabled");
	}
}

void
print_object(
	char *ident,
	isns_obj_t *obj
)
{
	print_func[obj->type](ident, obj);
}

/*ARGSUSED*/
static int
cb_print_obj_n(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	print_func[obj->type](NULL, obj);

	return (0);
}

static void
list_pg(
)
{
	cache_dump_htab(OBJ_PG);
}

static void
list_portal(
)
{
	cache_dump_htab(OBJ_PORTAL);
}

static void
list_node(
)
{
	cache_dump_htab(OBJ_ISCSI);
}

static void
list_entity(
)
{
	cache_dump_htab(OBJ_ENTITY);
}

static void
list_dd(
)
{
	cache_dump_htab(OBJ_DD);
}

static void
list_ddn(
	uint32_t uid
)
{
	lookup_ctrl_t lc;

	bmp_t *p;
	uint32_t n;

	if (uid != 0) {
		setup_ddid_lcp(&lc, uid);
		cache_lookup(&lc, &uid, cb_print_obj_n);
	}

	if (uid != 0) {
		printf("--------------------------------\n");
		get_dd_matrix(uid, &p, &n);
		SET_UID_LCP(&lc, OBJ_ISCSI, 0);
		FOR_EACH_MEMBER(p, n, uid, {
			lc.data[0].ui = uid;
			cache_lookup(&lc, NULL, cb_print_obj_n);
		});
		free(p);
	} else {
		printf("no such dd.\n");
	}
}

static void
list_ddsn(
	uint32_t uid
)
{
	lookup_ctrl_t lc;

	bmp_t *p;
	uint32_t n;

	if (uid != 0) {
		setup_ddsid_lcp(&lc, uid);
		cache_lookup(&lc, &uid, cb_print_obj_n);
	}

	if (uid != 0) {
		printf("--------------------------------\n");
		get_dds_matrix(uid, &p, &n);
		SET_UID_LCP(&lc, OBJ_DD, 0);
		FOR_EACH_MEMBER(p, n, uid, {
			lc.data[0].ui = uid;
			cache_lookup(&lc, NULL, cb_print_obj_n);
		});
		free(p);
	} else {
		printf("no such dd-set.\n");
	}
}

static void
list_dds(
)
{
	cache_dump_htab(OBJ_DDS);
}

static void
new_dd_dds(
	int cmd_id,
	int argc,
	int *argv
)
{
	uint32_t buff[256];
	isns_pdu_t *pdu = (isns_pdu_t *)buff;
	uint8_t *payload = &pdu->payload[0];
	uint16_t payload_len = 0;
	isns_tlv_t *tlv;

	int len = 0;
	uint32_t uid = 0;
	char *name;

	conn_arg_t conn;

	pdu->version = ISNSP_VERSION;

	/* source attribute */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_ISCSI_NAME_ATTR_ID);
	tlv->attr_len = htonl(32);
	strcpy((char *)tlv->attr_value, "i am a control node.");
	payload += 8 + 32;
	payload_len += 8 + 32;

	/* key attributes */

	/* delimiter */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DELIMITER_ATTR_ID);
	tlv->attr_len = htonl(0);
	payload += 8 + 0;
	payload_len += 8 + 0;

	/* operating attributes */
	switch (cmd_id) {
	case CMD_NEWDD:
		pdu->func_id = ISNS_DD_REG;
		if (argc == 1) {
			name = (char *)argv[0];
			len = strlen(name) + 1;
			len += 4 - (len % 4);
		}
		tlv = (isns_tlv_t *)payload;
		tlv->attr_id = htonl(ISNS_DD_NAME_ATTR_ID);
		tlv->attr_len = htonl(len);
		if (len > 0) {
			strcpy((char *)tlv->attr_value, name);
		}
		payload_len += 8 + len;
		break;
	case CMD_NEWDDS:
		pdu->func_id = ISNS_DDS_REG;
		if (argc == 1) {
			name = (char *)argv[0];
			len = strlen(name) + 1;
			len += 4 - (len % 4);
		}
		tlv = (isns_tlv_t *)payload;
		tlv->attr_id = htonl(ISNS_DD_SET_NAME_ATTR_ID);
		tlv->attr_len = htonl(len);
		if (len > 0) {
			strcpy((char *)tlv->attr_value, name);
		}
		payload_len += 8 + len;
		break;
	case CMD_NEWDDN:
		pdu->func_id = ISNS_DD_REG;
		switch (argc) {
		case 2:
			name = (char *)argv[1];
			len = strlen(name) + 1;
			len += 4 - (len % 4);
		case 1:
			uid = argv[0];
		}
		tlv = (isns_tlv_t *)payload;
		tlv->attr_id = htonl(ISNS_DD_NAME_ATTR_ID);
		tlv->attr_len = htonl(len);
		if (len > 0) {
			strcpy((char *)tlv->attr_value, name);
		}
		payload += 8 + len;
		payload_len += 8 + len;
		if (uid > 0) {
			tlv = (isns_tlv_t *)payload;
			tlv->attr_id = htonl(ISNS_DD_ID_ATTR_ID);
			tlv->attr_len = htonl(4);
			*(uint32_t *)tlv->attr_value = htonl(uid);
			payload_len += 8 + 4;
		}
		break;
	case CMD_NEWDDSN:
		pdu->func_id = ISNS_DDS_REG;
		switch (argc) {
		case 2:
			name = (char *)argv[1];
			len = strlen(name) + 1;
			len += 4 - (len % 4);
		case 1:
			uid = argv[0];
		}
		tlv = (isns_tlv_t *)payload;
		tlv->attr_id = htonl(ISNS_DD_SET_NAME_ATTR_ID);
		tlv->attr_len = htonl(len);
		if (len > 0) {
			strcpy((char *)tlv->attr_value, name);
		}
		payload_len += 8 + len;
		payload += 8 + len;
		if (uid > 0) {
			tlv = (isns_tlv_t *)payload;
			tlv->attr_id = htonl(ISNS_DD_SET_ID_ATTR_ID);
			tlv->attr_len = htonl(4);
			*(uint32_t *)tlv->attr_value = htonl(uid);
			payload_len += 8 + 4;
		}
		break;
	default:
		break;
	}

	pdu->payload_len = payload_len;

	dump_pdu1(pdu);

	conn.in_packet.pdu = pdu;
	conn.out_packet.pdu = NULL;
	conn.out_packet.sz = 0;

	if (packet_split_verify(&conn) == 0) {
		cache_lock(conn.lock);
		conn.handler(&conn);
		conn.ec = cache_unlock(conn.lock, conn.ec);
	}

	if (conn.out_packet.pdu != NULL) {
		pdu_update_code(conn.out_packet.pdu,
		    &conn.out_packet.pl, conn.ec);
		dump_pdu2(conn.out_packet.pdu);
		free(conn.out_packet.pdu);
	} else if (conn.ec != 0) {
		printf("operation failed[%d].\n", conn.ec);
	}
}

static void
del_dd_dds(
	int cmd_id,
	int uid
)
{
	uint32_t buff[256];
	isns_pdu_t *pdu = (isns_pdu_t *)buff;
	uint8_t *payload = &pdu->payload[0];
	uint16_t payload_len = 0;
	isns_tlv_t *tlv;

	uint32_t tag;

	conn_arg_t conn;

	if (uid == 0) {
		return;
	}

	pdu->version = ISNSP_VERSION;

	if (cmd_id == CMD_DELDD) {
		tag = ISNS_DD_ID_ATTR_ID;
		pdu->func_id = ISNS_DD_DEREG;
	} else {
		tag = ISNS_DD_SET_ID_ATTR_ID;
		pdu->func_id = ISNS_DDS_DEREG;
	}

	/* source attribute */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_ISCSI_NAME_ATTR_ID);
	tlv->attr_len = htonl(32);
	strcpy((char *)tlv->attr_value, "i am a control node.");
	payload_len += 8 + 32;
	payload += 8 + 32;

	/* key attributes */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(tag);
	tlv->attr_len = htonl(4);
	*(uint32_t *)tlv->attr_value = htonl(uid);
	payload_len += 8 + 4;
	payload += 8 + 4;

	/* delimiter */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DELIMITER_ATTR_ID);
	tlv->attr_len = htonl(0);
	payload_len += 8 + 0;
	payload += 8 + 0;

	/* operating attributes */

	pdu->payload_len = payload_len;

	dump_pdu1(pdu);

	conn.in_packet.pdu = pdu;
	conn.out_packet.pdu = NULL;
	conn.out_packet.sz = 0;

	if (packet_split_verify(&conn) == 0) {
		cache_lock(conn.lock);
		conn.handler(&conn);
		conn.ec = cache_unlock(conn.lock, conn.ec);
	}

	if (conn.out_packet.pdu != NULL) {
		pdu_update_code(conn.out_packet.pdu,
		    &conn.out_packet.pl, conn.ec);
		dump_pdu2(conn.out_packet.pdu);
		free(conn.out_packet.pdu);
	} else if (conn.ec != 0) {
		printf("operation failed[%d].\n", conn.ec);
	}
}

static void
update_dds(
	int cmd_id,
	int uid
)
{
	uint32_t buff[256];
	isns_pdu_t *pdu = (isns_pdu_t *)buff;
	uint8_t *payload = &pdu->payload[0];
	uint16_t payload_len = 0;
	isns_tlv_t *tlv;

	conn_arg_t conn;

	if (uid == 0) {
		return;
	}

	pdu->version = ISNSP_VERSION;

	pdu->func_id = ISNS_DDS_REG;

	/* source attribute */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_ISCSI_NAME_ATTR_ID);
	tlv->attr_len = htonl(32);
	strcpy((char *)tlv->attr_value, "i am a control node.");
	payload_len += 8 + 32;
	payload += 8 + 32;

	/* key attributes */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DD_SET_ID_ATTR_ID);
	tlv->attr_len = htonl(4);
	*(uint32_t *)tlv->attr_value = htonl(uid);
	payload_len += 8 + 4;
	payload += 8 + 4;

	/* delimiter */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DELIMITER_ATTR_ID);
	tlv->attr_len = htonl(0);
	payload_len += 8 + 0;
	payload += 8 + 0;

	/* operating attributes */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DD_SET_STATUS_ATTR_ID);
	tlv->attr_len = htonl(4);
	if (cmd_id == CMD_ENABLE) {
		*(uint32_t *)tlv->attr_value = htonl(1);
	} else {
		*(uint32_t *)tlv->attr_value = htonl(0);
	}
	payload_len += 8 + 4;

	pdu->payload_len = payload_len;

	dump_pdu1(pdu);

	conn.in_packet.pdu = pdu;
	conn.out_packet.pdu = NULL;
	conn.out_packet.sz = 0;

	if (packet_split_verify(&conn) == 0) {
		cache_lock(conn.lock);
		conn.handler(&conn);
		conn.ec = cache_unlock(conn.lock, conn.ec);
	}

	if (conn.out_packet.pdu != NULL) {
		pdu_update_code(conn.out_packet.pdu,
		    &conn.out_packet.pl, conn.ec);
		dump_pdu2(conn.out_packet.pdu);
		free(conn.out_packet.pdu);
	} else if (conn.ec != 0) {
		printf("operation failed[%d].\n", conn.ec);
	}
}

static void
update_member(
	int cmd_id,
	int *argv
)
{
	uint32_t buff[256];
	isns_pdu_t *pdu = (isns_pdu_t *)buff;
	uint8_t *payload = &pdu->payload[0];
	uint16_t payload_len = 0;
	isns_tlv_t *tlv;
	uint32_t key_tag, op_tag, op_len;

	uint32_t uid = argv[0];
	uint32_t m_id;
	char *m_name;

	conn_arg_t conn;

	if (uid == 0) {
		printf("operation failed.\n");
		return;
	}

	pdu->version = ISNSP_VERSION;

	switch (cmd_id) {
	case CMD_ADDDD:
	case CMD_ADDDDN:
		pdu->func_id = ISNS_DD_REG;
		break;
	case CMD_REMDD:
	case CMD_REMDDN:
		pdu->func_id = ISNS_DD_DEREG;
		break;
	case CMD_ADDDDSN:
		pdu->func_id = ISNS_DDS_REG;
		break;
	case CMD_REMDDSN:
		pdu->func_id = ISNS_DDS_DEREG;
		break;
	}
	switch (cmd_id) {
	case CMD_ADDDD:
	case CMD_REMDD:
		key_tag = ISNS_DD_ID_ATTR_ID;
		op_tag = ISNS_DD_ISCSI_NAME_ATTR_ID;
		m_name = (char *)argv[1];
		op_len = strlen(m_name);
		op_len += 4 - (op_len % 4);
		break;
	case CMD_ADDDDN:
	case CMD_REMDDN:
		key_tag = ISNS_DD_ID_ATTR_ID;
		op_tag = ISNS_DD_ISCSI_INDEX_ATTR_ID;
		m_id = argv[1];
		op_len = 4;
		break;
	case CMD_ADDDDSN:
	case CMD_REMDDSN:
		key_tag = ISNS_DD_SET_ID_ATTR_ID;
		op_tag = ISNS_DD_ID_ATTR_ID;
		m_id = argv[1];
		op_len = 4;
		break;
	}

	/* source attribute */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_ISCSI_NAME_ATTR_ID);
	tlv->attr_len = htonl(32);
	strcpy((char *)tlv->attr_value, "i am a control node.");
	payload_len += 8 + 32;
	payload += 8 + 32;

	/* key attributes */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(key_tag);
	tlv->attr_len = htonl(4);
	*(uint32_t *)tlv->attr_value = htonl(uid);
	payload_len += 8 + 4;
	payload += 8 + 4;

	/* delimiter */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(ISNS_DELIMITER_ATTR_ID);
	tlv->attr_len = htonl(0);
	payload_len += 8 + 0;
	payload += 8 + 0;

	/* operating attributes */
	tlv = (isns_tlv_t *)payload;
	tlv->attr_id = htonl(op_tag);
	tlv->attr_len = htonl(op_len);
	switch (cmd_id) {
	case CMD_ADDDD:
	case CMD_REMDD:
		strcpy((char *)tlv->attr_value, m_name);
		break;
	case CMD_ADDDDN:
	case CMD_ADDDDSN:
	case CMD_REMDDN:
	case CMD_REMDDSN:
		*(uint32_t *)tlv->attr_value = htonl(m_id);
		break;
	}
	payload_len += 8 + op_len;

	pdu->payload_len = payload_len;

	dump_pdu1(pdu);

	conn.in_packet.pdu = pdu;
	conn.out_packet.pdu = NULL;
	conn.out_packet.sz = 0;

	if (packet_split_verify(&conn) == 0) {
		cache_lock(conn.lock);
		conn.handler(&conn);
		conn.ec = cache_unlock(conn.lock, conn.ec);
	}

	if (conn.out_packet.pdu != NULL) {
		pdu_update_code(conn.out_packet.pdu,
		    &conn.out_packet.pl, conn.ec);
		dump_pdu2(conn.out_packet.pdu);
		free(conn.out_packet.pdu);
	} else if (conn.ec != 0) {
		printf("operation failed[%d].\n", conn.ec);
	}
}

static void
cmd_file(
	char *file
)
{
	char i = 0, ch, cmd[256];
	FILE *f = fopen(file, "r");
	if (f != NULL) {
		while ((ch = fgetc(f)) != 0 && ch != EOF) {
			if (ch == '\t') {
				cmd[i++] = ' ';
			} else if (ch != '\n') {
				cmd[i++] = ch;
			} else {
				cmd[i ++] = ' ';
				cmd[i] = 0;
				i = 0;
				printf("%s\n", cmd);
				if (run_cmd(cmd) != 0) {
					break;
				}
			}
		}
		fclose(f);
	} else {
		printf("Cannot open file %s.\n", file);
	}
}

static int
run_cmd(
	char *cmd
)
{
	int argc, argv[32];
	int cmd_id;
	cmd_id = getcmd(&argc, argv, cmd);
	switch (cmd_id) {
		case CMD_LIST:
			list_node();
			break;
		case CMD_LISTNE:
			list_entity();
			break;
		case CMD_LISTP:
			list_portal();
			break;
		case CMD_LISTPG:
			list_pg();
			break;
		case CMD_LISTDD:
			list_dd();
			break;
		case CMD_LISTDDS:
			list_dds();
			break;
		case CMD_LISTDDN:
			list_ddn(argv[0]);
			break;
		case CMD_LISTDDSN:
			list_ddsn(argv[0]);
			break;
		case CMD_NEWDD:
		case CMD_NEWDDS:
		case CMD_NEWDDN:
		case CMD_NEWDDSN:
			new_dd_dds(cmd_id, argc, argv);
			break;
		case CMD_DELDD:
		case CMD_DELDDS:
			del_dd_dds(cmd_id, argv[0]);
			break;
		case CMD_ENABLE:
		case CMD_DISABLE:
			update_dds(cmd_id, argv[0]);
			break;
		case CMD_ADDDD:
		case CMD_ADDDDN:
		case CMD_ADDDDSN:
		case CMD_REMDD:
		case CMD_REMDDN:
		case CMD_REMDDSN:
			update_member(cmd_id, argv);
			break;
		case CMD_PAUSE:
			printf("Press enter to continue...");
			getchar();
			break;
		case CMD_FILE:
			cmd_file((char *)argv[0]);
			break;
		case CMD_HELP:
			test_cli_help();
			break;
		case CMD_VERBOSE_MEMORY:
			verbose_mc = !verbose_mc;
			break;
		case CMD_VERBOSE_NET:
			verbose_net = !verbose_net;
			break;
		case CMD_VERBOSE_TIME:
			verbose_tc = !verbose_tc;
			break;
		case CMD_VERBOSE_LOCK:
			verbose_lock = !verbose_lock;
			break;
		case CMD_VERBOSE_PARSER:
			verbose_parser = !verbose_parser;
			break;
		case CMD_QUIT:
			/* clean up cli */
			/* notify sys control */
			shutdown_server();
			return (1);
		case CMD_NONE:
			break;
		default:
			printf("invalid command\n");
			break;
	}
	if (cmd_id != CMD_NONE) {
		printf("\n>");
	} else {
		printf(">");
	}
	return (0);
}

/*ARGSUSED*/
void *cli_test(void *arg) {
	char i = 0, ch, cmd[256];

	printf("iSNS Server test CLI.\n");
	printf("Copyright 2007 Sun Microsystems, Inc.\n");

	printf("\n>");
	while ((ch = getchar()) != 0 && ch != EOF) {
		if (ch == '\t') {
			cmd[i++] = ' ';
		} else if (ch != '\n') {
			cmd[i++] = ch;
		} else {
			cmd[i ++] = ' ';
			cmd[i] = 0;
			i = 0;
			if (run_cmd(cmd) != 0) {
				break;
			}
		}
	}

	return (NULL);
}
#endif