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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "isns_server.h"
#include "isns_msgq.h"
#include "isns_cache.h"
#include "isns_cfg.h"
#include "isns_obj.h"
#include "isns_dseng.h"
#include "isns_log.h"
#include "isns_scn.h"
#include "isns_pdu.h"

/*
 * global variables.
 */

/*
 * local variables.
 */
static scn_registry_t *scn_registry = NULL;
static int scn_dispatched = 0;

/*
 * external variables.
 */
extern uint8_t mgmt_scn;
extern msg_queue_t *sys_q;
extern msg_queue_t *scn_q;
extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];

#ifdef DEBUG
extern void dump_pdu1(isns_pdu_t *);
#endif

static int sf_gen(scn_raw_t *);
static int sf_error(scn_raw_t *);

static scn_raw_t *make_raw_entity(isns_obj_t *);
static scn_raw_t *make_raw_iscsi(isns_obj_t *);
static scn_raw_t *make_raw_portal(isns_obj_t *);
static scn_raw_t *make_raw_assoc_iscsi(isns_obj_t *);
static scn_raw_t *make_raw_assoc_dd(isns_obj_t *);
static scn_raw_t *(*const make_raw[MAX_OBJ_TYPE_FOR_SIZE])(isns_obj_t *) = {
	NULL,
	&make_raw_entity,
	&make_raw_iscsi,
	&make_raw_portal,
	NULL,			/* OBJ_PG */
	NULL,			/* OBJ_DD */
	NULL,			/* OBJ_DDS */
	NULL,			/* MAX_OBJ_TYPE */
	NULL,			/* OBJ_DUMMY1 */
	NULL,			/* OBJ_DUMMY2 */
	NULL,			/* OBJ_DUMMY3 */
	NULL,			/* OBJ_DUMMY4 */
	&make_raw_assoc_iscsi,
	&make_raw_assoc_dd
};

static scn_text_t *scn_gen_entity(scn_raw_t *);
static scn_text_t *scn_gen_iscsi(scn_raw_t *);
static scn_text_t *scn_gen_portal(scn_raw_t *);
static scn_text_t *scn_gen_assoc_dd(scn_raw_t *);
static scn_text_t *(*const scn_gen[MAX_OBJ_TYPE_FOR_SIZE])(scn_raw_t *) = {
	NULL,
	&scn_gen_entity,
	&scn_gen_iscsi,
	&scn_gen_portal,
	NULL,			/* OBJ_PG */
	NULL,			/* OBJ_DD */
	NULL,			/* OBJ_DDS */
	NULL,			/* MAX_OBJ_TYPE */
	NULL,			/* OBJ_DUMMY1 */
	NULL,			/* OBJ_DUMMY2 */
	NULL,			/* OBJ_DUMMY3 */
	NULL,			/* OBJ_DUMMY4 */
	&scn_gen_iscsi,
	&scn_gen_assoc_dd
};

#define	SCN_TEST(E, BITMAP, UID1, UID2, NT) \
	(((E) & (BITMAP)) && \
	(!((BITMAP) & (ISNS_INIT_SELF_INFO_ONLY | \
			ISNS_TARGET_SELF_INFO_ONLY)) || \
		((UID1) == (UID2)) || \
		(((BITMAP) & ISNS_INIT_SELF_INFO_ONLY) && \
			((NT) & ISNS_INITIATOR_NODE_TYPE)) || \
		(((BITMAP) & ISNS_TARGET_SELF_INFO_ONLY) && \
			((NT) & ISNS_TARGET_NODE_TYPE))))

/*
 * local functions.
 */

/*
 * ****************************************************************************
 *
 * free_portal_1:
 *	Free one SCN portal or decrease the reference count if the portal
 *	is referenced by other SCN entry(s).
 *
 * p	- the portal.
 *
 * ****************************************************************************
 */
static void
free_portal_1(
	scn_portal_t *p
)
{
	if (p->ref <= 1) {
		if (p->sz == sizeof (in6_addr_t)) {
			free(p->ip.in6);
		}
		free(p);
	} else {
		p->ref --;
	}
}

/*
 * ****************************************************************************
 *
 * free_portal:
 *	Free the unused portals, which are extracted for new SCN entry,
 *	after the new SCN entry is added.
 *
 * p	- the portal.
 *
 * ****************************************************************************
 */
static void
free_portal(
	scn_portal_t *p
)
{
	scn_portal_t *n;

	while (p != NULL) {
		n = p->next;
		free_portal_1(p);
		p = n;
	}
}

/*
 * ****************************************************************************
 *
 * free_portal_list:
 *	Free the list of portals while a SCN entry is being destroyed.
 *
 * l	- the portal list.
 *
 * ****************************************************************************
 */
static void
free_portal_list(
	scn_list_t *l
)
{
	scn_list_t *n;
	scn_portal_t *p;

	while (l != NULL) {
		n = l->next;
		p = l->data.portal;
		free_portal_1(p);
		free(l);
		l = n;
	}
}

/*
 * ****************************************************************************
 *
 * free_scn_text:
 *	Free one SCN or decrease the ref count after the SCN is emitted.
 *
 * text	- the SCN.
 *
 * ****************************************************************************
 */
static void
free_scn_text(
	scn_text_t *text
)
{
	if (text->ref <= 1) {
		free(text->iscsi);
		free(text);
	} else {
		text->ref --;
	}
}

/*
 * ****************************************************************************
 *
 * free_scn_list:
 *	Free the the list of SCN.
 *
 * scn	- the list.
 *
 * ****************************************************************************
 */
static void
free_scn_list(
	scn_t *scn
)
{
	scn_t *next_scn;
	scn_list_t *list;
	scn_list_t *next_list;

	while (scn != NULL) {
		next_scn = scn->next;
		list = scn->data.list;
		while (list != NULL) {
			next_list = list->next;
			free_scn_text(list->data.text);
			free(list);
			list = next_list;
		}
		free(scn);
		scn = next_scn;
	}
}

/*
 * ****************************************************************************
 *
 * free_scn:
 *	Free all of SCNs which are dispatched to every entry.
 *
 * ****************************************************************************
 */
static void
free_scn(
)
{
	scn_registry_t *p;

	p = scn_registry;

	while (p != NULL) {
		free_scn_list(p->scn);
		p->scn = NULL;
		p = p->next;
	}
}

/*
 * ****************************************************************************
 *
 * free_entry:
 *	Free one SCN entry.
 *
 * e	- the SCN entry.
 *
 * ****************************************************************************
 */
static void
free_entry(
	scn_registry_t *e
)
{
	free_scn_list(e->scn);
	free_portal_list(e->portal.l);
	free(e->name);
	free(e);
}

/*
 * ****************************************************************************
 *
 * free_raw:
 *	Free the raw data after the SCN is generated from it.
 *
 * raw	- the raw SCN data.
 *
 * ****************************************************************************
 */
static void
free_raw(
	scn_raw_t *raw
)
{
	if (raw->ref == 0) {
		free(raw->iscsi);
	}
	if (raw->ip != NULL) {
		free(raw->ip);
	}
	free(raw);
}

/*
 * ****************************************************************************
 *
 * scn_add_portal:
 *	Add portals to the portal list of a SCN entry.
 *
 * e	- the SCN entry.
 * p	- the portals.
 * return - 0: successful, otherwise failed.
 *
 * ****************************************************************************
 */
static int
scn_add_portal(
	scn_registry_t *e,
	scn_portal_t *p
)
{
	scn_portal_t *x;
	scn_list_t *l, *m;

	scn_list_t **lp;

	int found_it;

	lp = &e->portal.l;
	while (p != NULL) {
		m = (scn_list_t *)malloc(sizeof (scn_list_t));
		if (m == NULL) {
			return (1);
		}
		found_it = 0;
		e = scn_registry;
		while (e && !found_it) {
			l = e->portal.l;
			while (l && !found_it) {
				x = l->data.portal;
				if (x->uid == p->uid) {
					found_it = 1;
				}
				l = l->next;
			}
			e = e->next;
		}

		if (!found_it) {
			x = p;
		}
		m->data.portal = x;
		x->ref ++;
		m->next = *lp;
		*lp = m;

		p = p->next;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_remove_portal:
 *	Remove a portal from the portal list of every SCN entry.
 *
 * uid	- the portal object uid.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_remove_portal(
	uint32_t uid
)
{
	scn_registry_t **ep, *e;

	scn_portal_t *x;
	scn_list_t **lp, *l;

	ep = &scn_registry;
	e = *ep;

	while (e != NULL) {
		lp = &e->portal.l;
		l = *lp;
		while (l != NULL) {
			x = l->data.portal;
			if (x->uid == uid) {
				/* remove it */
				*lp = l->next;
				free_portal_1(x);
				free(l);
			} else {
				lp = &l->next;
			}
			l = *lp;
		}

		if (e->portal.l == NULL) {
			/* no portal for this entry, destroy it */
			*ep = e->next;
			free_entry(e);
		} else {
			ep = &e->next;
		}
		e = *ep;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_list_add:
 *	Add one SCN entry to the SCN entry list.
 *
 * e	- the SCN entry.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_list_add(
	scn_registry_t *e
)
{
	scn_registry_t **pp;
	scn_portal_t *p;

	p = e->portal.p;
	e->portal.l = NULL;

	pp = &scn_registry;
	while (*pp) {
		if ((*pp)->uid == e->uid) {
			/* replace the bitmap */
			(*pp)->bitmap = e->bitmap;
			free_portal(p);
			free_entry(e);
			return (0);
		} else if ((*pp)->uid < e->uid) {
			break;
		}
		pp = &(*pp)->next;
	}

	(void) scn_add_portal(e, p);

	if (e->portal.l != NULL || sys_q == NULL) {
		/* insert it to the list */
		e->next = *pp;
		*pp = e;
	} else {
		/* no portal, ignore it */
		free_entry(e);
	}

	/* free the unused portal(s) */
	free_portal(p);

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_list_remove:
 *	Remove one SCN entry from the SCN entry list.
 *
 * uid	- the SCN entry unique ID.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_list_remove(
	uint32_t uid
)
{
	scn_registry_t **ep, *e;

	ep = &scn_registry;
	e = *ep;
	while (e) {
		if (e->uid == uid) {
			/* destroy it */
			*ep = e->next;
			free_entry(e);
			break;
		} else if (e->uid < uid) {
			break;
		}
		ep = &e->next;
		e = *ep;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_scn_port:
 *	The callback function which returns the SCN port of a portal object.
 *
 * p1	- the portal object.
 * p2	- the lookup control data.
 * return - the SCN port number.
 *
 * ****************************************************************************
 */
static int
cb_get_scn_port(
	void *p1,
	/*ARGSUSED*/
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;

	isns_attr_t *attr = &obj->attrs[
	    ATTR_INDEX_PORTAL(ISNS_SCN_PORT_ATTR_ID)];

	int port = 0;

	if (attr->tag != 0 && attr->value.ui != 0) {
		port = (int)attr->value.ui;
	}

	return (port);
}

/*
 * ****************************************************************************
 *
 * new_scn_portal:
 *	Make a new SCN portal.
 *
 * ref	- the ref count.
 * uid	- the portal object UID.
 * ip	- the ip address.
 * port	- the port number.
 * return - the SCN portal.
 *
 * ****************************************************************************
 */
static scn_portal_t *
new_scn_portal(
	uint32_t ref,
	uint32_t uid,
	in6_addr_t *ip,
	uint32_t port
)
{
	scn_portal_t *p;

	p = (scn_portal_t *)malloc(sizeof (scn_portal_t));
	if (p != NULL) {
		p->uid = uid;
		/* convert the ipv6 to ipv4 */
		if (((int *)ip)[0] == 0x00 &&
		    ((int *)ip)[1] == 0x00 &&
		    ((uchar_t *)ip)[8] == 0x00 &&
		    ((uchar_t *)ip)[9] == 0x00 &&
		    ((uchar_t *)ip)[10] == 0xFF &&
		    ((uchar_t *)ip)[11] == 0xFF) {
			p->sz = sizeof (in_addr_t);
			p->ip.in = ((uint32_t *)ip)[3];
			free(ip);
		} else {
			p->sz = sizeof (in6_addr_t);
			p->ip.in6 = ip;
		}
		p->port = port;
		p->ref = ref;
		p->so = 0;
		p->next = NULL;
	}

	return (p);
}

/*
 * ****************************************************************************
 *
 * extract scn_portal:
 *	Extract the SCN portal(s) for a storage node.
 *
 * name	- the storage node name.
 * return - the SCN portal list.
 *
 * ****************************************************************************
 */
static scn_portal_t *
extract_scn_portal(
	uchar_t *name
)
{
	scn_portal_t *list = NULL;
	scn_portal_t *p;

	lookup_ctrl_t lc_pg, lc_p;
	uint32_t pg_uid, uid;

	in6_addr_t *ip;
	uint32_t port;

	lc_pg.type = OBJ_PG;
	lc_pg.curr_uid = 0;
	lc_pg.id[0] = ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID);
	lc_pg.op[0] = OP_STRING;
	lc_pg.data[0].ptr = name;
	lc_pg.op[1] = 0;

	lc_pg.id[1] = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
	lc_pg.id[2] = ISNS_PG_PORTAL_PORT_ATTR_ID;

	lc_p.type = OBJ_PORTAL;
	lc_p.curr_uid = 0;
	lc_p.id[0] = ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID);
	lc_p.op[0] = OP_MEMORY_IP6;
	lc_p.id[1] = ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID);
	lc_p.op[1] = OP_INTEGER;
	lc_p.op[2] = 0;

	while (cache_lookup(&lc_pg, &pg_uid, cb_clone_attrs) == 0 &&
	    pg_uid != 0) {
		ip = lc_pg.data[1].ip;
		port = lc_pg.data[2].ui;
		if (ip != NULL) {
			lc_p.data[0].ip = ip;
			lc_p.data[1].ui = port;
			port = cache_lookup(&lc_p, &uid, cb_get_scn_port);
			if (port != 0 && uid != 0) {
				/* ref starts from 1 */
				p = new_scn_portal(1, uid, ip, port);
				if (p != NULL) {
					p->next = list;
					list = p;
				} else {
					free(ip);
					free(p);
				}
			} else {
				/* portal not registered or no scn port */
				free(ip);
			}
		}
		lc_pg.curr_uid = pg_uid;
	}

	return (list);
}

/*
 * ****************************************************************************
 *
 * cb_update_scn_bitmap:
 *	The callback function which updates the SCN Bitmap attribute of
 *	a storage node object.
 *
 * p1	- the storage node object.
 * p2	- the lookup control data.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
cb_update_scn_bitmap(
	void *p1,
	void *p2
)
{
	int ec = 0;

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

	int id = ATTR_INDEX_ISCSI(ISNS_ISCSI_SCN_BITMAP_ATTR_ID);
	isns_attr_t *attr = &obj->attrs[id];

	uint32_t bitmap = lcp->data[2].ui;

	if (bitmap != 0) {
		attr->tag = ISNS_ISCSI_SCN_BITMAP_ATTR_ID;
		attr->len = 4;
	} else if (attr->tag == 0) {
		return (ec);
	} else {
		attr->tag = 0;
		attr->len = 0;
	}
	attr->value.ui = bitmap;

	if (sys_q != NULL) {
		ec = write_data(DATA_UPDATE, obj);
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * cb_get_node_type:
 *	The callback function which returns the node type attribute of
 *	a storage node object.
 *
 * p1	- the storage node object.
 * p2	- the lookup control data.
 * return - error code.
 *
 * ****************************************************************************
 */
static int
cb_get_node_type(
	void *p1,
	/* LINTED E_FUNC_ARG_UNUSED */
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	isns_attr_t *attr = &obj->attrs[
	    ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
	int nt = (int)attr->value.ui;

	return (nt);
}

/*
 * ****************************************************************************
 *
 * cb_get_node_type:
 *	The callback function which returns the storage node object UID
 *	from a portal group object.
 *
 * p1	- the pg object.
 * p2	- the lookup control data.
 * return - the storage node object UID.
 *
 * ****************************************************************************
 */
static int
cb_pg_node(
	void *p1,
	/* LINTED E_FUNC_ARG_UNUSED */
	void *p2
)
{
	uint32_t ref;

	ref = get_ref_t(p1, OBJ_ISCSI);

	return ((int)ref);
}

/*
 * ****************************************************************************
 *
 * make_raw_entity:
 *	Make raw SCN data with a Network Entity object.
 *
 * obj	- the network entity object.
 * return - the raw SCN data.
 *
 * ****************************************************************************
 */
static scn_raw_t *
make_raw_entity(
	/*ARGSUSED*/
	isns_obj_t *obj
)
{
	scn_raw_t *raw;

	raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
	if (raw != NULL) {
		raw->type = obj->type;
		raw->uid = get_obj_uid(obj);
		raw->iscsi = NULL;
		raw->ref = 0;
		raw->ilen = 0;
		raw->nt = 0;
		raw->ip = NULL;
		raw->dd_id = 0;
		raw->dds_id = 0;
	} else {
		isnslog(LOG_DEBUG, "make_raw_entity", "malloc failed.");
	}

	return (raw);
}

/*
 * ****************************************************************************
 *
 * make_raw_iscsi:
 *	Make raw SCN data with a Storage Node object.
 *
 * obj	- the storage node object.
 * return - the raw SCN data.
 *
 * ****************************************************************************
 */
static scn_raw_t *
make_raw_iscsi(
	isns_obj_t *obj
)
{
	uint32_t uid;
	uint32_t nt;
	uchar_t *iscsi;
	uint32_t ilen;

	isns_attr_t *attr;

	scn_raw_t *raw;

	uid = get_obj_uid(obj);
	attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
	nt = attr->value.ui;
	attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];

	raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
	ilen = attr->len;
	iscsi = (uchar_t *)malloc(ilen);
	if (raw != NULL && iscsi != NULL) {
		/* copy the iscsi storage node name */
		(void) strcpy((char *)iscsi, (char *)attr->value.ptr);

		raw->type = obj->type;
		raw->uid = uid;
		raw->iscsi = iscsi;
		raw->ref = 0;
		raw->ilen = ilen;
		raw->nt = nt;
		raw->ip = NULL;
		raw->dd_id = 0;
		raw->dds_id = 0;
	} else {
		free(raw);
		free(iscsi);
		raw = NULL;
		isnslog(LOG_DEBUG, "make_raw_iscsi", "malloc failed.");
	}

	return (raw);
}

/*
 * ****************************************************************************
 *
 * make_raw_portal:
 *	Make raw SCN data with a Portal object.
 *
 * obj	- the portal object.
 * return - the raw SCN data.
 *
 * ****************************************************************************
 */
static scn_raw_t *
make_raw_portal(
	isns_obj_t *obj
)
{
	isns_attr_t *attr;
	in6_addr_t *ip;
	uint32_t port;

	scn_raw_t *raw;

	raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
	ip = (in6_addr_t *)malloc(sizeof (in6_addr_t));
	if (raw != NULL && ip != NULL) {
		attr = &obj->attrs[
		    ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
		(void) memcpy(ip, attr->value.ip, sizeof (in6_addr_t));
		attr = &obj->attrs[
		    ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];
		port = attr->value.ui;

		raw->type = obj->type;
		raw->uid = 0;
		raw->iscsi = NULL;
		raw->ref = 0;
		raw->ilen = 0;
		raw->nt = 0;
		raw->ip = ip;
		raw->port = port;
		raw->dd_id = 0;
		raw->dds_id = 0;
	} else {
		free(ip);
		free(raw);
		raw = NULL;
		isnslog(LOG_DEBUG, "make_raw_portal", "malloc failed.");
	}

	return (raw);
}

/*
 * ****************************************************************************
 *
 * make_raw_assoc_iscsi:
 *	Make raw SCN data with a Discovery Domain member association.
 *
 * obj	- the member association object.
 * return - the raw SCN data.
 *
 * ****************************************************************************
 */
static scn_raw_t *
make_raw_assoc_iscsi(
	isns_obj_t *obj
)
{
	uint32_t uid;
	uint32_t dd_id;
	uint32_t nt;

	lookup_ctrl_t lc;
	isns_attr_t *attr;

	scn_raw_t *raw;
	uchar_t *iscsi;
	uint32_t ilen;

	uid = get_obj_uid(obj);
	dd_id = get_parent_uid(obj);

	SET_UID_LCP(&lc, OBJ_ISCSI, uid);

	nt = cache_lookup(&lc, NULL, cb_get_node_type);

	attr = &obj->attrs[ATTR_INDEX_ASSOC_ISCSI(ISNS_DD_ISCSI_NAME_ATTR_ID)];

	raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
	ilen = attr->len;
	iscsi = (uchar_t *)malloc(ilen);
	if (raw != NULL && iscsi != NULL) {
		/* copy the iscsi storage node name */
		(void) strcpy((char *)iscsi, (char *)attr->value.ptr);

		raw->type = obj->type;
		raw->uid = uid;
		raw->iscsi = iscsi;
		raw->ref = 0;
		raw->ilen = ilen;
		raw->nt = nt;
		raw->ip = NULL;
		raw->dd_id = dd_id;
		raw->dds_id = 0;
	} else {
		free(raw);
		free(iscsi);
		raw = NULL;
		isnslog(LOG_DEBUG, "make_raw_assoc_iscsi", "malloc failed.");
	}

	return (raw);
}

/*
 * ****************************************************************************
 *
 * make_raw_assoc_dd:
 *	Make raw SCN data with a Discovery Domain Set member association.
 *
 * obj	- the member association object.
 * return - the raw SCN data.
 *
 * ****************************************************************************
 */
static scn_raw_t *
make_raw_assoc_dd(
	isns_obj_t *obj
)
{
	scn_raw_t *raw;

	raw = (scn_raw_t *)malloc(sizeof (scn_raw_t));
	if (raw != NULL) {
		raw->type = obj->type;
		raw->uid = 0;
		raw->iscsi = NULL;
		raw->ref = 0;
		raw->ilen = 0;
		raw->nt = 0;
		raw->ip = NULL;
		raw->dd_id = get_obj_uid(obj);
		raw->dds_id = get_parent_uid(obj);
	} else {
		isnslog(LOG_DEBUG, "make_raw_assoc_dd", "malloc failed.");
	}

	return (raw);
}

/*
 * ****************************************************************************
 *
 * scn_gen_entity:
 *	Generate SCN with the raw SCN data from a Network Entity object.
 *
 * raw	- the raw SCN data.
 * return - the SCN.
 *
 * ****************************************************************************
 */
static scn_text_t *
scn_gen_entity(
	/* LINTED E_FUNC_ARG_UNUSED */
	scn_raw_t *raw
)
{
	return (NULL);
}

/*
 * ****************************************************************************
 *
 * scn_gen_iscsi:
 *	Generate SCN with the raw SCN data from a Storage Node object.
 *
 * raw	- the raw SCN data.
 * return - the SCN.
 *
 * ****************************************************************************
 */
static scn_text_t *
scn_gen_iscsi(
	scn_raw_t *raw
)
{
	scn_text_t *text;

	text = (scn_text_t *)malloc(sizeof (scn_text_t));
	if (text != NULL) {
		text->flag = 0;
		text->ref = 1; /* start with 1 */
		text->uid = raw->uid;
		text->iscsi = raw->iscsi;
		raw->ref ++;
		text->ilen = raw->ilen;
		text->nt = raw->nt;
		text->dd_id = raw->dd_id;
		text->dds_id = raw->dds_id;
		text->next = NULL;
	} else {
		isnslog(LOG_DEBUG, "scn_gen_iscsi", "malloc failed.");
	}
	return (text);
}

/*
 * ****************************************************************************
 *
 * scn_gen_portal:
 *	Generate SCN with the raw SCN data from a Portal object.
 *
 * raw	- the raw SCN data.
 * return - the SCN.
 *
 * ****************************************************************************
 */
static scn_text_t *
scn_gen_portal(
	scn_raw_t *raw
)
{
	in6_addr_t *ip;
	uint32_t port;

	uint32_t pg_uid, uid;
	lookup_ctrl_t pg_lc, lc;

	uint32_t nt;
	uchar_t *name;
	int ilen;

	scn_text_t *text, *l = NULL;

	ip = raw->ip;
	port = raw->port;

	pg_lc.curr_uid = 0;
	pg_lc.type = OBJ_PG;
	pg_lc.id[0] = ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID);
	pg_lc.op[0] = OP_MEMORY_IP6;
	pg_lc.data[0].ip = ip;
	pg_lc.id[1] = ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID);
	pg_lc.op[1] = OP_INTEGER;
	pg_lc.data[1].ui = port;
	pg_lc.op[2] = 0;

	SET_UID_LCP(&lc, OBJ_ISCSI, 0);

	lc.id[1] = ISNS_ISCSI_NAME_ATTR_ID;
	lc.id[2] = ISNS_ISCSI_NODE_TYPE_ATTR_ID;
	lc.data[1].ptr = NULL;

	/* get a pg which is associated to the portal */
	uid = cache_lookup(&pg_lc, &pg_uid, cb_pg_node);
	while (pg_uid != 0) {
		if (uid != 0) {
			lc.data[0].ui = uid;
			(void) cache_lookup(&lc, NULL, cb_clone_attrs);
			name = lc.data[1].ptr;
			if (name != NULL) {
				nt = lc.data[2].ui;
				text = (scn_text_t *)malloc(
				    sizeof (scn_text_t));
				if (text != NULL) {
					text->flag = 0;
					text->ref = 1; /* start with 1 */
					text->uid = uid;
					text->iscsi = name;
					ilen = strlen((char *)name);
					ilen += 4 - (ilen % 4);
					text->ilen = ilen;
					text->nt = nt;
					text->dd_id = 0;
					text->dds_id = 0;
					text->next = l;
					l = text;
				} else {
					free(name);
					isnslog(LOG_DEBUG, "scn_gen_portal",
					    "malloc failed.");
				}
				lc.data[1].ptr = NULL;
			} else {
				isnslog(LOG_WARNING, "scn_gen_portal",
				    "cannot get node name.");
			}
		}

		/* get the next pg */
		pg_lc.curr_uid = pg_uid;
		uid = cache_lookup(&pg_lc, &pg_uid, cb_pg_node);
	}

	/* update the iscsi storage node object */
	raw->event = ISNS_OBJECT_UPDATED;

	return (l);
}

/*
 * ****************************************************************************
 *
 * scn_gen_assoc_dd:
 *	Generate SCN with the raw SCN data from a DD membership object.
 *
 * raw	- the raw SCN data.
 * return - the SCN.
 *
 * ****************************************************************************
 */
static scn_text_t *
scn_gen_assoc_dd(
	/* LINTED E_FUNC_ARG_UNUSED */
	scn_raw_t *raw
)
{
	return (NULL);
}

/*
 * ****************************************************************************
 *
 * make_scn:
 *	Make a SCN with an event and an object.
 *
 * event - the event.
 * obj	 - the object.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
int
make_scn(
	uint32_t event,
	isns_obj_t *obj
)
{
	scn_raw_t *raw = NULL;

	scn_raw_t *(*f)(isns_obj_t *) = make_raw[obj->type];

	if (f != NULL) {
		/* make raw scn data */
		raw = f(obj);
	}
	if (raw != NULL) {
		/* trigger an scn event */
		raw->event = event;
		(void) queue_msg_set(scn_q, SCN_SET, (void *)raw);
	}

	return (0);
}

/*
 * data structure of the SCN state transition table.
 */
typedef struct scn_tbl {
	int state;
	uint32_t event;
	isns_type_t type;
	int (*sf)(scn_raw_t *);
	int next_state;
} scn_tbl_t;

/*
 * the SCN state transition table.
 */
static const scn_tbl_t stbl[] = {
	{ -1, 0, OBJ_PG, NULL, 0 },
	{ -1, 0, OBJ_DD, NULL, 0 },
	{ -1, 0, OBJ_DDS, NULL, 0 },

	{ 0, ISNS_OBJECT_ADDED, OBJ_ENTITY, NULL, 1 },
	{ 1, ISNS_OBJECT_ADDED, OBJ_ISCSI, sf_gen, 1 },
	{ 1, ISNS_OBJECT_ADDED, 0, NULL, 1 },

	{ 0, ISNS_OBJECT_UPDATED, OBJ_ENTITY, sf_gen, 2 },
	{ 2, ISNS_OBJECT_UPDATED, 0, NULL, 2 },
	{ 2, ISNS_OBJECT_ADDED, OBJ_ISCSI, sf_gen, 2 },
	{ 2, ISNS_OBJECT_ADDED, 0, NULL, 2 },

	{ 0, ISNS_OBJECT_REMOVED, OBJ_ENTITY, NULL, 3 },
	{ 0, ISNS_OBJECT_REMOVED, 0, sf_gen, 4 },
	{ 3, ISNS_OBJECT_REMOVED, OBJ_ISCSI, sf_gen, 3 },
	{ 3, ISNS_OBJECT_REMOVED, 0, NULL, 3 },
	{ 4, ISNS_OBJECT_REMOVED, 0, sf_gen, 4 },

	{ 0, ISNS_MEMBER_ADDED, OBJ_ASSOC_ISCSI, sf_gen, 5 },
	{ 5, ISNS_MEMBER_ADDED, OBJ_ASSOC_ISCSI, sf_gen, 5 },

	{ 0, ISNS_MEMBER_ADDED, OBJ_ASSOC_DD, sf_gen, 6 },
	{ 6, ISNS_MEMBER_ADDED, OBJ_ASSOC_DD, sf_gen, 6 },

	{ 0, ISNS_MEMBER_REMOVED, OBJ_ASSOC_ISCSI, sf_gen, 7 },
	{ 7, ISNS_MEMBER_REMOVED, OBJ_ASSOC_ISCSI, sf_gen, 7 },

	{ 0, ISNS_MEMBER_REMOVED, OBJ_ASSOC_DD, sf_gen, 8 },
	{ 8, ISNS_MEMBER_REMOVED, OBJ_ASSOC_DD, sf_gen, 8 },

	{ -1, 0, 0, sf_error, -1 }
};

/*
 * ****************************************************************************
 *
 * scn_disp1:
 *	Dispatch one SCN to one SCN entry.
 *
 * event - the event.
 * p	 - the SCN entry.
 * t	 - the SCN.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_disp1(
	uint32_t event,
	scn_registry_t *p,
	scn_text_t *t
)
{
	scn_t *s, *r = NULL;
	scn_list_t *l, **lp;

	s = p->scn;

	while (s != NULL) {
		if (s->event == event) {
			l = s->data.list;
			do {
				if (l->data.text->uid == t->uid) {
					/* duplicated */
					return (0);
				}
				lp = &l->next;
				l = *lp;
			} while (l != NULL);
			break;
		}
		r = s;
		s = s->next;
	}

	l = (scn_list_t *)malloc(sizeof (scn_list_t));
	if (l != NULL) {
		if (s == NULL) {
			s = (scn_t *)malloc(sizeof (scn_t));
			if (s != NULL) {
				s->event = event;
				s->next = NULL;
				if (r != NULL) {
					r->next = s;
				} else {
					p->scn = s;
				}
				lp = &s->data.list;
			} else {
				free(l);
				isnslog(LOG_DEBUG, "scn_disp1",
				    "malloc scn failed.\n");
				return (0);
			}
		}

		t->ref ++;
		l->data.text = t;
		l->next = NULL;
		*lp = l;
	} else {
		isnslog(LOG_DEBUG, "scn_disp1",
		    "malloc list failed.\n");
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_disp1:
 *	Dispatch one SCN to every SCN entry and update the dispatch status.
 *
 * event - the event.
 * text	 - the SCN.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_disp(
	uint32_t event,
	scn_text_t *text
)
{
	scn_registry_t *registry, *p;
	uint32_t dd_id = 0;

	scn_text_t *t;

	uint32_t e;

	registry = scn_registry;

	t = text;
	while (t != NULL) {
		e = event;
		if (t->flag == 0) {
			if (e & ISNS_MEMBER_ADDED) {
				e |= ISNS_OBJECT_ADDED;
			} else if (e & ISNS_MEMBER_REMOVED) {
				e |= ISNS_OBJECT_REMOVED;
			}
		}
		p = registry;
		while (p != NULL) {
			if (SCN_TEST(e, p->bitmap, p->uid, t->uid, t->nt)) {
				if (p->bitmap & ISNS_MGMT_REG) {
					/* management scn are not bound */
					/* by discovery domain service. */
					dd_id = 1;
				} else {
					dd_id = 0;
					/* lock the cache for reading */
					(void) cache_lock_read();
					/* verify common dd */
					do {
						dd_id = get_common_dd(
						    p->uid,
						    t->uid,
						    dd_id);
					} while (dd_id > 0 &&
					    is_dd_active(dd_id) == 0);
					/* unlock the cache */
					(void) cache_unlock_nosync();
				}
				if (dd_id != 0) {
					(void) scn_disp1(e, p, t);
				}
			}
			p = p->next;
		}
		t = t->next;
	}

	while (text != NULL) {
		t = text->next;
		/* clean up the scn text(s) which nobody cares about. */
		free_scn_text(text);
		text = t;
	}

	if (dd_id != 0) {
		/* scn(s) are dispatched. */
		scn_dispatched = 1;
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * sf_gen:
 *	State transition function which generates and dispatches SCN(s).
 *
 * raw	- the raw SCN data.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
sf_gen(
	scn_raw_t *raw
)
{
	uint32_t event;

	scn_text_t *(*gen)(scn_raw_t *);
	scn_text_t *text = NULL;

	gen = scn_gen[raw->type];
	if (gen != NULL) {
		text = gen(raw);
	}

	event = raw->event;
	if (text != NULL) {
		(void) scn_disp(event, text);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * sf_error:
 *	State transition function for an error state. It free any SCN(s)
 *	which have been generated and dispatched previously.
 *
 * raw	- the raw SCN data.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
sf_error(
	/* LINTED E_FUNC_ARG_UNUSED */
	scn_raw_t *raw
)
{
	free_scn();

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_transition:
 *	Performs the state transition when a SCN event occurs.
 *
 * state - the previous state.
 * raw	 - the raw SCN data.
 * return - the next state.
 *
 * ****************************************************************************
 */
static int
scn_transition(
	int state,
	scn_raw_t *raw
)
{
	uint32_t event = raw->event;
	isns_type_t type = raw->type;

	int new_state = state;

	const scn_tbl_t *tbl;

	tbl = &stbl[0];
	for (;;) {
		if ((tbl->state == -1 || tbl->state == state) &&
		    (tbl->event == 0 || tbl->event == event) &&
		    (tbl->type == 0 || tbl->type == type)) {
			if (tbl->next_state != 0) {
				new_state = tbl->next_state;
			}
			if (tbl->sf != NULL) {
				tbl->sf(raw);
			}
			break;
		}
		tbl ++;
	}

	if (new_state == -1) {
		isnslog(LOG_DEBUG, "scn_transition",
		    "prev state: %d new event: 0x%x new object: %d.\n",
		    state, event, type);
		new_state = 0;
	}

	state = new_state;

	return (state);
}

/*
 * ****************************************************************************
 *
 * connect_to:
 *	Create socket connection with peer network portal.
 *
 * sz	- the size of the ip addr.
 * in	- the ipv4 address.
 * in6	- the ipv6 address.
 * port2- the port info.
 * return - the socket descriptor.
 *
 * ****************************************************************************
 */
int
connect_to(
	int sz,
	in_addr_t in,
	/* LINTED E_FUNC_ARG_UNUSED */
	in6_addr_t *in6,
	uint32_t port2
)
{
	int so = -1;

	union {
		struct sockaddr sin;
		struct sockaddr_in in;
		struct sockaddr_in6 in6;
	} ca = { 0 };

	int tcp;
	uint16_t port;

	tcp = (port2 & 0x10000) == 0 ? 1 : 0;
	port = (uint16_t)(port2 & 0xFFFF);
	if (sz == sizeof (in_addr_t)) {
		if (tcp != 0) {
			so = socket(AF_INET, SOCK_STREAM, 0);
			if (so != -1) {
				ca.in.sin_family = AF_INET;
				ca.in.sin_port = htons(port);
				ca.in.sin_addr.s_addr = in;
				if (connect(so, &ca.sin, sizeof (ca.in)) !=
				    0) {
					isnslog(LOG_DEBUG, "connect_to",
					    "connect() failed %%m.");
					(void) close(so);
					so = -1;
				}
			} else {
				isnslog(LOG_DEBUG, "connect_to",
				    "socket() failed %%m.");
			}
		} else {
			/* FIXME: UDP support */
			isnslog(LOG_DEBUG, "connect_to", "No UDP support.");
		}
	} else {
		/* FIXME: IPv6 support */
		isnslog(LOG_DEBUG, "connect_to", "No IPv6 support.");
	}

	return (so);
}

/*
 * ****************************************************************************
 *
 * emit_scn:
 *	Emit the SCN to any portal of the peer storage node.
 *
 * list	- the list of portal.
 * pdu	- the SCN packet.
 * pl	- the SCN packet payload length.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
emit_scn(
	scn_list_t *list,
	isns_pdu_t *pdu,
	size_t pl
)
{
	int so = 0;
	scn_list_t *l;
	scn_portal_t *p;

	isns_pdu_t *rsp = NULL;
	size_t rsp_sz;

	pdu->version = htons((uint16_t)ISNSP_VERSION);
	pdu->func_id = htons((uint16_t)ISNS_SCN);
	pdu->xid = htons(get_server_xid());

	l = list;
	while (l != NULL) {
		p = l->data.portal;
		so = connect_to(p->sz, p->ip.in, p->ip.in6, p->port);
		if (so != -1) {
			if (isns_send_pdu(so, pdu, pl) == 0) {
				/* This may help Solaris iSCSI Initiator */
				/* not to panic frequently. */
				(void) isns_rcv_pdu(so, &rsp, &rsp_sz,
				    ISNS_RCV_SHORT_TIMEOUT);
			} else {
				isnslog(LOG_DEBUG, "emit_scn",
				    "sending packet failed.");
			}
			(void) close(so);
			/* p->so = so; */
			break;
		}
		l = l->next;
	}

	if (rsp != NULL) {
#ifdef DEBUG
		dump_pdu1(rsp);
#endif
		free(rsp);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_trigger1:
 *	Trigger one SCN for one SCN entry.
 *
 * t	- the time that SCN is being triggered.
 * p	- the SCN entry.
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_trigger1(
	time_t t,
	scn_registry_t *p
)
{
	int ec;

	isns_pdu_t *pdu = NULL;
	size_t sz;
	size_t pl;

	scn_t *s;
	scn_list_t *l;
	scn_text_t *x;

	union {
		uint32_t i32;
		uint64_t i64;
	} u;

#ifdef DEBUG
	char buff[1024] = { 0 };
	char *logbuff = buff;
#endif

	ec = pdu_reset_scn(&pdu, &pl, &sz);
	if (pdu == NULL) {
		goto scn_done;
	}

	/* add destination attribute */
	ec = pdu_add_tlv(&pdu, &pl, &sz,
	    ISNS_ISCSI_NAME_ATTR_ID,
	    p->nlen,
	    (void *)p->name, 0);
	if (ec != 0) {
		goto scn_done;
	}

#ifdef DEBUG
	sprintf(logbuff, "==>%s ", p->name);
	logbuff += strlen(logbuff);
#endif

	/* add timestamp */
	u.i64 = BE_64((uint64_t)t);
	ec = pdu_add_tlv(&pdu, &pl, &sz,
	    ISNS_TIMESTAMP_ATTR_ID,
	    8,
	    (void *)&u.i64, 1);

	s = p->scn;
	while (s != NULL && ec == 0) {
		u.i32 = htonl(s->event);
		ec = pdu_add_tlv(&pdu, &pl, &sz,
		    ISNS_ISCSI_SCN_BITMAP_ATTR_ID,
		    4,
		    (void *)&u.i32, 1);
#ifdef DEBUG
		sprintf(logbuff, "EVENT [%d] ", s->event);
		logbuff += strlen(logbuff);
#endif
		l = s->data.list;
		while (l != NULL && ec == 0) {
			x = l->data.text;
			if (x->flag == 0) {
				ec = pdu_add_tlv(&pdu, &pl, &sz,
				    ISNS_ISCSI_NAME_ATTR_ID,
				    x->ilen, (void *)x->iscsi, 0);
#ifdef DEBUG
				sprintf(logbuff, "FROM [%s] ", x->iscsi);
				logbuff += strlen(logbuff);
#endif
				if (ec == 0 &&
				    (p->bitmap &
				    (ISNS_MEMBER_ADDED |
				    ISNS_MEMBER_REMOVED))) {
					/* management SCN */
					u.i32 = htonl(x->dd_id);
					ec = pdu_add_tlv(&pdu, &pl, &sz,
					    ISNS_DD_ID_ATTR_ID,
					    4, (void *)&u.i32, 1);
#ifdef DEBUG
					sprintf(logbuff, "IN DD [%d] ",
					    x->dd_id);
					logbuff += strlen(logbuff);
#endif
				}
			} else {
				/* add(remove) dd to(from) dd-set */
				u.i32 = htonl(x->dd_id);
				ec = pdu_add_tlv(&pdu, &pl, &sz,
				    ISNS_DD_ID_ATTR_ID,
				    4, (void *)&u.i32, 1);
				u.i32 = htonl(x->dds_id);
				if (ec == 0) {
					ec = pdu_add_tlv(&pdu, &pl, &sz,
					    ISNS_DD_ID_ATTR_ID,
					    4, (void *)&u.i32, 1);
				}
#ifdef DEBUG
				sprintf(logbuff, "FROM [%d] ", x->dd_id);
				logbuff += strlen(logbuff);
				sprintf(logbuff, "IN [%d] ", x->dds_id);
				logbuff += strlen(logbuff);
#endif
			}
			l = l->next;
		}
		s = s->next;
	}

scn_done:
	if (ec == 0) {
#ifdef DEBUG
		isnslog(LOG_DEBUG, "scn_trigger1", buff);
#endif
		ec = emit_scn(p->portal.l, pdu, pl);
	} else {
		isnslog(LOG_DEBUG, "scn_trigger1", " failed.\n");
	}

	free(pdu);

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_trigger:
 *	Trigger one SCN for every SCN entry.
 *
 * return - always successful (0).
 *
 * ****************************************************************************
 */
static int
scn_trigger(
)
{
	time_t t;
	scn_registry_t *p;

	t = time(NULL);

	p = scn_registry;
	while (p != NULL) {
		if (p->scn != NULL) {
			(void) scn_trigger1(t, p);
		}
		p = p->next;
	}

	return (0);
}

/*
 * global functions.
 */

/*
 * ****************************************************************************
 *
 * scn_list_load:
 *	Load one SCN entry and add it to the SCN entry list.
 *
 * uid	- the Storage Node object UID.
 * node	- the Storage Node name.
 * nlen	- the length of the name.
 * bitmap - the SCN bitmap.
 * return - error code.
 *
 * ****************************************************************************
 */
int
scn_list_load(
	uint32_t uid,
	uchar_t *node,
	uint32_t nlen,
	uint32_t bitmap
)
{
	int ec = 0;

	scn_registry_t *list;
	uchar_t *name;

	list = (scn_registry_t *)malloc(sizeof (scn_registry_t));
	name = (uchar_t *)malloc(nlen);

	if (list != NULL && name != NULL) {
		list->uid = uid;
		(void) strcpy((char *)name, (char *)node);
		list->name = name;
		list->nlen = nlen;
		list->bitmap = bitmap;
		list->portal.l = NULL;
		list->scn = NULL;
		list->next = NULL;
		ASSERT(scn_q == NULL);
		(void) scn_list_add(list);
	} else {
		free(list);
		free(name);
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * verify_scn_portal:
 *	Extract and verify portals for every SCN entry(s) after they are
 *	loaded from data store, for those which do not have a SCN portal,
 *	remove it from the SCN entry list.
 *
 * return - 1: error occurs, otherwise 0.
 *
 * ****************************************************************************
 */
int
verify_scn_portal(
)
{
	scn_registry_t **pp, *e;
	scn_portal_t *p;

	pp = &scn_registry;
	while (*pp != NULL) {
		e = *pp;
		p = extract_scn_portal(e->name);
		if (p != NULL) {
			if (scn_add_portal(e, p) != 0) {
				return (1);
			}
		}
		if (e->portal.l != NULL) {
			pp = &e->next;
		} else {
			/* remove this entry */
			*pp = e->next;
			free_entry(e);
		}
		/* free the unused portal(s) */
		free_portal(p);
	}

	return (0);
}

/*
 * ****************************************************************************
 *
 * add_scn_entry:
 *	Add a SCN entry.
 *
 * node	- the Storage Node name.
 * nlen	- the length of the name.
 * bitmap - the SCN bitmap.
 * return - error code.
 *
 * ****************************************************************************
 */
int
add_scn_entry(
	uchar_t *node,
	uint32_t nlen,
	uint32_t bitmap
)
{
	int ec = 0;

	uint32_t mgmt;
	scn_portal_t *p;

	lookup_ctrl_t lc;
	uint32_t uid;
	scn_registry_t *e;
	uchar_t *name;

	mgmt = bitmap & (
	    ISNS_MGMT_REG |
	    ISNS_MEMBER_REMOVED |
	    ISNS_MEMBER_ADDED);

	if ((mgmt > 0 &&
	    (mgmt_scn == 0 ||
	    mgmt < ISNS_MGMT_REG ||
	    is_control_node(node) == 0)) ||
	    (p = extract_scn_portal(node)) == NULL) {
		return (ISNS_RSP_SCN_REGIS_REJECTED);
	}

	e = (scn_registry_t *)malloc(sizeof (scn_registry_t));
	name = (uchar_t *)malloc(nlen);
	if (e != NULL && name != NULL) {
		lc.type = OBJ_ISCSI;
		lc.curr_uid = 0;
		lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
		lc.data[0].ptr = node;
		lc.op[0] = OP_STRING;
		lc.op[1] = 0;
		lc.data[2].ui = bitmap;
		ec = cache_lookup(&lc, &uid, cb_update_scn_bitmap);
		if (uid == 0) {
			ec = ISNS_RSP_SCN_REGIS_REJECTED;
		}
		if (ec == 0) {
			e->uid = uid;
			(void) strcpy((char *)name, (char *)node);
			e->name = name;
			e->nlen = nlen;
			e->bitmap = bitmap;
			e->portal.p = p;
			e->scn = NULL;
			e->next = NULL;
			(void) queue_msg_set(scn_q, SCN_ADD, (void *)e);
		}
	} else {
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	if (ec != 0) {
		free(e);
		free(name);
		free_portal(p);
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * remove_scn_entry:
 *	Remove a SCN entry.
 *
 * node	- the Storage Node name.
 * return - error code.
 *
 * ****************************************************************************
 */
int
remove_scn_entry(
	uchar_t *node
)
{
	int ec = 0;

	lookup_ctrl_t lc;
	uint32_t uid;

	lc.type = OBJ_ISCSI;
	lc.curr_uid = 0;
	lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
	lc.data[0].ptr = node;
	lc.op[0] = OP_STRING;
	lc.op[1] = 0;
	lc.data[2].ui = 0;
	ec = cache_lookup(&lc, &uid, cb_update_scn_bitmap);
	if (ec == 0 && uid != 0) {
		(void) queue_msg_set(scn_q, SCN_REMOVE, (void *)uid);
	}

	return (ec);
}

/*
 * ****************************************************************************
 *
 * remove_scn_portal:
 *	Remove a portal from every SCN entry.
 *
 * uid	- the Portal object UID.
 * return - alrays successful (0).
 *
 * ****************************************************************************
 */
int
remove_scn_portal(
	uint32_t uid
)
{
	(void) queue_msg_set(scn_q, SCN_REMOVE_P, (void *)uid);

	return (0);
}

/*
 * ****************************************************************************
 *
 * scn_proc:
 *	The entry point of the SCN thread. It listens on the SCN message
 *	queue and process every SCN related stuff.
 *
 * arg	- nothing.
 * return - NULL.
 *
 * ****************************************************************************
 */
void *
scn_proc(
	/* LINTED E_FUNC_ARG_UNUSED */
	void *arg
)
{
	int state = 0;

	scn_raw_t *raw;
	msg_text_t *msg;

	for (;;) {
		msg = queue_msg_get(scn_q);
		switch (msg->id) {
		case SCN_ADD:
			(void) scn_list_add((scn_registry_t *)msg->data);
			break;
		case SCN_REMOVE:
			(void) scn_list_remove((uint32_t)msg->data);
			break;
		case SCN_REMOVE_P:
			(void) scn_remove_portal((uint32_t)msg->data);
			break;
		case SCN_SET:
			raw = (scn_raw_t *)msg->data;
			state = scn_transition(state, raw);
			/* free the raw data */
			free_raw(raw);
			break;
		case SCN_TRIGGER:
			if (scn_dispatched != 0) {
				(void) scn_trigger();
			}
			/* FALLTHROUGH */
		case SCN_IGNORE:
			/* clean the scn(s) */
			free_scn();
			/* reset the state */
			state = 0;
			/* reset the scn_dispatched flag */
			scn_dispatched = 0;
			break;
		case SCN_STOP:
			queue_msg_free(msg);
			return (NULL);
		default:
			break;
		}
		queue_msg_free(msg);
	}
}