xref: /illumos-gate/usr/src/cmd/isns/isnsd/obj.c (revision a2b0e4f1)

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include "isns_server.h"
#include "isns_msgq.h"
#include "isns_htab.h"
#include "isns_cache.h"
#include "isns_pdu.h"
#include "isns_obj.h"
#include "isns_dd.h"
#include "isns_func.h"
#include "isns_dseng.h"
#include "isns_log.h"
#include "isns_scn.h"
#include "isns_utils.h"
#include "isns_esi.h"

/*
 * external variables
 */
#ifdef DEBUG
extern int verbose_mc;
extern void print_object(char *, isns_obj_t *);
#endif

extern msg_queue_t *sys_q;
extern msg_queue_t *scn_q;

extern pthread_mutex_t el_mtx;

extern int cache_flag;

/*
 * global data
 */

/*
 * local variables
 */
/* type of parent object */
const int TYPE_OF_PARENT[MAX_OBJ_TYPE_FOR_SIZE] = {
	0,
	0,
	ISCSI_PARENT_TYPE,
	PORTAL_PARENT_TYPE,
	PG_PARENT_TYPE,
	0,	/* OBJ_DD */
	0,	/* OBJ_DDS */
	0,	/* MAX_OBJ_TYPE */
	0,	/* OBJ_DUMMY1 */
	0,	/* OBJ_DUMMY2 */
	0,	/* OBJ_DUMMY3 */
	0,	/* OBJ_DUMMY4 */
	ASSOC_ISCSI_PARENT_TYPE,
	ASSOC_DD_PARENT_TYPE
};

/* number of children object type */
const int NUM_OF_CHILD[MAX_OBJ_TYPE] = {
	0,
	MAX_ENTITY_CHILD,
	MAX_ISCSI_CHILD,
	MAX_PORTAL_CHILD,
	MAX_PG_CHILD,
	0,
	0
};

/* type of a child object */
const int TYPE_OF_CHILD[MAX_OBJ_TYPE][MAX_CHILD_TYPE] = {
	{ 0, 0 },
	{ OBJ_ISCSI, OBJ_PORTAL },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 }
};

/* number of attributes of certain type of object */
const int NUM_OF_ATTRS[MAX_OBJ_TYPE_FOR_SIZE] = {
	0,
	NUM_OF_ENTITY_ATTRS,
	NUM_OF_ISCSI_ATTRS,
	NUM_OF_PORTAL_ATTRS,
	NUM_OF_PG_ATTRS,
	NUM_OF_DD_ATTRS,
	NUM_OF_DDS_ATTRS,
	0,			/* MAX_OBJ_TYPE */
	0,			/* OBJ_DUMMY1 */
	0,			/* OBJ_DUMMY2 */
	0,			/* OBJ_DUMMY3 */
	0,			/* OBJ_DUMMY4 */
	NUM_OF_ASSOC_ISCSI_ATTRS,
	NUM_OF_ASSOC_DD_ATTRS
};

/* the tag of UID of each type of object */
static const int UID_TAG[MAX_OBJ_TYPE_FOR_SIZE] = {
	0,
	ISNS_ENTITY_INDEX_ATTR_ID,
	ISNS_ISCSI_NODE_INDEX_ATTR_ID,
	ISNS_PORTAL_INDEX_ATTR_ID,
	ISNS_PG_INDEX_ATTR_ID,
	ISNS_DD_ID_ATTR_ID,
	ISNS_DD_SET_ID_ATTR_ID,
	0,			/* MAX_OBJ_TYPE */
	0,			/* OBJ_DUMMY1 */
	0,			/* OBJ_DUMMY2 */
	0,			/* OBJ_DUMMY3 */
	0,			/* OBJ_DUMMY4 */
	ISNS_DD_ISCSI_INDEX_ATTR_ID,
	ISNS_DD_ID_ATTR_ID
};

/* the index of UID of each type of object */
const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE] = {
	0,
	ATTR_INDEX_ENTITY(ISNS_ENTITY_INDEX_ATTR_ID),
	ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_INDEX_ATTR_ID),
	ATTR_INDEX_PORTAL(ISNS_PORTAL_INDEX_ATTR_ID),
	ATTR_INDEX_PG(ISNS_PG_INDEX_ATTR_ID),
	ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID),
	ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID),
	0,			/* MAX_OBJ_TYPE */
	0,			/* OBJ_DUMMY1 */
	0,			/* OBJ_DUMMY2 */
	0,			/* OBJ_DUMMY3 */
	0,			/* OBJ_DUMMY4 */
	ATTR_INDEX_ASSOC_ISCSI(ISNS_DD_ISCSI_INDEX_ATTR_ID),
	ATTR_INDEX_ASSOC_DD(ISNS_DD_ID_ATTR_ID)
};

/* the index of the key attributes of each type of object */
static const int KEY_ATTR_INDEX[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
	{ 0 },
	{ ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID), 0 },
	{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID),
		0 },
	{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
		ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID),
		0 },
	{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID),
		ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
		ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
	{ ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID), 0 },
	{ ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID), 0 }
};

/* the operating methods for key attributes of each type of object */
static const int KEY_ATTR_OP[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
	{ 0 },
	{ OP_STRING, 0 },
	{ OP_STRING, 0 },
	{ OP_MEMORY_IP6, OP_INTEGER, 0 },
	{ OP_STRING, OP_MEMORY_IP6, OP_INTEGER },
	{ OP_STRING, 0 },
	{ OP_STRING, 0 }
};

/* the size of each type of object */
static const int SIZEOF_OBJ[MAX_OBJ_TYPE_FOR_SIZE] = {
	0,
	sizeof (isns_entity_t),
	sizeof (isns_iscsi_t),
	sizeof (isns_portal_t),
	sizeof (isns_pg_t),
	sizeof (isns_dd_t),
	sizeof (isns_dds_t),
	0,
	0,
	0,
	0,
	0,
	sizeof (isns_assoc_iscsi_t),
	sizeof (isns_assoc_dd_t)
};

#ifdef DEBUG
const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
#else
static const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
#endif
	0,
	0,
	0,
	0,
	PG_REF_COUNT,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0
};

/* the type of the reference object */
static const int TYPE_OF_REF[MAX_OBJ_TYPE][MAX_REF_COUNT + 1] = {
	{ 0 },
	{ 0 },
	{ OBJ_PG, OBJ_PORTAL, 0 },
	{ OBJ_PG, OBJ_ISCSI, 0 },
	{ 0, OBJ_ISCSI, OBJ_PORTAL },
	{ 0 },
	{ 0 }
};

/* the operating method for match operation of the reference object */
#define	MAX_REF_MATCH	(2)
static const int REF_MATCH_OPS[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
	{ 0, 0 },
	{ 0, 0 },
	{ OP_STRING, 0 },
	{ OP_MEMORY_IP6, OP_INTEGER },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 }
};

/* the index of the attribute of being matched object */
static const int REF_MATCH_ID1[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
	{ 0, 0 },
	{ 0, 0 },
	{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID), 0 },
	{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
		ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID) },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 }
};

/* the index of the attribute of matching object */
static const int REF_MATCH_ID2[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
	{ 0, 0 },
	{ 0, 0 },
	{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID), 0 },
	{ ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
		ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 }
};

/*
 * local functions.
 */
static uint32_t get_reg_period();
static char *make_unique_name(int *, uint32_t);
static lookup_ctrl_t *set_lookup_ctrl(lookup_ctrl_t *, isns_obj_t *);
static int setup_ref_lcp(lookup_ctrl_t *,
	const isns_obj_t *, const isns_obj_t *);
static int setup_deref_lcp(lookup_ctrl_t *,
	const isns_obj_t *, isns_type_t);
static int cb_get_parent(void *, void *);
static int cb_node_child(void *, void *);
static int cb_set_ref(void *, void *);
static int cb_clear_ref(void *, void *);
static int cb_add_child(void *, void *);
static int cb_remove_child(void *, void *);
static int cb_verify_ref(void *, void *);
static int cb_ref_new2old(void *, void *);
static int cb_new_ref(void *, void *);
static int ref_new2old(
	lookup_ctrl_t *, isns_type_t, uint32_t, const isns_obj_t *);
static int ref_new2new(
	lookup_ctrl_t *, const isns_obj_t *, const isns_obj_t *);
static int new_ref(const isns_obj_t *, const isns_obj_t *);
static uint32_t setup_parent_lcp(lookup_ctrl_t *, isns_obj_t *);
static int set_obj_offline(isns_obj_t *);
static int copy_attrs(isns_obj_t *, const isns_obj_t *);

static isns_obj_t *make_default_pg(const isns_obj_t *, const isns_obj_t *);
static isns_obj_t *(*const make_ref[MAX_OBJ_TYPE])
	(const isns_obj_t *, const isns_obj_t *) = {
		NULL,
		NULL,
		&make_default_pg,
		&make_default_pg,
		NULL,
		NULL,
		NULL
};

static uint32_t entity_hval(void *, uint16_t, uint32_t *);
static uint32_t iscsi_hval(void *, uint16_t, uint32_t *);
static uint32_t portal_hval(void *, uint16_t, uint32_t *);
static uint32_t pg_hval(void *, uint16_t, uint32_t *);
static uint32_t dd_hval(void *, uint16_t, uint32_t *);
static uint32_t dds_hval(void *, uint16_t, uint32_t *);
static uint32_t (*const hval_func[MAX_OBJ_TYPE])
	(void *, uint16_t, uint32_t *) = {
		NULL,
		&entity_hval,
		&iscsi_hval,
		&portal_hval,
		&pg_hval,
		&dd_hval,
		&dds_hval
};

/*
 * ****************************************************************************
 *
 * entity_hval:
 *	caculate the hash value of a network entity object.
 *
 * p	- the pointer pointers to network entity object or
 *	  the lookup control data, both have the key attribute
 *	  of a network entity object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
entity_hval(
	void *p,
	/* LINTED E_FUNC_ARG_UNUSED */
	uint16_t chunk,
	uint32_t *flags
)
{
	uchar_t *key;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p pointers to a network entity object */
		obj = (isns_obj_t *)p;
		key = obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)].
		    value.ptr;
	} else {
		/* p is lookup control data */
		lcp = (lookup_ctrl_t *)p;
		key = lcp->data[0].ptr;
	}

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * iscsi_hval:
 *	caculate the hash value of an iscsi storage node object.
 *
 * p	- the pointer pointers to iscsi storage node object or
 *	  the lookup control data, both have the key attribute
 *	  of an iscsi storage node object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
iscsi_hval(
	void *p,
	/* LINTED E_FUNC_ARG_UNUSED */
	uint16_t chunk,
	uint32_t *flags
)
{
	uchar_t *key;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p pointers to an iscsi storage node object */
		obj = (isns_obj_t *)p;
		key = obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)].
		    value.ptr;
	} else {
		/* p is lookup control data */
		lcp = (lookup_ctrl_t *)p;
		key = lcp->data[0].ptr;
	}

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * portal_hval:
 *	caculate the hash value of a portal object.
 *
 * p	- the pointer pointers to a portal object or the lookup control
 *	  data, both have the key attributes of a portal object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
portal_hval(
	void *p,
	/* LINTED E_FUNC_ARG_UNUSED */
	uint16_t chunk,
	uint32_t *flags
)
{
	char buff[INET6_ADDRSTRLEN + 8] = { 0 };
	char buff2[8] = { 0 };
	uchar_t *key;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	in6_addr_t *ip;
	uint32_t port;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p pointers to a portal object */
		obj = (isns_obj_t *)p;
		ip = obj->attrs[ATTR_INDEX_PORTAL
		    (ISNS_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
		port = obj->attrs[ATTR_INDEX_PORTAL
		    (ISNS_PORTAL_PORT_ATTR_ID)].value.ui;
	} else {
		/* p is lookup control data */
		lcp = (lookup_ctrl_t *)p;
		ip = lcp->data[0].ip;
		port = lcp->data[1].ui;
	}

	key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
	    buff, sizeof (buff));
	(void) snprintf(buff2, sizeof (buff2), "%d", port);
	(void) strcat((char *)key, buff2);

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * pg_hval:
 *	caculate the hash value of a portal group object.
 *
 * p	- the pointer pointers to a portal group object or the lookup
 *	  control data, both have the key attributes of a portal object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
pg_hval(
	void *p,
	uint16_t chunk,
	uint32_t *flags
)
{
	char buff[INET6_ADDRSTRLEN + 8] = { 0 };
	char buff2[8] = { 0 };
	uchar_t *key = NULL;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	in6_addr_t *ip = NULL;
	uint32_t port;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p is a portal group object */
		obj = (isns_obj_t *)p;
		if (chunk == 0) {
			/* the first chunk */
			key = obj->attrs[ATTR_INDEX_PG
			    (ISNS_PG_ISCSI_NAME_ATTR_ID)].value.ptr;
		} else {
			/* another chunk */
			ip = obj->attrs[ATTR_INDEX_PG
			    (ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
			port = obj->attrs[ATTR_INDEX_PG
			    (ISNS_PG_PORTAL_PORT_ATTR_ID)].value.ui;
		}
	} else {
		/* p is a lookup control data */
		lcp = (lookup_ctrl_t *)p;
		/* clear the chunk flags */
		*flags &= ~FLAGS_CHUNK_MASK;
		if (lcp->op[0] == OP_STRING) {
			/* the first chunk */
			key = lcp->data[0].ptr;
		} else {
			/* another chunk */
			ip = lcp->data[0].ip;
			port = lcp->data[1].ui;
			*flags |= 1;
		}
	}

	if (key == NULL) {
		key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
		    buff, sizeof (buff));
		(void) snprintf(buff2, sizeof (buff2), "%d", port);
		(void) strcat((char *)key, buff2);
	}

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * dd_hval:
 *	caculate the hash value of a DD object.
 *
 * p	- the pointer pointers to a DD object or the lookup control data,
 *	  both have the key attributes of a DD object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
dd_hval(
	void *p,
	/* LINTED E_FUNC_ARG_UNUSED */
	uint16_t chunk,
	uint32_t *flags
)
{
	uchar_t *key;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p is a DD object */
		obj = (isns_obj_t *)p;
		key = obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)].
		    value.ptr;
	} else {
		/* p is a lookup control data */
		lcp = (lookup_ctrl_t *)p;
		key = lcp->data[0].ptr;
	}

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * dds_hval:
 *	caculate the hash value of a DD-set object.
 *
 * p	- the pointer pointers to a DD-set object or the lookup control data,
 *	  both have the key attributes of a DD-set object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
static uint32_t
dds_hval(
	void *p,
	/* LINTED E_FUNC_ARG_UNUSED */
	uint16_t chunk,
	uint32_t *flags
)
{
	uchar_t *key;
	isns_obj_t *obj;
	lookup_ctrl_t *lcp;

	if ((*flags & FLAGS_CTRL_MASK) == 0) {
		/* p is a DD-set object */
		obj = (isns_obj_t *)p;
		key = obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)].
		    value.ptr;
	} else {
		/* p is lookup control data */
		lcp = (lookup_ctrl_t *)p;
		key = lcp->data[0].ptr;
	}

	return (htab_compute_hval(key));
}

/*
 * ****************************************************************************
 *
 * obj_hval:
 *	caculate the hash value of an object.
 *
 * p	- the pointer pointers to an object or lookup control data,
 *	  both has the object type and the key attributes of an object.
 * chunk- which chunk of the hash table.
 * flags- pointer to flags.
 * return - the hash value.
 *
 * ****************************************************************************
 */
uint32_t
obj_hval(
	void *p,
	uint16_t chunk,
	uint32_t *flags
)
{
	isns_type_t type = ((isns_obj_t *)p)->type;

	return (hval_func[type](p, chunk, flags));
}

/*
 * ****************************************************************************
 *
 * get_obj_uid:
 *	get the UID of an object.
 *
 * p	- the pointer pointers to an object.
 * return - the UID.
 *
 * ****************************************************************************
 */
uint32_t
get_obj_uid(
	const void *p
)
{
	isns_obj_t *obj = (isns_obj_t *)p;
	isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];
	uint32_t uid = attr->value.ui;
	return (uid);
}

/*
 * ****************************************************************************
 *
 * set_obj_uid:
 *	set the UID of an object.
 *
 * p	- the pointer pointers to an object.
 * uid	- the UID.
 * return - the UID.
 *
 * ****************************************************************************
 */
uint32_t
set_obj_uid(
	void *p,
	uint32_t uid
)
{
	isns_obj_t *obj = (isns_obj_t *)p;
	isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];

	/* set the tag, len and value */
	attr->tag = UID_TAG[obj->type];
	attr->len = 4;
	attr->value.ui = uid;

	return (uid);
}

/*
 * ****************************************************************************
 *
 * obj_cmp:
 *	compare between two objects or an object with a lookup control data.
 *
 * p1	- the pointer points to an object.
 * p2	- the pointer points to an object or a lookup control data.
 * flags- 0: p2 is an object; otherwise p2 is a lookup control data.
 * return - the comparsion result.
 *
 * ****************************************************************************
 */
int
obj_cmp(
	void *p1,
	void *p2,
	int flags
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t buff = { 0 };
	lookup_ctrl_t *lcp;
	uint32_t uid;

	if (flags == 0) {
		lcp = set_lookup_ctrl(&buff, (isns_obj_t *)p2);
	} else {
		lcp = (lookup_ctrl_t *)p2;
		uid = get_obj_uid(obj);
		/* the object are linked with decending order by */
		/* the object UID, if the object UID is greater than */
		/* or equal to the current UID, it needs to compare */
		/* for the next one. */
		if (lcp->curr_uid != 0 && uid >= lcp->curr_uid) {
			return (-1);
		}
	}

	return (key_cmp(lcp, obj));
}

/*
 * ****************************************************************************
 *
 * replace_object:
 *	replace an existing object with the new one.
 *
 * p1	- the pointer points to an object being replaced.
 * p2	- the pointer points to a new object.
 * uid_p- points to uid for returning.
 * flag	- 0: do not free the source object, otherwise free it.
 * return - error code.
 *
 * ****************************************************************************
 */
int
replace_object(
	void *p1,
	void *p2,
	uint32_t *uid_p,
	int flag
)
{
	int ec = 0;

#ifndef SKIP_SRC_AUTH
	uint32_t *pp_dst, *pp_src, swap;
#endif
	int online;

	isns_obj_t *dst = (isns_obj_t *)p1;
	isns_obj_t *src = (isns_obj_t *)p2;

	if (src->type == OBJ_DD || src->type == OBJ_DDS) {
		/* replace not allowed */
		return (ERR_NAME_IN_USE);
	}

	online = is_obj_online(dst);

	/* set cache update flag */
	SET_CACHE_UPDATED();

	/* update parent uid */
#ifndef SKIP_SRC_AUTH
	pp_dst = get_parent_p(dst);
	if (pp_dst != NULL) {
		pp_src = get_parent_p(src);
		swap = *pp_dst;
		*pp_dst = *pp_src;
		if (swap != 0) {
			*pp_src = swap;
		}
	}
#endif

	/* update all of attributes */
	if (copy_attrs(dst, src) != 0) {
		return (ISNS_RSP_INTERNAL_ERROR);
	}

	/* free up the src object */
	if (flag != 0) {
		(void) free_object(src);
	} else if (online == 0) {
		(void) set_obj_uid(src, get_obj_uid(dst));
		(void) set_obj_offline(src);
	}

	/* update data store */
	if (sys_q != NULL) {
		ec = write_data(DATA_UPDATE, dst);
	} else {
		/* we should never have duplicated entry in data store */
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	/* trigger a scn */
	if (ec == 0) {
		if (scn_q != NULL) {
			(void) make_scn((online == 0) ?
			    ISNS_OBJECT_ADDED :
			    ISNS_OBJECT_UPDATED,
			    dst);
		}
		if (uid_p != NULL) {
			*uid_p = get_obj_uid(dst);
		}
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * add_object:
 *	post function after adding a new object.
 *
 * p	- object which has been added.
 * return - error code.
 *
 * ****************************************************************************
 */
int
add_object(
	void *p
)
{
	int ec = 0;

	isns_obj_t *obj = (isns_obj_t *)p;

	/* add the new object to data store */
	if (sys_q != NULL) {
		ec = write_data(DATA_ADD, obj);
	}

	/* trigger a scn */
	if (ec == 0 && scn_q != NULL) {
		(void) make_scn(ISNS_OBJECT_ADDED, obj);
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * obj_tab_init:
 *	initialize the object hash tables.
 *
 * c	- points to the cache.
 * return - error code.
 *
 * ****************************************************************************
 */
int
obj_tab_init(
	struct cache *c
)
{
	htab_t *t;

	htab_init();

	/*
	 * allocate an array of pointer for the object hash tables.
	 */
	c->t = (struct htab **)calloc(sizeof (struct htab *), MAX_OBJ_TYPE);
	if (c->t == NULL) {
		return (1);
	}

	/*
	 * hash table for network entity objects.
	 */
	t = htab_create(UID_FLAGS_SEQ, 8, 1);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_ENTITY] = t;
	} else {
		return (1);
	}

	/*
	 * hash table for iscsi storage node objects.
	 */
	t = htab_create(UID_FLAGS_SEQ, 8, 1);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_ISCSI] = t;
	} else {
		return (1);
	}

	/*
	 * hash table for portal objects.
	 */
	t = htab_create(UID_FLAGS_SEQ, 8, 1);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_PORTAL] = t;
	} else {
		return (1);
	}

	/*
	 * hash table for portal group objects.
	 */
	t = htab_create(UID_FLAGS_SEQ, 8, 2);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_PG] = t;
	} else {
		return (1);
	}

	/*
	 * hash table for discovery domain objects.
	 */
	t = htab_create(0, 6, 1);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_DD] = t;
	} else {
		return (1);
	}

	/*
	 * hash table for discovery domain set objects.
	 */
	t = htab_create(0, 4, 1);
	if (t != NULL) {
		t->c = c;
		c->t[OBJ_DDS] = t;
	} else {
		return (1);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * get_ref_np:
 *	get the ref pointer of the portal group object.
 *
 * obj	- portal group object.
 * return - ref pointer.
 *
 * ****************************************************************************
 */
static uint32_t *
get_ref_np(
	isns_obj_t *obj,
	int n
)
{
	uint32_t *refp =
	    obj->type == OBJ_PG ? &((isns_pg_t *)obj)->ref[n] : NULL;

	return (refp);
}

#ifdef DEBUG
uint32_t
#else
static uint32_t
#endif
get_ref_n(
	isns_obj_t *obj,
	int n
)
{
	return (*get_ref_np(obj, n));
}

static uint32_t *
get_ref_p(
	isns_obj_t *obj,
	isns_type_t rt
)
{
	isns_type_t t = obj->type;

	int i = 0;
	while (i < NUM_OF_REF[t]) {
		if (rt == TYPE_OF_REF[t][i + 1]) {
			return (get_ref_np(obj, i));
		}
		i ++;
	}

	return (NULL);
}

uint32_t
get_ref_t(
	isns_obj_t *obj,
	isns_type_t type
)
{
	uint32_t *refp = get_ref_p(obj, type);

	if (refp != NULL) {
		return (*refp);
	/* LINTED E_NOP_ELSE_STMT */
	} else {
		ASSERT(0);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * get_parent_p:
 *	get the pointer of the parent object.
 *
 * obj	- an object.
 * return - parent object pointer.
 *
 * ****************************************************************************
 */
uint32_t *const
get_parent_p(
	const isns_obj_t *obj
)
{
	uint32_t *pp;
	switch (obj->type) {
	case OBJ_ISCSI:
		pp = &((isns_iscsi_t *)obj)->puid;
		break;
	case OBJ_PORTAL:
		pp = &((isns_portal_t *)obj)->puid;
		break;
	case OBJ_PG:
		pp = &((isns_pg_t *)obj)->puid;
		break;
	case OBJ_ASSOC_ISCSI:
		pp = &((isns_assoc_iscsi_t *)obj)->puid;
		break;
	case OBJ_ASSOC_DD:
		pp = &((isns_assoc_dd_t *)obj)->puid;
		break;
	default:
		pp = NULL;
		break;
	}

	return (pp);
}

uint32_t
get_parent_uid(
	const isns_obj_t *obj
)
{
	uint32_t *pp = get_parent_p(obj);
	if (pp != NULL) {
		return (*pp);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * get_child_np:
 *	get the pointer of the UID array of the n'th child of an object.
 *
 * obj	- an object.
 * n	- the child index.
 * return - the pointer of the UID array.
 *
 * ****************************************************************************
 */
static uint32_t **
get_child_np(
	isns_obj_t *obj,
	int n
)
{
	uint32_t **pp =
	    obj->type == OBJ_ENTITY ? &((isns_entity_t *)obj)->cuid[n] : NULL;

	return (pp);
}

/*
 * ****************************************************************************
 *
 * get_child_n:
 *	get the UID array of the n'th child of an object.
 *
 * obj	- an object.
 * n	- the child index.
 * return - the UID array.
 *
 * ****************************************************************************
 */
#ifdef DEBUG
uint32_t *
#else
static uint32_t *
#endif
get_child_n(
	isns_obj_t *obj,
	int n
)
{
	uint32_t **pp = get_child_np(obj, n);

	if (pp != NULL) {
		return (*pp);
	}

	ASSERT(0);
	return (NULL);
}

/*
 * ****************************************************************************
 *
 * get_child_p:
 *	get the pointer of the UID array of the child matching the type.
 *
 * base	- an object.
 * child_type	- the child object type.
 * return - the pointer of the UID array.
 *
 * ****************************************************************************
 */
static uint32_t **
get_child_p(
	isns_obj_t *base,
	int child_type
)
{
	uint32_t **pp = NULL;
	int i = 0;
	while (i < NUM_OF_CHILD[base->type]) {
		if (child_type == TYPE_OF_CHILD[base->type][i]) {
			pp = get_child_np(base, i);
			break;
		}
		i ++;
	}

	return (pp);
}

/*
 * ****************************************************************************
 *
 * get_child_t:
 *	get the UID array of the child object matching the type.
 *
 * base	- an object.
 * child_type	- the child object type.
 * return - the UID array.
 *
 * ****************************************************************************
 */
uint32_t *
get_child_t(
	isns_obj_t *base,
	int child_type
)
{
	uint32_t **pp = get_child_p(base, child_type);

	if (pp != NULL) {
		return (*pp);
	} else {
		return (NULL);
	}
}

/*
 * ****************************************************************************
 *
 * key_cmp:
 *	compare the object against the lookup control data.
 *
 * lcp	- the lookup control data.
 * obj	- an object.
 * return - comparison result.
 *
 * ****************************************************************************
 */
int
key_cmp(
	lookup_ctrl_t *lcp,
	isns_obj_t *obj
)
{
	int i = 0;
	int match = 1;
	while (i < MAX_LOOKUP_CTRL && lcp->op[i] > 0 && match) {
		isns_attr_t *attr = &obj->attrs[lcp->id[i]];
		switch (lcp->op[i]) {
			case OP_STRING:
				match = (strcmp((const char *)lcp->data[i].ptr,
				    (const char *)attr->value.ptr) == 0);
				break;
			case OP_INTEGER:
				match = (lcp->data[i].ui == attr->value.ui);
				break;
			case OP_MEMORY_IP6:
				match = !memcmp((void *)lcp->data[i].ip,
				    (void *)attr->value.ip,
				    sizeof (in6_addr_t));
				break;
			default:
				ASSERT(0);
				match = 0;
				break;
		}
		i ++;
	}

	if (i && match) {
		return (0);
	} else {
		return (1);
	}
}

/*
 * ****************************************************************************
 *
 * set_lookup_ctrl:
 *	fill in the lookup control data for an object.
 *
 * lcp	- the lookup control data.
 * obj	- an object.
 * return - the lookup control data.
 *
 * ****************************************************************************
 */
static lookup_ctrl_t *
set_lookup_ctrl(
	lookup_ctrl_t *lcp,
	isns_obj_t *obj
)
{
	isns_type_t type = obj->type;
	uint32_t id, op;
	int i = 0;

	lcp->type = type;
	while (i < MAX_KEY_ATTRS) {
		op = KEY_ATTR_OP[type][i];
		if (op != 0) {
			id = KEY_ATTR_INDEX[type][i];
			lcp->id[i] = id;
			lcp->op[i] = op;
			lcp->data[i].ui = obj->attrs[id].value.ui;
		} else {
			break;
		}
		i ++;
	}

	return (lcp);
}

/*
 * ****************************************************************************
 *
 * assign_attr:
 *	assign an attribute.
 *
 * attr	- the attribute being assigned.
 * tmp	- the attribute.
 * return - error code.
 *
 * ****************************************************************************
 */
int
assign_attr(
	isns_attr_t *attr,
	const isns_attr_t *tmp
)
{
	uint32_t t;

	switch (tmp->tag) {
	case ISNS_EID_ATTR_ID:
	case ISNS_DD_SET_NAME_ATTR_ID:
	case ISNS_DD_NAME_ATTR_ID:
		if (tmp->len == 0 && attr->len == 0) {
			int len;
			char *name = make_unique_name(&len, tmp->tag);
			if (name != NULL) {
				attr->value.ptr = (uchar_t *)name;
				attr->tag = tmp->tag;
				attr->len = len;
			} else {
				/* memory exhausted */
				return (1);
			}
		}
		/* FALLTHROUGH */
	case ISNS_PORTAL_NAME_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_ISCSI_NAME_ATTR_ID:
		if (tmp->len == 0) {
			return (0);
		} else if (tmp->len >= attr->len) {
			attr->value.ptr = realloc(
			    attr->value.ptr, tmp->len + 1);
		}
		if (attr->value.ptr != NULL) {
			(void) strncpy((char *)attr->value.ptr,
			    (char *)tmp->value.ptr, tmp->len);
			attr->value.ptr[tmp->len] = 0;
			attr->tag = tmp->tag;
			attr->len = tmp->len;
		} else {
			/* memory exhausted */
			return (1);
		}
		break;
	case ISNS_MGMT_IP_ADDR_ATTR_ID:
	case ISNS_PORTAL_IP_ADDR_ATTR_ID:
	case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
		if (attr->value.ip == NULL) {
			attr->value.ip = (in6_addr_t *)calloc(1, tmp->len);
		}
		if (attr->value.ip != NULL) {
			(void) memcpy((void *)attr->value.ip,
			    (void *)tmp->value.ip, tmp->len);
			attr->tag = tmp->tag;
			attr->len = tmp->len;
		} else {
			/* memory exhausted */
			return (1);
		}
		break;
	case ISNS_ENTITY_INDEX_ATTR_ID:
	case ISNS_PORTAL_INDEX_ATTR_ID:
	case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
	case ISNS_PG_INDEX_ATTR_ID:
	case ISNS_DD_SET_ID_ATTR_ID:
	case ISNS_DD_ID_ATTR_ID:
		if (attr->value.ui != 0) {
			break;
		}
		/* FALLTHROUGH */
	case ISNS_ENTITY_PROTOCOL_ATTR_ID:
	case ISNS_VERSION_RANGE_ATTR_ID:

	case ISNS_PORTAL_PORT_ATTR_ID:
	case ISNS_ESI_PORT_ATTR_ID:
	case ISNS_SCN_PORT_ATTR_ID:

	case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
	case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:

	case ISNS_PG_PORTAL_PORT_ATTR_ID:
	case ISNS_PG_TAG_ATTR_ID:

	case ISNS_DD_SET_STATUS_ATTR_ID:
	case ISNS_DD_ISCSI_INDEX_ATTR_ID:
		attr->tag = tmp->tag;
		attr->len = tmp->len;
		attr->value.ui = tmp->value.ui;
		break;
	case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
		attr->tag = tmp->tag;
		attr->len = tmp->len;
		attr->value.ui = tmp->value.ui;
		t = get_reg_period();
		if (attr->value.ui > t) {
			attr->value.ui = t;
		} else if (attr->value.ui < ONE_DAY) {
			attr->value.ui = ONE_DAY;
		}
		break;
	case ISNS_ESI_INTERVAL_ATTR_ID:
		attr->tag = tmp->tag;
		attr->len = tmp->len;
		attr->value.ui = tmp->value.ui;
		if (attr->value.ui > ONE_DAY) {
			attr->value.ui = ONE_DAY;
		} else if (attr->value.ui < MIN_ESI_INTVAL) {
			attr->value.ui = MIN_ESI_INTVAL; /* 20 seconds */
		}
		break;
	default:
		ASSERT(0);
		/* don't assign the attribute */
		break;
	}
	return (0);
}

/*
 * ****************************************************************************
 *
 * copy_attrs:
 *	copy all of attributes from one object to another.
 *
 * dst	- the destination object.
 * tmp	- the source object.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
copy_attrs(
	isns_obj_t *dst,
	const isns_obj_t *src
)
{
	int i = 0;
	int n = NUM_OF_ATTRS[dst->type];

	isns_attr_t *dst_attr;
	const isns_attr_t *src_attr;

	while (i < n) {
		src_attr = &(src->attrs[i]);
		if (src_attr->tag != 0) {
			dst_attr = &(dst->attrs[i]);
			if (assign_attr(dst_attr, src_attr) != 0) {
				return (1);
			}
		}
		i ++;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * extract_attr:
 *	extract an attribute from a TLV format data.
 *
 * attr	- the attribute.
 * tlv	- the TLV format data.
 * return - error code.
 *
 * ****************************************************************************
 */
int
extract_attr(
	isns_attr_t *attr,
	const isns_tlv_t *tlv,
	int flag
)
{
	int ec = 0;

	uint32_t min_len = 4, max_len = 224;

	switch (tlv->attr_id) {
	case ISNS_EID_ATTR_ID:
		min_len = 0;
		/* FALLTHROUGH */
	case ISNS_PORTAL_NAME_ATTR_ID:
	case ISNS_ISCSI_ALIAS_ATTR_ID:
	case ISNS_DD_SET_NAME_ATTR_ID:
	case ISNS_DD_NAME_ATTR_ID:
		max_len = 256;
		/* FALLTHROUGH */
	case ISNS_ISCSI_NAME_ATTR_ID:
	case ISNS_PG_ISCSI_NAME_ATTR_ID:
		if (tlv->attr_len < min_len || tlv->attr_len > max_len) {
			ec = ISNS_RSP_MSG_FORMAT_ERROR;
		} else {
			attr->tag = tlv->attr_id;
			attr->len = tlv->attr_len;
			attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
		}
		break;
	case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
		attr->tag = tlv->attr_id;
		attr->len = tlv->attr_len;
		attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
		break;
	case ISNS_MGMT_IP_ADDR_ATTR_ID:
	case ISNS_PORTAL_IP_ADDR_ATTR_ID:
	case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
		if (tlv->attr_len != 16) {
			ec = ISNS_RSP_MSG_FORMAT_ERROR;
		} else {
			attr->tag = tlv->attr_id;
			attr->len = tlv->attr_len;
			attr->value.ip = (void *)&(tlv->attr_value[0]);
		}
		break;
	case ISNS_ENTITY_PROTOCOL_ATTR_ID:
	case ISNS_VERSION_RANGE_ATTR_ID:
	case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
		/* fall throught */
	case ISNS_PORTAL_PORT_ATTR_ID:
	case ISNS_ESI_INTERVAL_ATTR_ID:
	case ISNS_ESI_PORT_ATTR_ID:
	case ISNS_SCN_PORT_ATTR_ID:
		/* fall throught */
	case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
		/* fall throught */
	case ISNS_PG_PORTAL_PORT_ATTR_ID:
		/* fall throught */
	case ISNS_DD_SET_ID_ATTR_ID:
	case ISNS_DD_SET_STATUS_ATTR_ID:
		/* fall throught */
	case ISNS_DD_ID_ATTR_ID:
		if (tlv->attr_len != 4) {
			ec = ISNS_RSP_MSG_FORMAT_ERROR;
			break;
		}
		/* FALLTHROUGH */
	case ISNS_PG_TAG_ATTR_ID:
		attr->tag = tlv->attr_id;
		attr->len = tlv->attr_len;
		if (tlv->attr_len == 4) {
			attr->value.ui = ntohl(*(uint32_t *)
			    &(tlv->attr_value[0]));
		} else {
			attr->value.ui = 0;
		}
		break;
	case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
		/* ignore scn bitmap attribute during object registration, */
		/* it is registered by scn_reg message. */
	case ISNS_ENTITY_ISAKMP_P1_ATTR_ID:
	case ISNS_ENTITY_CERT_ATTR_ID:
	case ISNS_PORTAL_SEC_BMP_ATTR_ID:
	case ISNS_PORTAL_ISAKMP_P1_ATTR_ID:
	case ISNS_PORTAL_ISAKMP_P2_ATTR_ID:
	case ISNS_PORTAL_CERT_ATTR_ID:
		break;
	case ISNS_PORTAL_INDEX_ATTR_ID:
	case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
	case ISNS_PG_INDEX_ATTR_ID:
		if (flag == 0) {
			if (tlv->attr_len != 4) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			} else {
				attr->tag = tlv->attr_id;
				attr->len = tlv->attr_len;
				attr->value.ui = ntohl(*(uint32_t *)
				    &(tlv->attr_value[0]));
			}
			break;
		}
		/* FALLTHROUGH */
	case ISNS_ENTITY_INDEX_ATTR_ID:
	case ISNS_TIMESTAMP_ATTR_ID:
	default:
		if (flag == 0) {
			ec = ISNS_RSP_INVALID_QRY;
		} else {
			ec = ISNS_RSP_INVALID_REGIS;
		}
		break;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * copy_attr:
 *	copy an attribute from a TLV format data.
 *
 * attr	- the attribute.
 * tlv	- the TLV format data.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
copy_attr(
	isns_attr_t *attr,
	const isns_tlv_t *tlv
)
{
	int ec = 0;

	isns_attr_t tmp = { 0 };

	/* extract the attribute first */
	ec = extract_attr(&tmp, tlv, 1);

	/* assign the attribute */
	if (ec == 0 && tmp.tag != 0) {
		if (assign_attr(attr, &tmp) != 0) {
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * get_timestamp:
 *	get current timestamp.
 *
 * return - current timestamp.
 *
 * ****************************************************************************
 */
uint32_t
get_timestamp(
)
{
	uint32_t t;
	int flag;

	/* block the scheduler */
	(void) pthread_mutex_lock(&el_mtx);

	/* get most current time */
	if (sys_q != NULL) {
		/* need to wakeup idle */
		flag = 1;
	} else {
		flag = 0;
	}
	t = get_stopwatch(flag);

	/* unblock it */
	(void) pthread_mutex_unlock(&el_mtx);

	return (t);
}

/*
 * ****************************************************************************
 *
 * get_reg_period:
 *	get the longest registration period.
 *
 * return - the longest registration period.
 *
 * ****************************************************************************
 */
static uint32_t
get_reg_period(
)
{
	uint32_t t;
	uint32_t period;

	/* get most current time */
	t = get_timestamp();

	/* just one second before the end of the world */
	period = INFINITY - t - 1;

	return (period);
}

/*
 * ****************************************************************************
 *
 * obj_calloc:
 *	allocate memory space for an object.
 *
 * type	- the object type.
 * return - pointer of the object being allocated.
 *
 * ****************************************************************************
 */
isns_obj_t *
obj_calloc(
	int type
)
{
	isns_obj_t *obj = NULL;

	obj = (isns_obj_t *)calloc(1, SIZEOF_OBJ[type]);
	if (obj != NULL) {
		obj->type = type;
#ifdef DEBUG
	if (verbose_mc) {
		printf("object(%d) allocated\n", type);
	}
#endif
	}

	return (obj);
}

/*
 * ****************************************************************************
 *
 * make_default_entity:
 *	generate a default network entity object.
 *
 * return - pointer of the default network entity object.
 *
 * ****************************************************************************
 */
isns_obj_t *
make_default_entity(
)
{
	uint32_t t;

	isns_obj_t *obj = obj_calloc(OBJ_ENTITY);
	isns_attr_t *attr;
	if (obj != NULL) {
		int len;
		char *eid = make_unique_name(&len, ISNS_EID_ATTR_ID);
		if (!eid) {
			free(obj);
			return (NULL);
		}
		attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)];

		/* set default entity name */
		attr->tag = ISNS_EID_ATTR_ID;
		attr->len = len;
		attr->value.ptr = (uchar_t *)eid;

		/* set default registration period */
		attr = &obj->attrs[
		    ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
		if (attr->tag == 0) {
			attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
			attr->len = 4;
			t = get_reg_period();
			attr->value.ui = t;
		}
	}

	return (obj);
}

/*
 * ****************************************************************************
 *
 * make_default_pg:
 *	generate a default portal group object.
 *
 * iscsi  - the iscsi storage node object.
 * portal - the portal object.
 * return - pointer of the default portal group object.
 *
 * ****************************************************************************
 */
static isns_obj_t *
make_default_pg(
	const isns_obj_t *p1,
	const isns_obj_t *p2
)
{
	const isns_obj_t *iscsi, *portal;
	const isns_attr_t *name, *addr, *port;
	isns_obj_t *pg;

	uchar_t *pg_name;
	in6_addr_t *pg_addr;

	isns_attr_t *attr;

	uint32_t *refp;

	if (p1->type == OBJ_ISCSI) {
		iscsi = p1;
		portal = p2;
	} else {
		iscsi = p2;
		portal = p1;
	}
	name = &iscsi->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
	addr = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
	port = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];

	pg = obj_calloc(OBJ_PG);
	pg_name = (uchar_t *)malloc(name->len);
	pg_addr = (in6_addr_t *)malloc(addr->len);
	if (pg != NULL && pg_name != NULL && pg_addr != NULL) {
		(void) strcpy((char *)pg_name, (char *)name->value.ptr);
		attr = &pg->attrs[ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID)];
		attr->tag = ISNS_PG_ISCSI_NAME_ATTR_ID;
		attr->len = name->len;
		attr->value.ptr = pg_name;

		(void) memcpy((void *)pg_addr,
		    (void *)addr->value.ip, addr->len);
		attr = &pg->attrs[ATTR_INDEX_PG(
		    ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)];
		attr->tag = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
		attr->len = addr->len;
		attr->value.ip = pg_addr;

		attr = &pg->attrs[ATTR_INDEX_PG(
		    ISNS_PG_PORTAL_PORT_ATTR_ID)];
		attr->tag = ISNS_PG_PORTAL_PORT_ATTR_ID;
		attr->len = port->len;
		attr->value.ui = port->value.ui;

		attr = &pg->attrs[ATTR_INDEX_PG(
		    ISNS_PG_TAG_ATTR_ID)];
		attr->tag = ISNS_PG_TAG_ATTR_ID;
		attr->len = 4;
		attr->value.ui = ISNS_DEFAULT_PGT;

		refp = get_ref_p(pg, OBJ_ISCSI);
		*refp = get_obj_uid(iscsi);

		refp = get_ref_p(pg, OBJ_PORTAL);
		*refp = get_obj_uid(portal);

		(void) set_parent_obj(pg, get_parent_uid(iscsi));
	} else {
		free(pg);
		free(pg_name);
		free(pg_addr);
		pg = NULL;
	}

	return (pg);
}

/*
 * ****************************************************************************
 *
 * reg_get_entity:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create the Network Entity object if it has one.
 *
 * p	- the pointer of the object for returning.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
int
reg_get_entity(
	isns_obj_t **p,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *entity = NULL;

	tmp = *op;
	tmp_len = *op_len;

	/* parse the entity object */
	if (tmp_len >= 8 && IS_ENTITY_KEY(tmp->attr_id)) {
		entity = obj_calloc(OBJ_ENTITY);
		if (entity != NULL) {
			do {
				attr = &entity->attrs[
				    ATTR_INDEX_ENTITY(tmp->attr_id)];
				ec = copy_attr(attr, tmp);
				NEXT_TLV(tmp, tmp_len);
			} while (ec == 0 &&
			    tmp_len >= 8 &&
			    IS_ENTITY_ATTR(tmp->attr_id));
		} else {
			ec = ISNS_RSP_INTERNAL_ERROR;
		}

		if (ec == 0) {
			/* set default registration period */
			attr = &entity->attrs[
			    ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
			if (attr->tag == 0) {
				attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
				attr->len = 4;
				attr->value.ui = get_reg_period();
			}
		} else if (entity != NULL) {
			free(entity);
			entity = NULL;
		}
	}

	*p = entity;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_iscsi:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create an iSCSI Storage Node object.
 *
 * p	- the pointer of the object for returning.
 * pg_key1 - the pointer of iscsi storage node name for returning.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
reg_get_iscsi(
	isns_obj_t **p,
	isns_attr_t *pg_key1,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *obj = NULL;

	tmp = *op;
	tmp_len = *op_len;

	/* keep the iscsi storage node name for */
	/* parsing a pg object which is immediately */
	/* followed with a PGT by the iscsi storage node */
	pg_key1->tag = PG_KEY1;
	pg_key1->len = tmp->attr_len;
	pg_key1->value.ptr = (uchar_t *)&tmp->attr_value[0];

	/* parse one iscsi storage node object */
	obj = obj_calloc(OBJ_ISCSI);
	if (obj != NULL) {
		/* parse key & non-key attributes */
		do {
			attr = &obj->attrs[
			    ATTR_INDEX_ISCSI(tmp->attr_id)];
			ec = copy_attr(attr, tmp);
			NEXT_TLV(tmp, tmp_len);
		} while (ec == 0 &&
		    tmp_len >= 8 &&
		    IS_ISCSI_ATTR(tmp->attr_id));
	} else {
		/* no memory */
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	*p = obj;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_portal:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create a Portal object.
 *
 * p	- the pointer of the object for returning.
 * pg_key1 - the pointer of portal ip addr for returning.
 * pg_key2 - the pointer of portal port for returning.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
reg_get_portal(
	isns_obj_t **p,
	isns_attr_t *pg_key1,
	isns_attr_t *pg_key2,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *obj = NULL;

	isns_tlv_t *ip;

	tmp = *op;
	tmp_len = *op_len;

	/* keep the portal ip addr */
	pg_key1->tag = PG_KEY2;
	pg_key1->len = tmp->attr_len;
	pg_key1->value.ip = (void *)&tmp->attr_value[0];
	ip = tmp;

	NEXT_TLV(tmp, tmp_len);
	if (tmp_len > 8 &&
	    tmp->attr_id == PORTAL_KEY2 &&
	    tmp->attr_len == 4) {
		/* keep the portal port */
		pg_key2->tag = PG_KEY3;
		pg_key2->len = tmp->attr_len;
		pg_key2->value.ui = ntohl(*(uint32_t *)&tmp->attr_value[0]);

		/* parse one portal object */
		obj = obj_calloc(OBJ_PORTAL);
		if (obj != NULL) {
			/* copy ip addr attribute */
			attr = &obj->attrs[
			    ATTR_INDEX_PORTAL(ip->attr_id)];
			ec = copy_attr(attr, ip);
			/* copy port attribute */
			if (ec == 0) {
				attr = &obj->attrs[
				    ATTR_INDEX_PORTAL(tmp->attr_id)];
				ec = copy_attr(attr, tmp);
			}
			/* parse non-key attributes */
			NEXT_TLV(tmp, tmp_len);
			while (ec == 0 &&
			    tmp_len >= 8 &&
			    IS_PORTAL_ATTR(tmp->attr_id)) {
				attr = &obj->attrs[
				    ATTR_INDEX_PORTAL(
				    tmp->attr_id)];
				ec = copy_attr(attr, tmp);
				NEXT_TLV(tmp, tmp_len);
			}
		} else {
			/* no memory */
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	} else {
		/* ip address is not followed by port */
		ec = ISNS_RSP_MSG_FORMAT_ERROR;
	}

	*p = obj;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_pg:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create a Portal Group object.
 *
 * p	- the pointer of the object for returning.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
reg_get_pg(
	isns_obj_t **p,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *obj = NULL;

	tmp = *op;
	tmp_len = *op_len;

	/* parse a complete pg object */
	obj = obj_calloc(OBJ_PG);
	if (obj != NULL) {
		/* parse attributes */
		do {
			attr = &obj->attrs[
			    ATTR_INDEX_PG(tmp->attr_id)];
			ec = copy_attr(attr, tmp);
			NEXT_TLV(tmp, tmp_len);
		} while (ec == 0 &&
		    tmp_len >= 8 &&
		    IS_PG_ATTR(tmp->attr_id));
	} else {
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	*p = obj;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_pg1:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create a Portal Group object which is followed to a Portal object.
 *
 * p	- the pointer of the object for returning.
 * pgt	- the size-3 array of pointers which have the pg portal ip addr, port
 *	  and the pg tag attributes.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
reg_get_pg1(
	isns_obj_t **p,
	isns_attr_t const *pgt,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *obj = NULL;
	int i = 0;

	tmp = *op;
	tmp_len = *op_len;

	if (pgt[0].tag == PG_KEY2 &&
	    pgt[1].tag == PG_KEY3) {
		/* the pg iscsi storage node name is */
		/* followed to a portal group tag */
		obj = obj_calloc(OBJ_PG);
		if (obj != NULL) {
			/* copy pg iscsi storage node name */
			attr = &obj->attrs[
			    ATTR_INDEX_PG(tmp->attr_id)];
			ec = copy_attr(attr, tmp);
			/* copy pg ip addr, pg port & pgt */
			while (ec == 0 && i < 3) {
				attr = &obj->attrs[
				    ATTR_INDEX_PG(pgt[i].tag)];
				ec = assign_attr(attr, &pgt[i]);
				i ++;
			}
			NEXT_TLV(tmp, tmp_len);
		} else {
			/* no memory */
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	} else {
		ec = ISNS_RSP_MSG_FORMAT_ERROR;
	}

	*p = obj;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_pg2:
 *	parse the Operating Attributes of the DevAttrReg message and
 *	create a Portal Group object which is followed to a iSCSI
 *	Storage Node object.
 *
 * p	- the pointer of the object for returning.
 * pgt	- the size-3 array of pointers which have the pg iscsi storage
 *	  node name and the pg tag attributes.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
reg_get_pg2(
	isns_obj_t **p,
	isns_attr_t const *pgt,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	isns_tlv_t *tmp;
	uint16_t tmp_len;
	isns_attr_t *attr;

	isns_obj_t *obj = NULL;
	int i = 0;

	isns_tlv_t *ip;

	tmp = *op;
	tmp_len = *op_len;

	/* keep ip address */
	ip = tmp;
	NEXT_TLV(tmp, tmp_len);

	if (tmp_len > 8 &&
	    /* expect pg portal port */
	    tmp->attr_id == PG_KEY3 &&
	    tmp->attr_len == 4 &&
	    /* expect pg tag */
	    pgt[2].tag == PG_PGT &&
	    /* expect pg iscsi storage node name only */
	    pgt[1].tag == 0 &&
	    pgt[0].tag == PG_KEY1) {
		/* the pg portal ip addr & port is followed */
		/* to a pg tag and we have the iscsi storage */
		/* node parsed previously */
		obj = obj_calloc(OBJ_PG);
		if (obj != NULL) {
			/* copy the pg ip addr */
			attr = &obj->attrs[
			    ATTR_INDEX_PG(ip->attr_id)];
			ec = copy_attr(attr, ip);
			/* copy the pg port */
			if (ec == 0) {
				attr = &obj->attrs[
				    ATTR_INDEX_PG(tmp->attr_id)];
				ec = copy_attr(attr, tmp);
			}
			/* copy pg iscsi storage node name & pgt */
			while (ec == 0 && i < 3) {
				attr = &obj->attrs[
				    ATTR_INDEX_PG(pgt[i].tag)];
				ec = assign_attr(attr, &pgt[i]);
				i += 2;
			}
			NEXT_TLV(tmp, tmp_len);
		} else {
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	} else {
		ec = ISNS_RSP_MSG_FORMAT_ERROR;
	}

	*p = obj;
	*op = tmp;
	*op_len = tmp_len;

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_get_obj:
 *	parse and create one object from the rest of Operating Attributes
 *	of the DevAttrReg message, the object can be iSCSI Storage Node,
 *	Portal or Portal Group.
 *
 * p	- the pointer of the object for returning.
 * pgt	- an attribute array with size 3, the elements are:
 *	  0: the first pg key attribute, it is either the name of an
 *	     iscsi storage node object or the ip addr of a portal object.
 *	  1: the second pg key attribute, i.e. the portal port.
 *	  2: the portal group tag attribute.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
int
reg_get_obj(
	isns_obj_t **p,
	isns_attr_t *pgt,
	isns_tlv_t **op,
	uint16_t *op_len
)
{
	int ec = 0;

	int derefd = 0;

	uint32_t pg_tag;

	if (*op_len == 0) {
		*p = NULL;
		return (0);
	}

	switch ((*op)->attr_id) {
	case ISCSI_KEY:
		ec = reg_get_iscsi(p, &pgt[0], op, op_len);
		pgt[1].tag = 0;
		pgt[2].tag = 0;
		break;
	case PORTAL_KEY1:
		ec = reg_get_portal(p, &pgt[0], &pgt[1], op, op_len);
		pgt[2].tag = 0;
		break;
	case PG_KEY1:
		if (pgt[2].tag == PG_PGT) {
			/* pg iscsi storage node name is */
			/* followed to a pgt */
			ec = reg_get_pg1(p, pgt, op, op_len);
		} else {
			/* a complete pg object */
			ec = reg_get_pg(p, op, op_len);
			pgt[0].tag = 0;
			pgt[1].tag = 0;
			pgt[2].tag = 0;
		}
		break;
	case PG_KEY2:
		/* pg portal ip addr is followed to a pgt */
		ec = reg_get_pg2(p, pgt, op, op_len);
		break;
	case PG_PGT:
		switch (pgt[0].tag) {
		case 0:
			/* portal group tag does not follow */
			/* iscsi storage node or portal object */
			*p = NULL;
			ec = ISNS_RSP_MSG_FORMAT_ERROR;
			break;
		case PG_KEY1:
		case PG_KEY2:
			pgt[2].tag = PG_PGT;
			pgt[2].len = (*op)->attr_len;
			pg_tag = 0;
			switch ((*op)->attr_len) {
			case 4:
				pg_tag = ntohl(*(uint32_t *)
				    &(*op)->attr_value[0]);
				/* FALLTHROUGH */
			case 0:
				pgt[2].value.ui = pg_tag;
				break;
			default:
				*p = NULL;
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
				break;
			}
			if (ec == 0) {
				derefd = 1;
				NEXT_TLV(*op, *op_len);
				ec = reg_get_obj(p, pgt, op, op_len);
			}
			break;
		default:
			/* should never happen */
			ASSERT(0);
			*p = NULL;
			ec = ISNS_RSP_INTERNAL_ERROR;
			break;
		}
		break;
	default:
		*p = NULL;
		ec = ISNS_RSP_MSG_FORMAT_ERROR;
		break;
	}

	if (ec == 0 && derefd == 0) {
		ec = update_deref_obj(*p);
	}

	if (ec != 0 && *p != NULL) {
		free_one_object(*p);
		*p = NULL;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * reg_auth_src:
 *	Authorize the source attribute the DevAttrReg message.
 *	The update can only performed by the node who has the owenership.
 *
 * p	- the pointer of the object for returning.
 * pgt	- an attribute array with size 3, the elements are:
 *	  0: the first pg key attribute, it is either the name of an
 *	     iscsi storage node object or the ip addr of a portal object.
 *	  1: the second pg key attribute, i.e. the portal port.
 *	  2: the portal group tag attribute.
 * op	- the operating attributes.
 * op_len - the length of the operating attributes.
 * return - error code.
 *
 * ****************************************************************************
 */
int
reg_auth_src(
	isns_type_t type,
	uint32_t uid,
	uchar_t *src
)
{
	lookup_ctrl_t lc;
	uint32_t puid;

	puid = is_parent_there(src);

	if (TYPE_OF_PARENT[type] != 0) {
		SET_UID_LCP(&lc, type, uid);
		uid = cache_lookup(&lc, NULL, cb_get_parent);
		type = TYPE_OF_PARENT[type];
	}

	if (uid != 0 && puid == 0) {
		SET_UID_LCP(&lc, type, uid);
		uid = cache_lookup(&lc, NULL, cb_node_child);
	}

	if (puid != uid) {
		return (0);
	}

	return (1);
}

/*
 * ****************************************************************************
 *
 * is_obj_online:
 *	determine if the object is currently registered with the server.
 *
 * obj - the object being checked.
 * return - 0: not registered, otherwise registered.
 *
 * ****************************************************************************
 */
int
is_obj_online(
	const isns_obj_t *obj
)
{
	int online = 1;

	switch (obj->type) {
	case OBJ_ISCSI:
		online = obj->attrs[ATTR_INDEX_ISCSI(
		    ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui == 0 ? 0 : 1;
		break;
	default:
		break;
	}

	return (online);
}

static int
set_obj_offline(
	isns_obj_t *obj
)
{
	switch (obj->type) {
	case OBJ_ISCSI:
		obj->attrs[ATTR_INDEX_ISCSI(
		    ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui = 0;
		break;
	default:
		break;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * assoc_clone:
 *	clone the association object.
 *
 * p - the object being cloned.
 * clone_flag - 0: the object is being removed;
 *		1: only the association is being removed.
 * return - the clone object.
 *
 * ****************************************************************************
 */
void *
assoc_clone(
	void *p,
	int clone_flag
)
{
	isns_type_t type;
	isns_obj_t *clone;
	const isns_attr_t *src_attr;
	isns_attr_t *dst_attr;
	uint32_t id, op;
	int i = 0;

	const isns_obj_t *obj;
	uint32_t dd_flag;
	int online;

	int state;

	obj = (isns_obj_t *)p;

	if (obj->type != OBJ_ISCSI) {
		return (NULL);
	}

	dd_flag = (get_dd_id(get_obj_uid(obj), ISNS_DEFAULT_DD_ID) == 0) ?
	    0 : 1;
	online = is_obj_online(obj);

	state = (clone_flag << 2) | (dd_flag  << 1) | online;

	/* clone_flag	dd_flag	online	action		*/
	/* 0		0	0	ASSERT(0)	*/
	/* 0		0	1	NULL		*/
	/* 0		1	0	itself		*/
	/* 0		1	1	clone it	*/
	/* 1		0	0	NULL		*/
	/* 1		0	1	itself		*/
	/* 1		1	0	itself		*/
	/* 1		1	1	itself		*/

	switch (state) {
	case 0:
		ASSERT(0);
	case 1:
	case 4:
		return (NULL);
	case 2:
	case 5:
	case 6:
	case 7:
		return (p);
	case 3:
	default:
		break;
	}

	type = obj->type;
	clone = obj_calloc(type);

	if (clone != NULL) {
		id = UID_ATTR_INDEX[type];
		src_attr = &(obj->attrs[id]);
		dst_attr = &(clone->attrs[id]);
		if (assign_attr(dst_attr, src_attr) != 0) {
			free_one_object(clone);
			return (NULL);
		}

		while (i < MAX_KEY_ATTRS) {
			op = KEY_ATTR_OP[type][i];
			if (op != 0) {
				id = KEY_ATTR_INDEX[type][i];
				src_attr = &(obj->attrs[id]);
				dst_attr = &(clone->attrs[id]);
				if (assign_attr(dst_attr, src_attr) != 0) {
					free_one_object(clone);
					return (NULL);
				}
			} else {
				break;
			}
			i ++;
		}
	}

	return ((void *)clone);
}

/*
 * ****************************************************************************
 *
 * free_one_object:
 *	free up one object.
 *
 * obj - the object being freed.
 *
 * ****************************************************************************
 */
void
free_one_object(
	isns_obj_t *obj
)
{
	int i;
	uint32_t *cuid;
	if (obj == NULL) {
		return;
	}
	for (i = 0; i < NUM_OF_ATTRS[obj->type]; i++) {
		isns_attr_t *attr = &obj->attrs[i];
		switch (attr->tag) {
			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_PORTAL_IP_ADDR_ATTR_ID:
			case ISNS_PORTAL_NAME_ATTR_ID:
			case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
			case ISNS_DD_SET_NAME_ATTR_ID:
			case ISNS_DD_NAME_ATTR_ID:
			case ISNS_DD_ISCSI_NAME_ATTR_ID:
			case ISNS_DD_FC_PORT_NAME_ATTR_ID:
			case ISNS_DD_PORTAL_IP_ADDR_ATTR_ID:
#ifdef DEBUG
				if (verbose_mc) {
					printf("memory(%d) deallocated\n",
					    attr->len);
				}
#endif
				free(attr->value.ptr);
				attr->value.ptr = NULL;
				break;
			default:
				break;
		}
	}

	/* free child uids */
	i = 0;
	while (i < NUM_OF_CHILD[obj->type]) {
		cuid = get_child_n(obj, i);
		free(cuid);
		i ++;
	}

	/* at last, free the object itself */
#ifdef DEBUG
	if (verbose_mc) {
		printf("object(%d) deallocated\n", obj->type);
	}
#endif
	free(obj);
}

/*
 * ****************************************************************************
 *
 * free_object:
 *	free up one object.
 *
 * obj - the object being freed.
 *
 * ****************************************************************************
 */
void
free_object(
	isns_obj_t *obj
)
{
	free_one_object(obj);
}

/*
 * ****************************************************************************
 *
 * set_parent_obj:
 *	set the parent object UID.
 *
 * obj - the child object.
 * puid- the parent object UID.
 * return - error code.
 *
 * ****************************************************************************
 */
int
set_parent_obj(
	isns_obj_t *obj,
	uint32_t puid
)
{
	uint32_t *const p = get_parent_p(obj);
	if (p != NULL) {
		*p = puid;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * buff_child_obj:
 *	add a child object UID to the child object array.
 *
 * obj - the parent object.
 * child_type - the type of the child object.
 * number  - the number of the child object.
 * return - the length of the child object UID array.
 *
 * ****************************************************************************
 */
int
buff_child_obj(
	const isns_type_t ptype,
	const isns_type_t ctype,
	const void *c,
	void const ***child
)
{
	int ec = 0;

	int i = 0;
	void const ***pp, **p;
	uint32_t num, new_num;

	pp = NULL;
	/* get the pointer of the array which the child belongs to */
	while (i < NUM_OF_CHILD[ptype]) {
		if (TYPE_OF_CHILD[ptype][i] == ctype) {
			pp = &child[i];
			break;
		}
		i ++;
	}

	/* the child type is not applicable */
	if (pp == NULL) {
		return (ec);
	}

	p = *pp;
	/* get an empty slot from the uid array for this child */
	if (p != NULL) {
		num = (uint32_t)*p;
		i = 0;
		while (i < num) {
			if (p[++i] == NULL) {
				/* found it */
				p[i] = c;
				return (ec);
			}
		}
		p = *pp;
		new_num = num + 1;
	} else {
		num = 0;
		new_num = 1;
	}

	/* the array is full, enlarge the child uid array */
	p = (void const **)realloc(p, (new_num + 1) * sizeof (void *));
	if (p != NULL) {
		*pp = p;
		*p = (void *)new_num;
		p[new_num] = c;
	} else {
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * update_child_object:
 *	update the child object of a network entity object.
 *
 * puid - the UID of the parent object, i.e. the network entity object.
 * child_type - the type of the child object.
 * child_uid  - the uid of the child object.
 * return - error code.
 *
 * ****************************************************************************
 */
int
update_child_obj(
	const isns_type_t ptype,
	const uint32_t puid,
	void const ***child,
	int child_flag
)
{
	int ec = 0;

	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, ptype, puid);

	lc.data[1].ptr = (uchar_t *)child;
	lc.data[2].ui = child_flag;

	ec = cache_lookup(&lc, NULL, cb_add_child);

	return (ec);
}

int
update_ref_obj(
	const isns_obj_t *obj
)
{
	uint32_t uid;
	lookup_ctrl_t lc;
	isns_type_t t;

	t = obj->type;

	if (TYPE_OF_REF[t][0] != 0) {
		(void) setup_ref_lcp(&lc, obj, NULL);

		lc.id[2] = t;
		lc.data[2].ui = get_obj_uid(obj);

		uid = 0;
		do {
			lc.curr_uid = uid;
			(void) cache_lookup(&lc, &uid, cb_set_ref);
		} while (uid != 0);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * verify_ref_obj:
 *	update the reference bit of a portal group object.
 *
 * obj - the object being ref'ed.
 * return - error code.
 *
 * ****************************************************************************
 */
int
verify_ref_obj(
	const isns_type_t ptype,
	const uint32_t puid,
	void const ***child
)
{
	int ec = 0;

	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, ptype, puid);

	lc.data[1].ptr = (uchar_t *)child;

	ec = cache_lookup(&lc, NULL, cb_verify_ref);

	return (ec);
}

int
update_deref_obj(
	isns_obj_t *obj
)
{
	int ec = 0;

	isns_type_t t, rt;
	lookup_ctrl_t lc;
	int i, ref_count;

	uint32_t uid, *refp;

	t = obj->type;
	i = ref_count = 0;
	while (i < NUM_OF_REF[t]) {
		rt = TYPE_OF_REF[t][i + 1];
		(void) setup_deref_lcp(&lc, obj, rt);
		uid = is_obj_there(&lc);
		if (uid != 0) {
			refp = get_ref_p(obj, lc.type);
			*refp = uid;
			ref_count ++;
		}
		i ++;
	}

	if (i > 0 && ref_count == 0) {
		ec = ISNS_RSP_INVALID_REGIS;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * register_object:
 *	add one object to the object container.
 *
 * obj	- the object being added.
 * uid_p- the pointer for returning object UID.
 * update_p- the pointer for returning flag which indicates if the object
 *		is newly registered or updated with an existing one.
 * return - error code.
 *
 * ****************************************************************************
 */
int
register_object(
	isns_obj_t *obj,
	uint32_t *uid_p,
	int *update_p
)
{
	return (cache_add(obj, 0, uid_p, update_p));
}

/*
 * ****************************************************************************
 *
 * register_assoc:
 *	add one association object to the object container, the association
 *	object has only the information for discovery domain membership, i.e.
 *	a name and UID only.
 *
 * obj	- the association object being added.
 * uid_p- the pointer for returning object UID.
 * return - error code.
 *
 * ****************************************************************************
 */
int
register_assoc(
	isns_obj_t *obj,
	uint32_t *uid_p
)
{
	return (cache_add(obj, 1, uid_p, NULL));
}

/*
 * ****************************************************************************
 *
 * is_obj_there:
 *	check if the object is registered or not.
 *
 * lcp	- the lookup control data.
 * return - the object UID.
 *
 * ****************************************************************************
 */
uint32_t
is_obj_there(
	lookup_ctrl_t *lcp
)
{
	uint32_t uid;

	(void) cache_lookup(lcp, &uid, NULL);

	return (uid);
}

uint32_t
is_parent_there(
	uchar_t *src
)
{
	lookup_ctrl_t lc;

	lc.curr_uid = 0;
	lc.type = OBJ_ISCSI;
	lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
	lc.op[0] = OP_STRING;
	lc.data[0].ptr = src;
	lc.op[1] = 0;

	return (cache_lookup(&lc, NULL, cb_get_parent));
}

/*
 * ****************************************************************************
 *
 * setup_ref_lcp:
 *	prepare the lookup control data for looking up a portal group
 *	object which references to a iscsi stroage node and/or a portal
 *	object.
 *
 * lcp	- the lookup control data.
 * iscsi- the ref'ed iscsi storage node object.
 * portal- the ref'ed portal object.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
setup_ref_lcp(
	lookup_ctrl_t *lcp,
	const isns_obj_t *iscsi,
	const isns_obj_t *portal
)
{
	int i = 0, j = 0;

	lcp->curr_uid = 0;
	lcp->type = TYPE_OF_REF[iscsi->type][0];

	/* extrace the matching attributes from iscsi storage node object */
	while (iscsi != NULL &&
	    i < MAX_REF_MATCH &&
	    REF_MATCH_OPS[iscsi->type][i] > 0) {
		lcp->id[i] = REF_MATCH_ID2[iscsi->type][i];
		lcp->op[i] = REF_MATCH_OPS[iscsi->type][i];
		lcp->data[i].ptr = iscsi->attrs[
		    REF_MATCH_ID1[iscsi->type][i]].value.ptr;
		i ++;
	}

	/* extrace the matching attributes from portal object */
	while (portal != NULL &&
	    i < MAX_LOOKUP_CTRL &&
	    j < MAX_REF_MATCH &&
	    REF_MATCH_OPS[portal->type][j] > 0) {
		lcp->id[i] = REF_MATCH_ID2[portal->type][j];
		lcp->op[i] = REF_MATCH_OPS[portal->type][j];
		lcp->data[i].ptr = portal->attrs[
		    REF_MATCH_ID1[portal->type][j]].value.ptr;
		j ++;
		i ++;
	}

	if (i < MAX_LOOKUP_CTRL) {
		lcp->op[i] = 0;
	}

	return (0);
}

static int
setup_deref_lcp(
	lookup_ctrl_t *lcp,
	const isns_obj_t *pg,
	isns_type_t t
)
{
	int i = 0;

	lcp->curr_uid = 0;
	lcp->type = t;

	/* extrace the matching attributes from iscsi storage node object */
	while (i < MAX_REF_MATCH &&
	    REF_MATCH_OPS[t][i] > 0) {
		lcp->id[i] = REF_MATCH_ID1[t][i];
		lcp->op[i] = REF_MATCH_OPS[t][i];
		lcp->data[i].ptr = pg->attrs[
		    REF_MATCH_ID2[t][i]].value.ptr;
		i ++;
	}

	if (i < MAX_LOOKUP_CTRL) {
		lcp->op[i] = 0;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * setup_parent_lcp:
 *	prepare the lookup control data for looking up parent object
 *	with a child object.
 *
 * lcp	- the lookup control data.
 * obj	- the child object.
 * return - parent object UID.
 *
 * ****************************************************************************
 */
static uint32_t
setup_parent_lcp(
	lookup_ctrl_t *lcp,
	isns_obj_t *obj
)
{
	isns_type_t ptype;
	uint32_t puid;

	puid = get_parent_uid(obj);
	if (puid != 0) {
		ptype = TYPE_OF_PARENT[obj->type];
		SET_UID_LCP(lcp, ptype, puid);
		lcp->data[1].ui = obj->type;
		lcp->data[2].ui = get_obj_uid(obj);
	}

	return (puid);
}

static int
cb_get_parent(
	void *p1,
	/* LINTED E_FUNC_ARG_UNUSED */
	void *p2
)
{
	return (get_parent_uid(p1));
}

static int
cb_node_child(
	void *p1,
	/* LINTED E_FUNC_ARG_UNUSED */
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;

	uint32_t num, uid;

	uint32_t *cuid = get_child_t(obj, OBJ_ISCSI);

	if (cuid != NULL) {
		num = *cuid;
	} else {
		num = 0;
	}

	while (num > 0) {
		uid = *++cuid;
		if (uid != 0) {
			return (uid);
		}
		num --;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * cb_set_ref:
 *	callback function which sets the reference bit to 1 according to
 *	the type of object.
 *
 * p1	- the object.
 * p2	- the lcp.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
cb_set_ref(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	isns_type_t t;
	uint32_t u;

	uint32_t *refp;

	t = lcp->id[2];
	u = lcp->data[2].ui;
	refp = get_ref_p(obj, t);
	*refp = u;

	/* successful */
	return (0);
}

/*
 * ****************************************************************************
 *
 * cb_clear_ref:
 *	callback function which clears the reference bit according to
 *	the type of object.
 *
 * p1	- the object.
 * p2	- the lcp.
 * return - 1: the object is no longer ref'ed, 0: otherwise.
 *
 * ****************************************************************************
 */
static int
cb_clear_ref(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	isns_type_t t;
	uint32_t *refp;

	int i = 0;
	uint32_t ref;

	t = lcp->data[2].ui;
	refp = get_ref_p(obj, t);
	*refp = 0;

	while (i < NUM_OF_REF[obj->type]) {
		ref = get_ref_n(obj, i);
		if (ref != 0) {
			return (0);
		}
		i ++;
	}

	return (1);
}

static int
cb_add_child(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	const void ***child;
	const void **vpp;
	uint32_t vnum;
	int child_flag;

	uint32_t **upp, *up;
	uint32_t num;

	isns_obj_t *o;

	int i = 0;

	child = (const void ***)lcp->data[1].ptr;
	child_flag = lcp->data[2].ui;

	while (i < NUM_OF_CHILD[obj->type]) {
		vpp = child[i];
		if (vpp != NULL &&
		    (vnum = (uint32_t)*vpp) > 0 &&
		    *(vpp + 1) != NULL) {
			upp = get_child_np(obj, i);
			if (*upp == NULL) {
				if (child_flag == 0 &&
				    sizeof (typeof (**upp)) ==
				    sizeof (typeof (**child))) {
					*upp = (uint32_t *)vpp;
					vpp = NULL;
					child[i] = NULL;
				}
				num = vnum;
			} else {
				num = **upp + vnum;
			}
			if (vpp != NULL) {
				/* copy required */
				up = (uint32_t *)realloc(*upp,
				    (num + 1) * sizeof (uint32_t));
				if (up == NULL) {
					return (ISNS_RSP_INTERNAL_ERROR);
				}
				*upp = up;
				*up = num;
				up += num;
				vpp += vnum;
				while (vnum > 0) {
					if (*vpp == NULL) {
						*up = 0;
					} else if (child_flag == 0) {
						*up = (uint32_t)*vpp;
						*vpp = NULL;
					} else {
						o = (isns_obj_t *)*vpp;
						*up = get_obj_uid(o);
						if (is_obj_online(o) == 0) {
							free_object(o);
						}
						*vpp = NULL;
					}
					up --;
					vpp --;
					vnum --;
				}
			}
		}
		i ++;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * cb_remove_child:
 *	callback function which removes a child object UID from the
 *	children objet UID array of the parent object.
 *
 * p1	- the object.
 * p2	- the lcp.
 * return - 1: no more such type of child object, 0: otherwise.
 *
 * ****************************************************************************
 */
static int
cb_remove_child(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
	uint32_t child_type = lcp->data[1].ui;
	uint32_t child_uid = lcp->data[2].ui;
	uint32_t *cuidp, cuid, num_of_child = 0;
	int i;

	/* get the children object UID array */
	cuidp = get_child_t(obj, child_type);
	if (cuidp != NULL) {
		num_of_child = *cuidp;
	}

	/* remove it */
	while (num_of_child > 0) {
		cuid = *++cuidp;
		if (cuid == child_uid) {
			*cuidp = 0;
			break;
		}
		num_of_child --;
	}

	/* check if all of child object UIDs are removed */
	i = 0;
	while (i < NUM_OF_CHILD[obj->type]) {
		cuidp = get_child_n(obj, i);
		if (cuidp != NULL) {
			num_of_child = *cuidp;
			while (num_of_child > 0) {
				cuid = *++cuidp;
				if (cuid != 0) {
					return (0);
				}
				num_of_child --;
			}
		}
		i ++;
	}

	return (1);
}

static int
cb_verify_ref(
	void *p1,
	void *p2
)
{
	int ec = 0;

	isns_obj_t *parent = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	const void ***child;

	const void **vpp;
	const void *vp;
	uint32_t vnum;

	const void **evpp;
	const void *evp;
	uint32_t evnum;

	isns_type_t pt; /* parent object type */
	isns_type_t ct; /* child object type */
	isns_type_t rt; /* ref object type */
	isns_type_t et; /* peer object type */

	uint32_t *up;
	uint32_t u;
	uint32_t unum;

	lookup_ctrl_t lc;
	uint8_t flag[MAX_OBJ_TYPE + 1] = { 0 };

	int i, j, k;

	pt = parent->type;

	child = (const void ***)lcp->data[1].ptr;

	for (i = 0; i < NUM_OF_CHILD[pt]; i++) {
		ct = TYPE_OF_CHILD[pt][i];
		rt = TYPE_OF_REF[ct][0];
		if (rt == 0) {
			continue;
		}

		et = TYPE_OF_REF[ct][1];
		vpp = child[i];
		if (vpp != NULL) {
			vnum = (uint32_t)*vpp;
			up = get_child_t(parent, et);
			if (up != NULL) {
				unum = *up;
			} else {
				unum = 0;
			}
		} else {
			vnum = 0;
		}

		j = vnum;
		while (j > 0) {
			vp = vpp[j];
			if (vp != NULL) {
				(void) setup_ref_lcp(&lc, vp, NULL);
				k = unum;
				while (k > 0) {
					u = up[k];
					if (u != 0) {
						ec = ref_new2old(
						    &lc, et, u, vp);
						if (ec != 0) {
							return (ec);
						}
					}
					k --;
				} /* End of while each unum */
			}
			j --;
		} /* End of while each vnum */

		if (flag[ct] != 0) {
			continue;
		}

		evnum = 0;
		j = 0;
		while (j < NUM_OF_CHILD[pt]) {
			if (TYPE_OF_CHILD[pt][j] == et) {
				evpp = child[j];
				if (evpp != NULL) {
					evnum = (uint32_t)*evpp;
				}
				break;
			}
			j ++;
		}

		j = vnum;
		while (j > 0) {
			vp = vpp[j];
			k = evnum;
			while (k > 0) {
				evp = evpp[k];
				if (vp != NULL && evp != NULL) {
					(void) setup_ref_lcp(&lc, vp, evp);
					ec = ref_new2new(&lc, vp, evp);
					if (ec != 0) {
						return (ec);
					}
				}
				k --;
			}
			j --;
		} /* End of while each vnum */

		flag[et] = 1;
	} /* End of for each type of child */

	return (ec);
}

static int
cb_ref_new2old(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	isns_type_t et;
	uint32_t uu;

	uint32_t ref;

	int match;

	et = lcp->id[2];
	uu = lcp->data[2].ui;

	ref = get_ref_t(obj, et);

	if (ref == uu) {
		match = 1;
	} else {
		match = 0;
	}

	return (match);
}

static int
cb_new_ref(
	void *p1,
	void *p2
)
{
	int ec = 0;

	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
	isns_obj_t *a = (isns_obj_t *)p1;
	isns_obj_t *b = (isns_obj_t *)lcp->data[2].ptr;

	ec = new_ref(a, b);

	return (ec);
}

static int
ref_new2old(
	lookup_ctrl_t *lcp,
	isns_type_t et,
	uint32_t uu,
	const isns_obj_t *vp
)
{
	int ec = 0;

	int match;
	uint32_t uid;

	lookup_ctrl_t lc;

	lcp->id[2] = et;
	lcp->data[2].ui = uu;

	uid = 0;
	do {
		lcp->curr_uid = uid;
		match = cache_lookup(lcp, &uid, cb_ref_new2old);
	} while (match == 0 && uid != 0);

	if (match == 0) {
		/* no such ref, create a default one */
		SET_UID_LCP(&lc, et, uu);

		lc.data[2].ptr = (uchar_t *)vp;

		ec = cache_lookup(&lc, NULL, cb_new_ref);
	}

	return (ec);
}

static int
ref_new2new(
	lookup_ctrl_t *lcp,
	const isns_obj_t *p1,
	const isns_obj_t *p2
)
{
	int ec = 0;

	if (is_obj_there(lcp) != 0) {
		return (0);
	}

	ec = new_ref(p1, p2);

	return (ec);
}

static int
new_ref(
	const isns_obj_t *p1,
	const isns_obj_t *p2
)
{
	int ec = 0;

	isns_obj_t *obj;

	obj = make_ref[p1->type](p1, p2);
	if (obj != NULL) {
		ec = register_object(obj, NULL, NULL);
	} else {
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * do_dereg:
 *	Physically remove an object along with the children objects,
 *	the reference object and the parent object recursively.
 *	Apporiate SCN is triggered.
 *
 * lcp	- the lookup control for the object being removed.
 * parent_flag	- 1: the object being removed is the parent object;
 *		  0: otherwise.
 * child_flag	- 1: the object being removed is a child object;
 *		  0: otherwise.
 * pending	- 1: do not remove the ESI entry immediately;
 *		  0: remove the ESI entry without any delay.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
do_dereg(
	lookup_ctrl_t *lcp,
	int parent_flag,
	int child_flag,
	int pending
)
{
	int ec = 0;

	isns_obj_t *obj;
	uint32_t *cuidp, num;
	isns_type_t type;
	uint32_t uid;
	int i;

	/* remove the object from object container */
	obj = cache_remove(lcp, 0);

	if (obj == NULL) {
		return (0);
	}

	/* trigger a scn */
	if (scn_q != NULL) {
		(void) make_scn(ISNS_OBJECT_REMOVED, obj);
	}

	/* dereg children */
	i = 0;
	while (ec == 0 && !parent_flag &&
	    i < NUM_OF_CHILD[obj->type]) {
		type = TYPE_OF_CHILD[obj->type][i];
		cuidp = get_child_n(obj, i);
		if (cuidp != NULL) {
			num = *cuidp;
		} else {
			num = 0;
		}
		while (ec == 0 && num > 0) {
			uid = cuidp[num];
			if (uid != 0) {
				SET_UID_LCP(lcp, type, uid);
				ec = do_dereg(lcp,
				    parent_flag,
				    1,
				    pending);
			}
			num --;
		}
		i ++;
	}

	/* clear the ref bit on the ref'd object */
	if (ec == 0 && TYPE_OF_REF[obj->type][0] > 0) {
		uid = 0;
		do {
			(void) setup_ref_lcp(lcp, obj, NULL);
			lcp->curr_uid = uid;
			lcp->data[2].ui = obj->type;
			if (cache_lookup(lcp, &uid, cb_clear_ref) != 0) {
				UPDATE_LCP_UID(lcp, uid);
				ec = do_dereg(lcp,
				    parent_flag,
				    child_flag,
				    pending);
			}
		} while (uid != 0);
	}

	/* remove it from the parent */
	if (ec == 0 && !child_flag &&
	    TYPE_OF_PARENT[obj->type] > 0 &&
	    (uid = setup_parent_lcp(lcp, obj)) != 0) {
		if (cache_lookup(lcp, NULL, cb_remove_child) != 0) {
			UPDATE_LCP_UID(lcp, uid);
			ec = do_dereg(lcp,
			    1,
			    child_flag,
			    0);
		}
	}

	if (ec == 0 && !child_flag) {
		/* remove it from persistent data store */
		if (sys_q) {
			ec = write_data(DATA_DELETE, obj);
		}
		/* remove esi event entry */
		if (ec == 0) {
			(void) esi_remove_obj(obj, pending);
		}

		/* save the parent uid for caller */
		if (TYPE_OF_PARENT[obj->type] != 0) {
			lcp->curr_uid = get_parent_uid(obj);
		} else {
			/* it's the parent itself */
			lcp->curr_uid = get_obj_uid(obj);
		}
	}

	/* remove this portal from scn registry */
	if (ec == 0 &&
	    obj->type == OBJ_PORTAL) {
		(void) remove_scn_portal(get_obj_uid(obj));
	}

	/* free the object */
	(void) free_object(obj);

	return (ec);
}

/*
 * ****************************************************************************
 *
 * dereg_assoc:
 *	Remove one association object from object container.
 *
 * lcp	- the lookup control for the object being removed.
 * return - error code.
 *
 * ****************************************************************************
 */
int
dereg_assoc(
	lookup_ctrl_t *lcp
)
{
	isns_obj_t *obj;

	obj = cache_remove(lcp, 1);

	/* free the object */
	if (obj != NULL) {
		free_object(obj);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * dereg_object:
 *	Remove one object from object container.
 *
 * lcp	- the lookup control for the object being removed.
 * return - error code.
 *
 * ****************************************************************************
 */
int
dereg_object(
	lookup_ctrl_t *lcp,
	int pending
)
{
	return (do_dereg(lcp, 0, 0, pending));
}

/*
 * ****************************************************************************
 *
 * data_sync:
 *	Synchronize the cache with persistent data store.
 *	Flush the cache data to data store if the input ec is zero,
 *	retreat the changes in cache and ignore data store update
 *	if there is an error.
 *
 * ec	- error code.
 * return - error code.
 *
 * ****************************************************************************
 */
int
data_sync(
	int ec
)
{
	/* cache is updated successfully, commit the data to data store */
	if (IS_CACHE_UPDATED()) {
		if (ec == 0) {
			ec = write_data(DATA_COMMIT, NULL);
		}
		if (ec == 0) {
			/* successful, trigger the SCN */
			(void) queue_msg_set(scn_q, SCN_TRIGGER, (void *)NULL);
		} else {
			shutdown_server();
		}
	} else {
		/* ignore all SCNs which have been generated */
		(void) queue_msg_set(scn_q, SCN_IGNORE, (void *)NULL);

		(void) write_data(DATA_RETREAT, NULL);
	}

	return (ec);
}

static pthread_mutex_t name_mtx[3] = {
	PTHREAD_MUTEX_INITIALIZER,
	PTHREAD_MUTEX_INITIALIZER,
	PTHREAD_MUTEX_INITIALIZER
};
static const char *name_pattern[3] = {
	"ENTITY_ID_%d",
	"DD_%d",
	"DD-Set_%d"
};
static uint32_t name_count[3] = {
	0,
	0,
	0
};

/*
 * ****************************************************************************
 *
 * make_unique_name:
 *	make a default unique name for a newly registered network entity,
 *	discovery domain or discovery domain set object.
 *
 * len	- pointer of the length of the new name for returning.
 * tag	- which attribute of the new name is for.
 * return - the name being made.
 *
 * ****************************************************************************
 */
static char *
make_unique_name(
	int *len,
	uint32_t tag
)
{
	int i;
	int count;
	char name[32] = { 0 };

	char *p;

	lookup_ctrl_t lc;

	lc.curr_uid = 0;

	switch (tag) {
	case ISNS_EID_ATTR_ID:
		i = 0;
		lc.type = OBJ_ENTITY;
		lc.id[0] = ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID);
		break;
	case ISNS_DD_NAME_ATTR_ID:
		i = 1;
		lc.type = OBJ_DD;
		lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
		break;
	case ISNS_DD_SET_NAME_ATTR_ID:
		i = 2;
		lc.type = OBJ_DDS;
		lc.id[0] = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
		break;
	default:
		ASSERT(0);
		break;
	}

	lc.op[0] = OP_STRING;
	lc.op[1] = 0;
	do {
		(void) pthread_mutex_lock(&name_mtx[i]);
		count = ++ name_count[i];
		(void) pthread_mutex_unlock(&name_mtx[i]);
		/* no more space, failure */
		if (count == 0) {
			return (NULL);
		}
		(void) sprintf(name, name_pattern[i], count);
		lc.data[0].ptr = (uchar_t *)name;
	} while (is_obj_there(&lc) != 0);

	/* 4-bytes aligned length */
	*len = strlen(name);
	*len = *len + (4 - *len % 4);
	p = (char *)malloc(*len);
	if (p != NULL) {
		(void) strcpy(p, name);
	}
	return (p);
}

#ifdef DEBUG
void
obj_dump(
	void *p
)
{
	print_object(NULL, (isns_obj_t *)p);
}
#endif