isns/isnsd/scn.c

	scn.c revision fcf3ce441efd61da9bb2884968af01cb7c1452cc
/*
 * 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();
            }
        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);
    }
}