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

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

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

#include "isns_server.h"
#include "isns_cfg.h"
#include "isns_htab.h"
#include "isns_cache.h"
#include "isns_obj.h"
#include "isns_dd.h"
#include "isns_utils.h"
#include "isns_mgmt.h"
#include "isns_protocol.h"
#include "admintf.h"

extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];

static isns_type_t
get_lc_type(
        object_type obj
)
{
        isns_type_t type;

        switch (obj) {
        case Node:
                type = OBJ_ISCSI;
                break;
        case DiscoveryDomain:
        case DiscoveryDomainMember:
                type = OBJ_DD;
                break;
        case DiscoveryDomainSet:
        case DiscoveryDomainSetMember:
                type = OBJ_DDS;
                break;
        default:
                ASSERT(0);
                break;
        }

        return (type);
}

static uint32_t
get_lc_id(
        object_type obj
)
{
        uint32_t id;

        switch (obj) {
        case Node:
                id = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
                break;
        case DiscoveryDomain:
        case DiscoveryDomainMember:
                id = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
                break;
        case DiscoveryDomainSet:
        case DiscoveryDomainSetMember:
                id = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
                break;
        default:
                ASSERT(0);
                break;
        }

        return (id);
}

/*
 * ****************************************************************************
 *
 * cb_get_node_info: callback for get_node_op
 *      The routine process matching node and add a Node object elements
 *      to the response doc.
 *
 * p1   - matching node object
 * p2   - lookup control data that was used for node look up
 *          returns parent index(newtork entity) in look up control.
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_node_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, sub_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)NODEOBJECT);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
        switch (attr->value.ui) {
            case ISNS_CONTROL_NODE_TYPE | ISNS_INITIATOR_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODEINITIATORTYPE);
                break;
            case ISNS_CONTROL_NODE_TYPE | ISNS_TARGET_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODETARGETTYPE);
                break;
            case ISNS_TARGET_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)TARGETTYPE);
                break;
            case ISNS_INITIATOR_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)INITIATORTYPE);
                break;
            case ISNS_CONTROL_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODETYPE);
                break;
            default:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)UNKNOWNTYPE);
        }
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_ALIAS_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)ALIASATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /*
         * A node can have all or no SCN subsribtion.
         * May avoid redundant code with scsusrciption table.
         */
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_SCN_BITMAP_ATTR_ID)];
        if (IS_SCN_INIT_SELF_INFO_ONLY(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNINITSELFONLY);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_TARGET_SELF_INFO_ONLY(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNTARGETSELFONLY);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_MGMT_REG(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNTARGETSELFONLY);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_OBJ_REMOVED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNOBJECTREMOVED);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_OBJ_ADDED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNOBJECTADDED);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_OBJ_UPDATED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNOBJECTUPDATED);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_MEMBER_REMOVED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNMEMBERREMOVED);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }
        if (IS_SCN_MEMBER_ADDED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)SCNSUBSCRIPTION,
                (xmlChar *)SCNMEMBERADDED);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }

        /* set the parent object id, i.e. the network entity object id */
        lcp->id[2] = get_parent_uid(obj);
        /* pass back the node object element to add entity, portal info to it */
        lcp->data[2].ptr =  (uchar_t *)n_node;

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_entity_info: callback for get_node_op
 *      The routine process matching network entity and add children elements
 *      to a Node object for given entity.
 *
 * p1   - matching entity object
 * p2   - lookup control data that was used for node look up
 *          returns parent index(newtork entity) in look up control.
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_entity_info(
        void *p1,
        void *p2
)
{
        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlNodePtr n_node = (xmlNodePtr)lcp->data[2].ptr;
        xmlNodePtr sub_node, subchild_node, subgrandchild_node;
        char numbuf[32];
        char buff[INET6_ADDRSTRLEN + 1] = { 0 };
        isns_attr_t *attr;

        sub_node = xmlNewChild(n_node, NULL, (xmlChar *)NETWORKENTITY, NULL);

        if (sub_node) {
            attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)];
            subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)ENTITYID, (xmlChar *)attr->value.ptr);
            if (subchild_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_ENTITY_PROTOCOL_ATTR_ID)];
            (void) sprintf(numbuf, "%u", attr->value.ui);
            subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)ENTITYPROTOCOL, (xmlChar *)numbuf);
            if (subchild_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_MGMT_IP_ADDR_ATTR_ID)];
            if (attr->value.ip) {
                /* convert the ipv6 to ipv4 */
                if (((int *)attr->value.ip)[0] == 0x00 &&
                    ((int *)attr->value.ip)[1] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[8] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[9] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[10] == 0xFF &&
                    ((uchar_t *)attr->value.ip)[11] == 0xFF) {
                    subchild_node = xmlNewChild(sub_node, NULL,
                        (xmlChar *)MANAGEMENTIPADDR,
                        (xmlChar *)inet_ntop(AF_INET,
                        (void *)&(((uint32_t *)attr->value.ip)[3]),
                        buff, sizeof (buff)));
                } else {
                    subchild_node = xmlNewChild(sub_node, NULL,
                        (xmlChar *)MANAGEMENTIPADDR,
                        (xmlChar *)inet_ntop(AF_INET6,
                        (void *)attr->value.ip, buff, sizeof (buff)));
                }
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_TIMESTAMP_ATTR_ID)];
            if (attr->value.ui) {
                (void) sprintf(numbuf, "%u", attr->value.ui);
                subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)ENTITYREGTIMESTAMP, (xmlChar *)numbuf);
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_VERSION_RANGE_ATTR_ID)];
            if (attr->value.ui) {
                subchild_node = xmlNewNode(NULL,
                    (xmlChar *)PROTOCOLVERSIONRANGE);
                subchild_node = xmlAddChild(sub_node, subchild_node);
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }

                (void) sprintf(numbuf, "%u",
                    (attr->value.ui >> ISNS_VER_SHIFT) & ISNS_VERSION);
                subgrandchild_node = xmlNewChild(subchild_node, NULL,
                    (xmlChar *)PROTOCOLMAXVERSION, (xmlChar *)numbuf);
                if (subgrandchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                (void) sprintf(numbuf, "%u", attr->value.ui & ISNS_VERSION);
                subgrandchild_node = xmlNewChild(subchild_node, NULL,
                    (xmlChar *)PROTOCOLMINVERSION, (xmlChar *)numbuf);
                if (subgrandchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr =
                &obj->attrs[ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
            if (attr->value.ui) {
                (void) sprintf(numbuf, "%u", attr->value.ui);
                subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)REGISTRATIONPERIOD, (xmlChar *)numbuf);
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        } else {
            return (ERR_XML_NEWCHILD_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_pg_info: callback for get_node_op
 *      The routine process matching portal group and returns ip address
 *      and port number for further portal processing.
 *
 * p1   - matching portal group object
 * p2   - lookup control data that was used for portal group look up
 *          returns portal ip address, port and group tag in look up control.
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_pg_info(
        void *p1,
        void *p2
)
{
        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

        isns_attr_t *attr;

        /* get pg portal ip address and port attributes */
        attr = &obj->attrs[ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)];
        (void) memcpy(lcp->data[1].ip, attr->value.ip, sizeof (in6_addr_t));
        attr = &obj->attrs[ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID)];
        lcp->data[2].ui = attr->value.ui;
        attr = &obj->attrs[ATTR_INDEX_PG(ISNS_PG_TAG_ATTR_ID)];
        lcp->id[2] = attr->value.ui;

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_portal_info: callback for get_node_op
 *      The routine process matching portal and add portal object info to
 *      the node object.
 *
 * p1   - matching portal object
 * p2   - lookup control data that was used for portal look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_portal_info(
        void *p1,
        void *p2
)
{
        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlNodePtr n_node = (xmlNodePtr)lcp->data[2].ptr;
        uint32_t    tag = lcp->id[2];
        xmlNodePtr sub_node, subchild_node, subgrandchild_node;
        char numbuf[32];
        char buff[INET6_ADDRSTRLEN + 1] = { 0 };
        isns_attr_t *attr;

        sub_node = xmlNewChild(n_node, NULL, (xmlChar *)PORTAL, NULL);

        /* get portal object attributes. */
        if (sub_node) {
            attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
            if (attr->value.ip) {
                /* convert the ipv6 to ipv4 */
                if (((int *)attr->value.ip)[0] == 0x00 &&
                    ((int *)attr->value.ip)[1] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[8] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[9] == 0x00 &&
                    ((uchar_t *)attr->value.ip)[10] == 0xFF &&
                    ((uchar_t *)attr->value.ip)[11] == 0xFF) {
                    subchild_node = xmlNewChild(sub_node, NULL,
                        (xmlChar *)IPADDR,
                        (xmlChar *)inet_ntop(AF_INET,
                        (void *)&(((uint32_t *)attr->value.ip)[3]),
                        buff, sizeof (buff)));
                } else {
                    subchild_node = xmlNewChild(sub_node, NULL,
                        (xmlChar *)IPADDR,
                        (xmlChar *)inet_ntop(AF_INET6,
                        (void *)attr->value.ip, buff, sizeof (buff)));
                }
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            subchild_node = xmlNewChild(sub_node, NULL, (xmlChar *)UDPTCPPORT,
                NULL);
            if (subchild_node) {
                attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];
                subgrandchild_node = xmlNewChild(subchild_node, NULL,
                    (xmlChar *)PORTTYPE, IS_PORT_UDP(attr->value.ui) ?
                    (xmlChar *)UDPPORT : (xmlChar *)TCPPORT);
                if (subgrandchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                (void) sprintf(numbuf, "%u", PORT_NUMBER(attr->value.ui));
                subgrandchild_node = xmlNewChild(subchild_node, NULL,
                    (xmlChar *)PORTNUMBER, (xmlChar *)numbuf);
                if (subgrandchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            } else {
                return (ERR_XML_NEWCHILD_FAILED);
            }
            (void) sprintf(numbuf, "%u", tag);
            subchild_node = xmlNewChild(sub_node, NULL, (xmlChar *)GROUPTAG,
                (xmlChar *)numbuf);
            if (subchild_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_NAME_ATTR_ID)];
            if (attr->value.ptr) {
                subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)SYMBOLICNAME, (xmlChar *)attr->value.ptr);
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_ESI_INTERVAL_ATTR_ID)];
            if (attr->value.ui) {
                (void) sprintf(numbuf, "%u", attr->value.ui);
                subchild_node = xmlNewChild(sub_node, NULL,
                (xmlChar *)ESIINTERVAL, (xmlChar *)numbuf);
                if (subchild_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_ESI_PORT_ATTR_ID)];
            if (attr->value.ui) {
                subchild_node = xmlNewChild(sub_node, NULL,
                    (xmlChar *)ESIPORT, NULL);
                if (subchild_node) {
                    subgrandchild_node = xmlNewChild(subchild_node, NULL,
                        (xmlChar *)PORTTYPE, IS_PORT_UDP(attr->value.ui) ?
                        (xmlChar *)UDPPORT : (xmlChar *)TCPPORT);
                    if (subgrandchild_node == NULL) {
                        return (ERR_XML_NEWCHILD_FAILED);
                    }
                    (void) sprintf(numbuf, "%u", PORT_NUMBER(attr->value.ui));
                    subgrandchild_node = xmlNewChild(subchild_node, NULL,
                        (xmlChar *)PORTNUMBER, (xmlChar *)numbuf);
                    if (subgrandchild_node == NULL) {
                        return (ERR_XML_NEWCHILD_FAILED);
                    }
                } else {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
            attr = &obj->attrs[ATTR_INDEX_PORTAL(ISNS_SCN_PORT_ATTR_ID)];
            if (attr->value.ui) {
                subchild_node = xmlNewChild(sub_node, NULL,
                    (xmlChar *)SCNPORT, NULL);
                if (subchild_node) {
                    subgrandchild_node = xmlNewChild(subchild_node, NULL,
                        (xmlChar *)PORTTYPE, IS_PORT_UDP(attr->value.ui) ?
                        (xmlChar *)UDPPORT : (xmlChar *)TCPPORT);
                    (void) sprintf(numbuf, "%u", PORT_NUMBER(attr->value.ui));
                    if (subgrandchild_node == NULL) {
                        return (ERR_XML_NEWCHILD_FAILED);
                    }
                    subgrandchild_node = xmlNewChild(subchild_node, NULL,
                        (xmlChar *)PORTNUMBER, (xmlChar *)numbuf);
                    if (subgrandchild_node == NULL) {
                        return (ERR_XML_NEWCHILD_FAILED);
                    }
                } else {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        } else if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_dd_info: callback for get_dd_op
 *      The routine process matching dd object
 *
 * p1   - matching dd object
 * p2   - lookup control data that was used for dd look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_dd_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, sub_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;
        char numbuf[32];

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDOBJECT);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID)];
        (void) sprintf(numbuf, "%u", attr->value.ui);
        n_attr = xmlSetProp(n_node, (xmlChar *)IDATTR,
                (xmlChar *)numbuf);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_FEATURES_ATTR_ID)];
        if (DD_BOOTLIST_ENABLED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)BOOTLISTENABLEDELEM,
                (xmlChar *)XMLTRUE);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        } else {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)BOOTLISTENABLEDELEM,
                (xmlChar *)XMLFALSE);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_get_ddset_info: callback for get_ddset_op
 *      The routine process matching dd object
 *
 * p1   - matching dds object
 * p2   - lookup control data that was used for dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_get_ddset_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, sub_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;
        char numbuf[32];

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID)];
        (void) sprintf(numbuf, "%u", attr->value.ui);
        n_attr = xmlSetProp(n_node, (xmlChar *)IDATTR,
                (xmlChar *)numbuf);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_STATUS_ATTR_ID)];
        if (DDS_ENABLED(attr->value.ui)) {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)ENABLEDELEM,
                (xmlChar *)XMLTRUE);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        } else {
            sub_node = xmlNewChild(n_node, NULL, (xmlChar *)ENABLEDELEM,
                (xmlChar *)XMLFALSE);
            if (sub_node == NULL) {
                return (ERR_XML_NEWCHILD_FAILED);
            }
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_enumerate_node_info: callback for enumerate_node_op
 *      The routine is invoked for each node object.
 *
 * p1   - node object
 * p2   - lookup control data that was used for node look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_enumerate_node_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)NODEOBJECT);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
        switch (attr->value.ui) {
            case ISNS_CONTROL_NODE_TYPE | ISNS_INITIATOR_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODEINITIATORTYPE);
                break;
            case ISNS_CONTROL_NODE_TYPE | ISNS_TARGET_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODETARGETTYPE);
                break;
            case ISNS_TARGET_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)TARGETTYPE);
                break;
            case ISNS_INITIATOR_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)INITIATORTYPE);
                break;
            case ISNS_CONTROL_NODE_TYPE:
                n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)CONTROLNODETYPE);
                break;
            default:
            n_attr = xmlSetProp(n_node, (xmlChar *)TYPEATTR,
                    (xmlChar *)UNKNOWNTYPE);
        }
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_ALIAS_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)ALIASATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * i_enumerate_dd_dds_info:
 *      The routine is implemnetation for enumerate dd and enumerate dds.
 *
 * p1   - dd or dd set object
 * p2   - lookup control data that was used for dd and dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
i_enumerate_dd_dds_info(
        void *p1,
        void *p2,
        isns_type_t obj_type
)
{
        xmlNodePtr      n_obj, n_node, sub_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;
        char numbuf[32];

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        if (obj_type == OBJ_DD) {
            n_node = xmlNewNode(NULL, (xmlChar *)DDOBJECT);
        } else {
            n_node = xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
        }

        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        if (obj_type == OBJ_DD) {
            /* get name, id, feaure and generate xml info */
            attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)];
            n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
            if (n_attr == NULL) {
                return (ERR_XML_SETPROP_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID)];
            (void) sprintf(numbuf, "%u", attr->value.ui);
            n_attr = xmlSetProp(n_node, (xmlChar *)IDATTR,
                (xmlChar *)numbuf);
            if (n_attr == NULL) {
                return (ERR_XML_SETPROP_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_FEATURES_ATTR_ID)];
            if (DD_BOOTLIST_ENABLED(attr->value.ui)) {
                sub_node = xmlNewChild(n_node, NULL,
                    (xmlChar *)BOOTLISTENABLEDELEM, (xmlChar *)XMLTRUE);
                if (sub_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            } else {
                sub_node = xmlNewChild(n_node, NULL,
                    (xmlChar *)BOOTLISTENABLEDELEM, (xmlChar *)XMLFALSE);
                if (sub_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        } else {
            /* get name, id, status and generate xml info */
            attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)];
            n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                (xmlChar *)attr->value.ptr);
            if (n_attr == NULL) {
                return (ERR_XML_SETPROP_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID)];
            (void) sprintf(numbuf, "%u", attr->value.ui);
            n_attr = xmlSetProp(n_node, (xmlChar *)IDATTR,
                (xmlChar *)numbuf);
            if (n_attr == NULL) {
                return (ERR_XML_SETPROP_FAILED);
            }
            attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_STATUS_ATTR_ID)];
            if (DDS_ENABLED(attr->value.ui)) {
                sub_node = xmlNewChild(n_node, NULL,
                    (xmlChar *)ENABLEDELEM, (xmlChar *)XMLTRUE);
                if (sub_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            } else {
                sub_node = xmlNewChild(n_node, NULL,
                    (xmlChar *)ENABLEDELEM, (xmlChar *)XMLFALSE);
                if (sub_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_enumerate_dd_info: callback for enumerate_dd_op
 *      The routine is invoked for each dd object.
 *
 * p1   - dd object
 * p2   - lookup control data that was used for dd look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_enumerate_dd_info(
        void *p1,
        void *p2
)
{
        return (i_enumerate_dd_dds_info(p1, p2, OBJ_DD));
}

/*
 * ****************************************************************************
 *
 * cb_enumerate_ddset_info: callback for enumerate_dd_op
 *      The routine is invoked for each dd object.
 *
 * p1   - dd object
 * p2   - lookup control data that was used for dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_enumerate_ddset_info(
        void *p1,
        void *p2
)
{
        return (i_enumerate_dd_dds_info(p1, p2, OBJ_DDS));
}

/*
 * ****************************************************************************
 *
 * cb_getAssociated_node_info:
 *      The routine is implemnetation for enumerate dd and enumerate dds.
 *
 * p1   - dd or dd set object
 * p2   - lookup control data that was used for dd and dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_getAssociated_node_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;
        uchar_t *ddname = lcp->data[2].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDOBJECTMEMBER);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)NODENAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                (xmlChar *)ddname);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_getAssociated_node_to_dd_info:
 *      The routine is implemnetation for enumerate dd and enumerate dds.
 *
 * p1   - dd or dd set object
 * p2   - lookup control data that was used for dd and dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_getAssociated_node_to_dd_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;
        uchar_t *nodename = lcp->data[2].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDOBJECTMEMBER);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        n_attr = xmlSetProp(n_node, (xmlChar *)NODENAMEATTR,
                (xmlChar *)nodename);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_getAssociated_dd_info:
 *      The routine is implemnetation for getting dds membership.
 *
 * p1   - dd or dd set object
 * p2   - lookup control data that was used for dd and dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_getAssociated_dd_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;
        uchar_t *ddsetname = lcp->data[2].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDSETOBJECTMEMBER);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        attr = &obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        n_attr = xmlSetProp(n_node, (xmlChar *)DDSETNAMEATTR,
                (xmlChar *)ddsetname);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * cb_getAssociated_dd_to_ddset_info:
 *      The routine is implemnetation for enumerate dd and enumerate dds.
 *
 * p1   - dd or dd set object
 * p2   - lookup control data that was used for dd and dd set look up
 * return - error code
 *
 * ****************************************************************************
 */
static int
cb_getAssociated_dd_to_ddset_info(
        void *p1,
        void *p2
)
{
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        isns_attr_t *attr;

        isns_obj_t *obj = (isns_obj_t *)p1;
        lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
        xmlDocPtr doc = (xmlDocPtr)lcp->data[1].ptr;
        uchar_t *ddname = lcp->data[2].ptr;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        n_node = xmlNewNode(NULL, (xmlChar *)DDSETOBJECTMEMBER);
        if (n_node) {
            n_node = xmlAddChild(n_obj, n_node);
            if (n_node == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        /* get node name, alias, type and generate xml info */
        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                (xmlChar *)ddname);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }
        attr = &obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)];
        n_attr = xmlSetProp(n_node, (xmlChar *)DDSETNAMEATTR,
                (xmlChar *)attr->value.ptr);
        if (n_attr == NULL) {
            return (ERR_XML_SETPROP_FAILED);
        }

        /* successful */
        return (0);
}

/*
 * ****************************************************************************
 *
 * handle_partial_success:
 *
 * doc  - response doc to fill up
 * ret  - return code from the caller.
 *
 * ****************************************************************************
 */
static int
handle_partial_success(
        xmlDocPtr doc,
        int ret
)
{
        xmlNodePtr      n_obj, n_node, root;
        char numbuf[32];

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)RESULTELEMENT);
        if (n_obj) {
            if (root->children) {
                n_obj = xmlAddPrevSibling(root->children, n_obj);
                (void) sprintf(numbuf, "%d", (ret != 0) ? PARTIAL_SUCCESS : 0);
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)STATUSELEMENT,
                    (xmlChar *)numbuf);
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)MESSAGEELEMENT,
                    (xmlChar *)result_code_to_str((ret != 0) ?
                        PARTIAL_SUCCESS : 0));
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            } else {
                n_obj = xmlAddChild(root, n_obj);
                if (n_obj == NULL) {
                    return (ERR_XML_ADDCHILD_FAILED);
                }
                (void) sprintf(numbuf, "%d", ret);
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)STATUSELEMENT,
                    (xmlChar *)numbuf);
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)MESSAGEELEMENT,
                    (xmlChar *)result_code_to_str(ret));
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        return (0);
}

/*
 * ****************************************************************************
 *
 * handle_partial_failure:
 *
 * doc  - response doc to fill up
 * ret  - return code from the caller.
 *
 * ****************************************************************************
 */
static int
handle_partial_failure(
        xmlDocPtr doc,
        int ret,
        boolean_t all_failed
)
{
        xmlNodePtr      n_obj, n_node, root;
        char numbuf[32];

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)RESULTELEMENT);
        if (n_obj) {
            if (root->children) {
                /* some or all associations failed to create */
                n_obj = xmlAddPrevSibling(root->children, n_obj);
                /* capture last error. should come up with all failed?? */
                (void) sprintf(numbuf, "%d",
                    all_failed ? ret : PARTIAL_FAILURE);
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)STATUSELEMENT,
                    (xmlChar *)numbuf);
                if (n_node == NULL) {
                        return (ERR_XML_NEWCHILD_FAILED);
                }
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)MESSAGEELEMENT,
                    (xmlChar *)result_code_to_str(all_failed ? ret :
                        PARTIAL_FAILURE));
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            } else {
                n_obj = xmlAddChild(root, n_obj);
                if (n_obj == NULL) {
                    return (ERR_XML_ADDCHILD_FAILED);
                }
                (void) sprintf(numbuf, "%d", (ret != 0) ? ret : 0);
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)STATUSELEMENT,
                    (xmlChar *)numbuf);
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                n_node = xmlNewChild(n_obj, NULL, (xmlChar *)MESSAGEELEMENT,
                    (xmlChar *)result_code_to_str((ret != 0) ? ret : 0));
                if (n_node == NULL) {
                    return (ERR_XML_NEWCHILD_FAILED);
                }
            }
        } else {
            return (ERR_XML_NEWNODE_FAILED);
        }

        return (0);
}

/*
 * ****************************************************************************
 *
 * get_serverconfig_op:
 *      The routine process server administrative setting.
 *
 * doc  - response doc to fill up.
 *
 * ****************************************************************************
 */
int
get_serverconfig_op(
        xmlDocPtr doc
)
{
        extern uint64_t esi_threshold;
        extern uint8_t mgmt_scn;
        extern ctrl_node_t *control_nodes;
        extern pthread_mutex_t ctrl_node_mtx;
        extern char data_store[MAXPATHLEN];

        xmlNodePtr      n_obj, root;
        char numbuf[32];
        ctrl_node_t *ctrl_node_p;
        int ret = 0;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        n_obj = xmlNewNode(NULL, (xmlChar *)ISNSSERVER);
        if (n_obj) {
            n_obj = xmlAddChild(root, n_obj);
            if (n_obj == NULL) {
                return (ERR_XML_ADDCHILD_FAILED);
            }
        } else {
            return (ERR_XML_ADDCHILD_FAILED);
        }

        if (xmlNewChild(n_obj, NULL, (xmlChar *)DATASTORELOCATION,
            (xmlChar *)data_store) == NULL) {
            return (ERR_XML_NEWCHILD_FAILED);
        }

        (void) sprintf(numbuf, "%llu", esi_threshold);
        if (xmlNewChild(n_obj, NULL, (xmlChar *)ESIRETRYTHRESHOLD,
            (xmlChar *)numbuf) == NULL) {
            return (ERR_XML_NEWCHILD_FAILED);
        }
        if (xmlNewChild(n_obj, NULL, (xmlChar *)MANAGEMENTSCNENABLED,
            (mgmt_scn) ? (uchar_t *)XMLTRUE : (uchar_t *)XMLFALSE) == NULL) {
            return (ERR_XML_NEWCHILD_FAILED);
        }

        (void) pthread_mutex_lock(&ctrl_node_mtx);
        if (control_nodes == NULL) {
            if (xmlNewChild(n_obj, NULL, (xmlChar *)CONTROLNODENAME,
                    (xmlChar *)NULL) == NULL) {
                    (void) pthread_mutex_unlock(&ctrl_node_mtx);
                    return (ERR_XML_NEWCHILD_FAILED);
            }
        } else {
            ctrl_node_p = control_nodes;
            while (ctrl_node_p != NULL) {
                if (xmlNewChild(n_obj, NULL, (xmlChar *)CONTROLNODENAME,
                    (xmlChar *)ctrl_node_p->name) == NULL) {
                    (void) pthread_mutex_unlock(&ctrl_node_mtx);
                    return (ERR_XML_NEWCHILD_FAILED);
                }
                ctrl_node_p = ctrl_node_p->next;
            }
        }
        (void) pthread_mutex_unlock(&ctrl_node_mtx);

        return (handle_partial_success(doc, ret));
}

/*
 * ****************************************************************************
 *
 * get_node_op:
 *      service get operation on a given node.
 *
 * req  - contains all info for a request.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
get_node_op(
        request_t *req,
        xmlDocPtr doc
        /* any additional arguments go here */
)
{
        int ret = 0, ret_save = 0;
        int i = 0;
        lookup_ctrl_t lc, lc2, lc3;
        uint32_t uid;
        char buff2[INET6_ADDRSTRLEN];

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = get_lc_type(req->op_info.obj);
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;
        lc.data[1].ptr = (uchar_t *)doc; /* xml writer descriptor */
        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                ret = cache_lookup(&lc, &uid, cb_get_node_info);
                if (uid == 0) {
                    ret = ERR_MATCHING_ISCSI_NODE_NOT_FOUND;
                }

                /* generate network entity object information */
                if (ret == 0 && lc.id[2] != 0) {
                        /*
                         * !!! there might be no entity and portal info for
                         * !!! the node if it is not a registered node
                         */
                        /* prepare lookup ctrl data for looking for entity */
                        SET_UID_LCP(&lc2, OBJ_ENTITY, lc.id[2]);

                        lc2.data[1].ptr = (uchar_t *)doc;
                        /* cb_get_node_info callback returned Node object. */
                        lc2.data[2].ptr = lc.data[2].ptr;
                        ret = cache_lookup(&lc2, &uid, cb_get_entity_info);
                        if (uid == 0) {
                            ret = ERR_MATCHING_NETWORK_ENTITY_NOT_FOUND;
                        }
                }

                /* generate portal information */
                if (ret == 0 && lc.id[2] != 0) {
                        /* prepare lookup ctrl data for looking for pg */
                        lc2.curr_uid = 0;
                        lc2.type = OBJ_PG;
                        lc2.id[0] = ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID);
                        lc2.op[0] = OP_STRING;
                        /* lc.data[0].ptr contains node name */
                        lc2.data[0].ptr = lc.data[0].ptr;
                        lc2.op[1] = 0;
                        lc2.data[1].ip = (in6_addr_t *)buff2;

                        /* prepare lookup ctrl data for looking for portal */
                        lc3.curr_uid = 0;
                        lc3.type = OBJ_PORTAL;
                        lc3.id[0] = ATTR_INDEX_PORTAL(
                                ISNS_PORTAL_IP_ADDR_ATTR_ID);
                        lc3.op[0] = OP_MEMORY_IP6;
                        lc3.id[1] = ATTR_INDEX_PORTAL(
                                ISNS_PORTAL_PORT_ATTR_ID);
                        lc3.op[1] = OP_INTEGER;
                        lc3.op[2] = 0;
                        /* cb_get_node_info callback returned Node object. */
                        lc3.data[2].ptr = lc.data[2].ptr;
                        for (;;) {
                                ret = cache_lookup(&lc2, &uid, cb_get_pg_info);
                                if (uid != 0) {
                                        /* we found a portal group */
                                        lc2.curr_uid = uid;
                                        /* it is a null pg if pgt is zero. */
                                        if (lc2.id[2] != 0) {
                                                /* pass ip addr */
                                                lc3.data[0].ip = lc2.data[1].ip;
                                                /* pass port num */
                                                lc3.data[1].ui = lc2.data[2].ui;
                                                /* pass pgt */
                                                lc3.id[2] = lc2.id[2];
                                                ret = cache_lookup(&lc3, &uid,
                                                    cb_get_portal_info);
                                        }
                                } else {
                                        /*
                                         * no more portal group which is
                                         * tied to this stroage node object.
                                         */
                                        break;
                                }
                        }
                }
                /* save error for this iteration */
                if (ret != 0) {
                    ret_save = ret;
                }
                ret = 0;
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * i_get_dd_dds_op:
 *      serves get operatrion on dd or dds.
 *
 * req  - contains all info for a request.
 * doc  - response doc to fill up
 * obj_type     - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
static int
i_get_dd_dds_op(
        request_t *req,
        xmlDocPtr doc,
        isns_type_t obj_type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        int i = 0;
        lookup_ctrl_t lc;
        uint32_t uid;

        if ((obj_type != OBJ_DD) && (obj_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = obj_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;
        lc.data[1].ptr = (uchar_t *)doc; /* xml writer descriptor */
        while (i < req->count) {
                if (obj_type == OBJ_DD) {
                    lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                    ret = cache_lookup(&lc, &uid, cb_get_dd_info);
                    if (uid == 0) {
                        /* set an error and continue. */
                        ret = ERR_MATCHING_DD_NOT_FOUND;
                    }
                } else {
                    lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                    ret = cache_lookup(&lc, &uid, cb_get_ddset_info);
                    if (uid == 0) {
                        /* set an error and continue. */
                        ret = ERR_MATCHING_DDSET_NOT_FOUND;
                    }
                }
                /* save error for this iteration */
                if (ret != 0) {
                    ret_save = ret;
                }
                ret = 0;
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * i_delete_ddmember_op:
 *      serves delete member operatrion on dd.
 *
 * container    - dd name
 * member       - node name
 *
 * ****************************************************************************
 */
static int
i_delete_ddmember_op(
        uchar_t *container,
        uchar_t *member
)
{
        int ret = 0;

        isns_assoc_iscsi_t aiscsi;
        isns_obj_t *assoc;
        isns_attr_t *attr;
        int len;

        lookup_ctrl_t lc;
        uint32_t dd_id;

        /* prepare lookup ctrl data for looking for the dd object */
        lc.curr_uid = 0;
        lc.type = OBJ_DD;
        lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        lc.op[0] = OP_STRING;
        lc.data[0].ptr = container;
        lc.op[1] = 0;

        if ((dd_id = is_obj_there(&lc)) != 0) {
            aiscsi.type = OBJ_ASSOC_ISCSI;
            aiscsi.puid = dd_id;

            len = strlen((char *)member) + 1;
            len += 4 - (len % 4);

            attr = &aiscsi.attrs[ATTR_INDEX_ASSOC_ISCSI(
                ISNS_DD_ISCSI_NAME_ATTR_ID)];
            attr->tag = ISNS_DD_ISCSI_NAME_ATTR_ID;
            attr->len = len;
            attr->value.ptr = (uchar_t *)member;
            attr = &aiscsi.attrs[ATTR_INDEX_ASSOC_ISCSI(
                ISNS_DD_ISCSI_INDEX_ATTR_ID)];
            attr->tag = 0; /* clear it */
            assoc = (isns_obj_t *)&aiscsi;
            ret = remove_dd_member(assoc);
        } else {
            ret = ERR_MATCHING_DD_NOT_FOUND;
        }

        return (ret);
}

/*
 * ****************************************************************************
 *
 * i_delete_ddsetmember_op:
 *      serves delete member operatrion on dd set.
 *
 * container    - dd set name
 * member       - dd name
 *
 * ****************************************************************************
 */
static int
i_delete_ddsetmember_op(
        uchar_t *container,
        uchar_t *member
)
{
        int ret = 0;

        lookup_ctrl_t lc, lc2;
        uint32_t container_id, member_id;

        /* prepare lookup ctrl data for looking for the dd-set object */
        lc.curr_uid = 0;
        lc.type = OBJ_DDS;
        lc.id[0] = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
        lc.op[0] = OP_STRING;
        lc.data[0].ptr = container;
        lc.op[1] = 0;

        /* prepare lookup ctrl data for looking for the dd object */
        lc2.curr_uid = 0;
        lc2.type = OBJ_DD;
        lc2.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        lc2.op[0] = OP_STRING;
        lc2.data[0].ptr = member;
        lc2.op[1] = 0;

        if ((container_id = is_obj_there(&lc)) != 0) {
            if ((member_id = is_obj_there(&lc2)) != 0) {
                ret = remove_dds_member(container_id, member_id);
            } else {
                ret = ERR_MATCHING_DD_NOT_FOUND;
            }
        } else {
            ret = ERR_MATCHING_DDSET_NOT_FOUND;
        }

        return (ret);
}

/*
 * ****************************************************************************
 *
 * get_dd_op:
 *      service get operation on given dd(s).
 *
 * req  - contains all info for a request.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
get_dd_op(
        request_t *req,
        xmlDocPtr doc
        /* any additional arguments go here */
)
{
        return (i_get_dd_dds_op(req, doc, OBJ_DD));
}

/*
 * ****************************************************************************
 *
 * get_ddset_op:
 *      service get operation on given dd set(s).
 *
 * req  - contains all info for a request.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
get_ddset_op(
        request_t *req,
        xmlDocPtr doc
        /* any additional arguments go here */
)
{
        return (i_get_dd_dds_op(req, doc, OBJ_DDS));
}

/*
 * ****************************************************************************
 *
 * enumerate_node_op:
 *      services enumerate node op.
 *
 * req  - contains enumerate request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
enumerate_node_op(
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        htab_t *htab = cache_get_htab(OBJ_ISCSI);
        uint32_t uid = 0;
        lookup_ctrl_t lc;
        int         ret = 0, ret_save = 0;

        SET_UID_LCP(&lc, OBJ_ISCSI, 0);

        lc.data[1].ptr = (uchar_t *)doc;
        lc.data[2].ui = 0;

        FOR_EACH_ITEM(htab, uid, {
                lc.data[0].ui = uid;
                ret = cache_lookup(&lc, NULL, cb_enumerate_node_info);
                if (ret != 0) {
                    ret_save = ret;
                }
        });

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * enumerate_dd_op:
 *      services enumerate discovery domain op.
 *
 * req  - contains enumerate request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
enumerate_dd_op(
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{

        htab_t *htab = cache_get_htab(OBJ_DD);
        uint32_t uid = 0;
        lookup_ctrl_t lc;
        int         ret = 0, ret_save = 0;

        SET_UID_LCP(&lc, OBJ_DD, 0);

        lc.data[1].ptr = (uchar_t *)doc;
        lc.data[2].ui = 0;

        FOR_EACH_ITEM(htab, uid, {
                lc.data[0].ui = uid;
                ret = cache_lookup(&lc, NULL, cb_enumerate_dd_info);
                if (ret != 0) {
                    ret_save = ret;
                }
        });

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * enumerate_ddset_op:
 *      services enumerate discovery domain set op.
 *
 * req  - contains enumerate request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
enumerate_ddset_op(
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        htab_t *htab = cache_get_htab(OBJ_DDS);
        uint32_t uid = 0;
        lookup_ctrl_t lc;
        int         ret = 0, ret_save = 0;

        SET_UID_LCP(&lc, OBJ_DDS, 0);

        lc.data[1].ptr = (uchar_t *)doc;
        lc.data[2].ui = 0;

        FOR_EACH_ITEM(htab, uid, {
                lc.data[0].ui = uid;
                ret = cache_lookup(&lc, NULL, cb_enumerate_ddset_info);
                if (ret != 0) {
                    ret_save = ret;
                }
        });

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * getassociated_dd_to_node_op:
 *      construct a list of node that is associated with a given Discovery
 *      Domain.
 *
 * req  - contains getAssociated request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
getAssociated_dd_to_node_op(
        request_t *req,
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        uint32_t uid = 0, n;
        lookup_ctrl_t lc, lc2;
        int     i = 0, ret = 0, ret_save = 0;
        bmp_t   *p;

        lc.curr_uid = 0;
        lc.type = OBJ_DD;
        lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        SET_UID_LCP(&lc2, OBJ_ISCSI, 0);

        lc2.data[1].ptr = (uchar_t *)doc;

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                if ((uid = is_obj_there(&lc)) != 0) {
                    ret = get_dd_matrix(uid, &p, &n);
                    FOR_EACH_MEMBER(p, n, uid, {
                        lc2.data[0].ui = uid;
                        lc2.data[2].ptr = (uchar_t *)req->req_data.data[i];
                        ret = cache_lookup(&lc2, NULL,
                            cb_getAssociated_node_info);
                    });
                    free(p);
                } else {
                    ret = ERR_MATCHING_DD_NOT_FOUND;
                }
                /* save error for this iteration */
                if (ret != 0) {
                    ret_save = ret;
                }
                ret = 0;
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * getassociated_node_to_dd_op:
 *      construct a list of Discovery Doamins that is associated with a given
 *      node.
 *
 * req  - contains getAssociated request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
getAssociated_node_to_dd_op(
        request_t *req,
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        uint32_t uid = 0, dd_id;
        lookup_ctrl_t lc, lc2;
        int     i = 0, ret = 0, ret_save = 0;

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

        SET_UID_LCP(&lc2, OBJ_DD, 0);

        lc2.data[1].ptr = (uchar_t *)doc;

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                if ((uid = is_obj_there(&lc)) != 0) {
                    if ((dd_id = get_dd_id(uid, 0)) == 0) {
                        ret = ERR_NO_ASSOCIATED_DD_FOUND;
                        i++;
                        continue;
                    } else {
                        do {
                            lc2.data[0].ui = dd_id;
                            lc2.data[2].ptr = (uchar_t *)req->req_data.data[i];
                            ret = cache_lookup(&lc2, NULL,
                                cb_getAssociated_node_to_dd_info);
                            dd_id = get_dd_id(uid, dd_id);
                        } while (dd_id != 0);
                    };
                } else {
                    ret = ERR_MATCHING_NODE_NOT_FOUND;
                }
                /* save error for this iteration */
                if (ret != 0) {
                    ret_save = ret;
                }
                ret = 0;
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * getassociated_ddset_to_dd_op:
 *      construct a list of Discovery Doamins that is associated with a given
 *      Discover Domain set.
 *
 * req  - contains getAssociated request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
getAssociated_ddset_to_dd_op(
        request_t *req,
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        uint32_t uid = 0, n;
        lookup_ctrl_t lc, lc2;
        int     i = 0, ret = 0, ret_save = 0;
        bmp_t   *p;

        lc.curr_uid = 0;
        lc.type = OBJ_DDS;
        lc.id[0] = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        SET_UID_LCP(&lc2, OBJ_DD, 0);

        lc2.data[1].ptr = (uchar_t *)doc;

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                if ((uid = is_obj_there(&lc)) != 0) {
                    ret = get_dds_matrix(uid, &p, &n);
                    FOR_EACH_MEMBER(p, n, uid, {
                        lc2.data[0].ui = uid;
                        lc2.data[2].ptr = (uchar_t *)req->req_data.data[i];
                        ret = cache_lookup(&lc2, NULL,
                            cb_getAssociated_dd_info);
                    });
                    free(p);
                } else {
                    ret = ERR_MATCHING_DDSET_NOT_FOUND;
                }
                /* save error for this iteration */
                if (ret != 0) {
                    ret_save = ret;
                }
                ret = 0;
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * getassociated_dd_to_ddset_op:
 *      construct a list of Discovery Doamin sets that is associated with a
 *      given Discovery Domain.
 *
 * req  - contains getAssociated request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
getAssociated_dd_to_ddset_op(
        request_t *req,
        xmlDocPtr   doc
        /* any additional arguments go here */
)
{
        uint32_t uid = 0, ddset_id;
        lookup_ctrl_t lc, lc2;
        int     i = 0, ret = 0, ret_save = 0;

        lc.curr_uid = 0;
        lc.type = OBJ_DD;
        lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        SET_UID_LCP(&lc2, OBJ_DDS, 0);

        lc2.data[1].ptr = (uchar_t *)doc;

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];
                if ((uid = is_obj_there(&lc)) != 0) {
                    lc2.data[2].ui = 0;
                    if ((ddset_id = get_dds_id(uid, 0)) == 0) {
                        ret = ERR_NO_ASSOCIATED_DDSET_FOUND;
                        i++;
                        continue;
                    } else {
                        do {
                            lc2.data[0].ui = ddset_id;
                            lc2.data[2].ptr = (uchar_t *)req->req_data.data[i];
                            ret = cache_lookup(&lc2, NULL,
                                cb_getAssociated_dd_to_ddset_info);
                            ddset_id = get_dds_id(uid, ddset_id);
                        } while (ddset_id != 0);
                    };
                } else {
                    ret = ERR_MATCHING_DD_NOT_FOUND;
                }
                if (ret != 0) {
                    ret_save = ret;
                }
                i++;
        }

        return (handle_partial_success(doc, ret_save));
}

/*
 * ****************************************************************************
 *
 * delete_dd_ddset_op:
 *      removes a list of dd or dd set.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 * obj_type     - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
int
delete_dd_ddset_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        int i = 0, err_count = 0;
        lookup_ctrl_t lc;
        uint32_t uid;
        xmlNodePtr      n_obj, n_node, root;
        xmlAttrPtr      n_attr;
        int different_err = 0;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = lc_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;
        lc.data[1].ptr = (uchar_t *)doc; /* xml writer descriptor */
        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.data[i];

                /* lock the cache for writing */
                (void) cache_lock_write();

                if ((uid = is_obj_there(&lc)) != 0) {
                    /* remove the dd/ddset */
                    ret = (lc_type == OBJ_DD) ?
                        remove_dd_object(uid) :
                        remove_dds_object(uid);
                    /* unlock the cache and sync the data */
                    ret = cache_unlock_sync(ret);
                } else {
                    /* unlock the cache and no need to sync data */
                    (void) cache_unlock_nosync();
                    /* set an error and continue. */
                    ret = (lc_type == OBJ_DD) ?  ERR_MATCHING_DD_NOT_FOUND :
                        ERR_MATCHING_DDSET_NOT_FOUND;
                }

                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
                    if (n_obj) {
                        if ((n_obj = xmlAddChild(root, n_obj)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }

                    n_node = (lc_type == OBJ_DD) ?
                        xmlNewNode(NULL, (xmlChar *)DDOBJECT) :
                        xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
                    if (n_node) {
                        if ((n_node = xmlAddChild(n_obj, n_node)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                        n_attr = xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                                (xmlChar *)req->req_data.data[i]);
                        if (n_attr == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }
                    ret_save = ret;
                }
                i ++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * delete_ddmember_ddsetmember_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 * type - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
int
delete_ddmember_ddsetmember_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        int i = 0, err_count = 0;
        lookup_ctrl_t lc, lc2;
        uint32_t container_id, member_id;
        xmlNodePtr      n_node, n_obj, root;
        xmlAttrPtr      n_attr;
        int different_err = 0;
        int is_a_member;

        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = lc_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        lc2.curr_uid = 0;
        if (lc_type == OBJ_DD) {
            lc2.type = OBJ_ISCSI;
            lc2.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
        } else {
            lc2.type = OBJ_DD;
            lc2.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        }
        lc2.op[0] = OP_STRING;
        lc2.op[1] = 0;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.pair[i]->container;

                /* get the dd_id/dds_id */
                (void) cache_lock_write();
                container_id = is_obj_there(&lc);

                if (container_id != 0) {
                    lc2.data[0].ptr = (uchar_t *)req->req_data.pair[i]->member;

                    member_id = is_obj_there(&lc2);
                    if (member_id != 0) {
                        is_a_member =
                            (container_id ==
                            ((lc_type == OBJ_DD) ?
                            get_dd_id(member_id, container_id - 1) :
                            get_dds_id(member_id, container_id - 1)));
                    }
                    if (member_id != 0 && is_a_member != 0) {
                        /* delete the dd member */
                        ret = (lc_type == OBJ_DD) ?
                            i_delete_ddmember_op(
                                (uchar_t *)req->req_data.pair[i]->container,
                                (uchar_t *)req->req_data.pair[i]->member) :
                            i_delete_ddsetmember_op(
                                (uchar_t *)req->req_data.pair[i]->container,
                                (uchar_t *)req->req_data.pair[i]->member);
                        /* unlock the cache and sync the data */
                        ret = cache_unlock_sync(ret);
                    } else {
                        /* unlock the cache and no need to sync */
                        (void) cache_unlock_nosync();
                        ret = ERR_NO_SUCH_ASSOCIATION;
                    }
                } else {
                    /* unlock the cache and no need to sync */
                    (void) cache_unlock_nosync();
                    ret = (lc_type == OBJ_DD) ?  ERR_MATCHING_DD_NOT_FOUND :
                        ERR_MATCHING_DDSET_NOT_FOUND;
                }

                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    ret_save = ret;
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
                    if (n_obj) {
                        n_obj = xmlAddChild(root, n_obj);
                        if (n_obj == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }
                    if (lc_type == OBJ_DD) {
                        n_node =
                            xmlNewNode(NULL, (xmlChar *)DDOBJECTMEMBER);
                        n_attr = xmlSetProp(n_node, (xmlChar *)NODENAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->member);
                        if (n_attr == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->container);
                        if (n_attr == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                    } else {
                        n_node =
                            xmlNewNode(NULL, (xmlChar *)DDSETOBJECTMEMBER);
                        n_attr = xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->member);
                        if (n_attr == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                        n_attr = xmlSetProp(n_node, (xmlChar *)DDSETNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->container);
                        if (n_attr == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                    }
                    if (xmlAddChild(n_obj, n_node) == NULL) {
                        return (ERR_XML_ADDCHILD_FAILED);
                    }
                }
                i++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * create_ddmember_ddsetmember_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 * type - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
int
create_ddmember_ddsetmember_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        int i = 0, err_count = 0;
        lookup_ctrl_t lc, lc2;
        uint32_t container_id, member_id;
        xmlNodePtr      n_node, n_obj, root;
        isns_assoc_iscsi_t aiscsi = { 0 };
        isns_assoc_dd_t add = { 0 };
        isns_obj_t *assoc;
        isns_attr_t *attr;
        uint32_t len;
        int different_err = 0;

        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = lc_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        lc2.curr_uid = 0;
        if (lc_type == OBJ_DD) {
            lc2.type = OBJ_ISCSI;
            lc2.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
        } else {
            lc2.type = OBJ_DD;
            lc2.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
        }
        lc2.op[0] = OP_STRING;
        lc2.op[1] = 0;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        while (i < req->count) {
                lc.data[0].ptr = (uchar_t *)req->req_data.pair[i]->container;

                /* get the dd_id/dds_id */
                (void) cache_lock_write();
                container_id = is_obj_there(&lc);

                if (container_id != 0) {
                    (void) memset(&aiscsi, 0, sizeof (aiscsi));
                    if (lc_type == OBJ_DD) {
                        aiscsi.puid = container_id;
                        aiscsi.type = OBJ_ASSOC_ISCSI;
                        attr = &aiscsi.attrs[ATTR_INDEX_ASSOC_ISCSI(
                            ISNS_DD_ISCSI_NAME_ATTR_ID)];
                        attr->tag = ISNS_DD_ISCSI_NAME_ATTR_ID;
                        len = xmlStrlen(
                            (xmlChar *)req->req_data.pair[i]->member) + 1;
                        len += 4 - (len % 4); /* on 4 bytes aligned */
                        attr->len = len;
                        attr->value.ptr =
                            (uchar_t *)req->req_data.pair[i]->member;
                        assoc = (isns_obj_t *)&aiscsi;

                        /* add the dd member */
                        ret = add_dd_member(assoc);

                        /* unlock the cache and sync the data */
                        ret = cache_unlock_sync(ret);
                    } else {
                        lc2.data[0].ptr =
                            (uchar_t *)req->req_data.pair[i]->member;

                        if ((member_id = is_obj_there(&lc2)) != 0) {
                            add.puid = container_id;
                            add.type = OBJ_ASSOC_DD;
                            attr = &add.attrs[ATTR_INDEX_ASSOC_DD(
                                ISNS_DD_ID_ATTR_ID)];
                            attr->tag = ISNS_DD_ID_ATTR_ID;
                            attr->len = 4;
                            attr->value.ui = member_id;
                            assoc = (isns_obj_t *)&add;

                            /* add the dd-set member */
                            ret = add_dds_member(assoc);

                            /* unlock the cache and sync the data */
                            ret = cache_unlock_sync(ret);
                        } else {
                            /* unlock the cache and no need to sync */
                            (void) cache_unlock_nosync();
                            ret = ERR_MATCHING_DD_NOT_FOUND;
                        }
                    }
                } else {
                    /* unlock the cache and no need to sync */
                    (void) cache_unlock_nosync();
                    ret = (lc_type == OBJ_DD) ?  ERR_MATCHING_DD_NOT_FOUND :
                        ERR_MATCHING_DDSET_NOT_FOUND;
                }
                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ASSOCIATION);
                    if (n_obj) {
                        n_obj = xmlAddChild(root, n_obj);
                        if (n_obj == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }
                    if (lc_type == OBJ_DD) {
                        n_node =
                            xmlNewNode(NULL, (xmlChar *)DDOBJECTMEMBER);
                        if (xmlSetProp(n_node, (xmlChar *)NODENAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->member) == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                        if (xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->container) ==
                            NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                    } else {
                        n_node =
                            xmlNewNode(NULL, (xmlChar *)DDSETOBJECTMEMBER);
                        if (xmlSetProp(n_node, (xmlChar *)DDNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->member) == NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                        if (xmlSetProp(n_node, (xmlChar *)DDSETNAMEATTR,
                            (xmlChar *)req->req_data.pair[i]->container) ==
                            NULL) {
                            return (ERR_XML_SETPROP_FAILED);
                        }
                    }
                    if (xmlAddChild(n_obj, n_node) == NULL) {
                        return (ERR_XML_ADDCHILD_FAILED);
                    }
                    ret_save = ret;
                }
                i++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * rename_dd_ddset_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 * type - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
static int
rename_dd_ddset_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        int i = 0, err_count = 0;
        lookup_ctrl_t lc;
        uint32_t container_id;
        xmlNodePtr      n_node, n_obj, root;
        uchar_t *name;
        uint32_t len;
        int different_err = 0;

        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        SET_UID_LCP(&lc, lc_type, 0);

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        while (i < req->count) {
                /* id is checked to be not NULL before calling this routine. */
                lc.data[0].ui = *(req->req_data.attrlist[i]->id);

                /* get the dd_id/dds_id */
                (void) cache_lock_write();

                if ((container_id = is_obj_there(&lc)) != 0) {
                    name = (uchar_t *)req->req_data.attrlist[i]->name;
                    /* the length of the name need to include the */
                    /* null terminator and be on 4 bytes aligned */
                    len = xmlStrlen(name) + 1;
                    len += 4 - (len % 4);

                    /* rename the dd/dds */
                    ret = (lc_type == OBJ_DD) ?
                        update_dd_name(container_id, len, name) :
                        update_dds_name(container_id, len, name);

                    /* release the lock and sync the data */
                    ret = cache_unlock_sync(ret);
                } else {
                    /* release the lock and no need to sync */
                    (void) cache_unlock_nosync();
                    ret = (lc_type == OBJ_DD) ?  ERR_MATCHING_DD_NOT_FOUND :
                        ERR_MATCHING_DDSET_NOT_FOUND;
                }
                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    ret_save = ret;
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
                    if (n_obj) {
                        if ((n_obj = xmlAddChild(root, n_obj)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }

                    n_node = (lc_type == OBJ_DD) ?
                        xmlNewNode(NULL, (xmlChar *)DDOBJECT) :
                        xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
                    if (n_node) {
                        if ((n_node = xmlAddChild(n_obj, n_node)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        } else {
                            if (xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                                (xmlChar *)req->req_data.attrlist[i]->name) ==
                                NULL) {
                                return (ERR_XML_SETPROP_FAILED);
                            }
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }

                }
                i++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * update_dd_ddset_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 * type - object type(either dd or dd set)
 *
 * ****************************************************************************
 */
static int
update_dd_ddset_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        int i = 0, err_count = 0;
        lookup_ctrl_t lc;
        uint32_t container_id;
        xmlNodePtr      n_node, n_obj, root;
        int different_err = 0;

        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = lc_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }

        while (i < req->count) {
                lc.data[0].ptr = req->req_data.attrlist[i]->name;

                /* lock the cache for writing */
                (void) cache_lock_write();

                if ((container_id = is_obj_there(&lc)) != 0) {
                    ret = (lc_type == OBJ_DD) ?
                        /* enabled is checked to be not NULL before calling. */
                        update_dd_features(container_id,
                        *(req->req_data.attrlist[i]->enabled) ? 1 : 0):
                        update_dds_status(container_id,
                        *(req->req_data.attrlist[i]->enabled) ? 1 : 0);
                    /* unlock the cache and sync the data */
                    ret = cache_unlock_sync(ret);
                } else {
                    (void) cache_unlock_nosync();
                    ret = (lc_type == OBJ_DD) ?  ERR_MATCHING_DD_NOT_FOUND :
                        ERR_MATCHING_DDSET_NOT_FOUND;
                }
                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    ret_save = ret;
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
                    if (n_obj) {
                        if ((n_obj = xmlAddChild(root, n_obj)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }

                    n_node = (lc_type == OBJ_DD) ?
                        xmlNewNode(NULL, (xmlChar *)DDOBJECT) :
                        xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
                    if (n_node) {
                        if ((n_node = xmlAddChild(n_obj, n_node)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        } else {
                            if (xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                                (xmlChar *)req->req_data.attrlist[i]->name) ==
                                NULL) {
                                return (ERR_XML_SETPROP_FAILED);
                            }
                        }
                    } else {
                            return (ERR_XML_NEWNODE_FAILED);
                    }
                }
                i++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * createModify_dd_ddset_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
static int
create_dd_ddset_op(
        request_t *req,
        xmlDocPtr doc,
        object_type type
        /* any additional arguments go here */
)
{
        isns_obj_t  *obj;
        result_code_t ret = 0, ret_save = 0;
        isns_type_t lc_type;
        lookup_ctrl_t lc;
        uint32_t uid;
        int i = 0, err_count = 0;
        xmlNodePtr      n_obj, n_node, root;
        int different_err = 0;

        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        root = xmlDocGetRootElement(doc);
        if (root == NULL) {
            return (ERR_SYNTAX_MISSING_ROOT);
        }
        lc_type = get_lc_type(type);
        if ((lc_type != OBJ_DD) && (lc_type != OBJ_DDS)) {
            return (ERR_INVALID_MGMT_REQUEST);
        }

        /* prepare lookup ctrl data for looking for the node object */
        lc.curr_uid = 0;
        lc.type = lc_type;
        lc.id[0] = get_lc_id(req->op_info.obj);
        lc.op[0] = OP_STRING;
        lc.op[1] = 0;
        lc.data[1].ptr = (uchar_t *)doc; /* xml writer descriptor */
        while (i < req->count) {
                lc.data[0].ptr = req->req_data.attrlist[i]->name,
                /* grab the write lock */
                (void) cache_lock_write();

                uid = is_obj_there(&lc);
                if (uid == 0) {
                    ret = (lc_type == OBJ_DD) ?
                        adm_create_dd(&obj, req->req_data.attrlist[i]->name,
                        0, 0) :
                        adm_create_dds(&obj, req->req_data.attrlist[i]->name,
                        0, 0);
                    if (ret == 0) {
                        ret = register_object(obj, NULL, NULL);
                        if (ret != 0) {
                            free_object(obj);
                        }
                        /* release the lock and sync the cache and data store */
                        ret = cache_unlock_sync(ret);
                    }
                } else {
                        /* release the lock and no need to sync the data */
                        (void) cache_unlock_nosync();
                        ret = ERR_NAME_IN_USE;
                }

                if (ret != 0) {
                /* keep track if there are different errors encountered. */
                    if (ret_save != 0 && ret != ret_save) {
                        different_err++;
                    }
                    ret_save = ret;
                    err_count++;
                    n_obj = xmlNewNode(NULL, (xmlChar *)ISNSOBJECT);
                    if (n_obj) {
                        if ((n_obj = xmlAddChild(root, n_obj)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        }
                    } else {
                        return (ERR_XML_ADDCHILD_FAILED);
                    }

                    n_node = (lc_type == OBJ_DD) ?
                        xmlNewNode(NULL, (xmlChar *)DDOBJECT) :
                        xmlNewNode(NULL, (xmlChar *)DDSETOBJECT);
                    if (n_node) {
                        if ((n_node = xmlAddChild(n_obj, n_node)) == NULL) {
                            return (ERR_XML_ADDCHILD_FAILED);
                        } else {
                            if (xmlSetProp(n_node, (xmlChar *)NAMEATTR,
                                (xmlChar *)req->req_data.attrlist[i]->name) ==
                                NULL) {
                                return (ERR_XML_SETPROP_FAILED);
                            }
                        }
                    } else {
                        return (ERR_XML_NEWNODE_FAILED);
                    }
                }
                i++;
        }

        return (handle_partial_failure(doc, ret_save,
            (req->count == err_count && !different_err) ? B_TRUE : B_FALSE));
}

/*
 * ****************************************************************************
 *
 * createModify_dd_ddset_op:
 *      removes a list of dd memeber or dd seti member.
 *
 * req  - contains delete request info.
 * doc  - response doc to fill up
 *
 * ****************************************************************************
 */
int
createModify_dd_ddset_op(
        request_t *req,
        xmlDocPtr doc
        /* any additional arguments go here */
)
{
        result_code_t ret = 0;

        if (req->req_data.attrlist[0]->id != NULL) {
            ret = rename_dd_ddset_op(req, doc, req->op_info.obj);
        } else if (req->req_data.attrlist[0]->enabled != NULL) {
            ret = update_dd_ddset_op(req, doc, req->op_info.obj);
        } else {
            ret = create_dd_ddset_op(req, doc, req->op_info.obj);
        }

        return (ret);
}