usr/src/cmd/isns/isnsadm/isnsadm.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * isnsadm.c : isnsadm CL
  28  *
  29  */
  30
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34 #include <stdlib.h>
  35 #include <devid.h>
  36 #include <fcntl.h>
  37 #include <door.h>
  38 #include <errno.h>
  39 #include <strings.h>
  40 #include <libscf.h>
  41 #include <libxml/xmlreader.h>
  42 #include <libxml/xmlwriter.h>
  43 #include <libxml/parser.h>
  44 #include <libxml/xpath.h>
  45 #include <libxml/tree.h>
  46 #include <wchar.h>
  47 #include <locale.h>
  48 #include "isns_mgmt.h"
  49 #include "isns_utils.h"
  50 #include "isns_protocol.h"
  51 #include "cmdparse.h"
  52 #include "isnsadm.h"
  53
  54 /* object functions per subcommand */
  55 static int list_node_func(int, char **, cmdOptions_t *, void *);
  56 static int list_dd_func(int, char **, cmdOptions_t *, void *);
  57 static int list_ddset_func(int, char **, cmdOptions_t *, void *);
  58 static int add_node_func(int, char **, cmdOptions_t *, void *);
  59 static int add_dd_func(int, char **, cmdOptions_t *, void *);
  60 static int delete_dd_func(int, char **, cmdOptions_t *, void *);
  61 static int delete_ddset_func(int, char **, cmdOptions_t *, void *);
  62 static int create_dd_func(int, char **, cmdOptions_t *, void *);
  63 static int create_ddset_func(int, char **, cmdOptions_t *, void *);
  64 static int remove_node_func(int, char **, cmdOptions_t *, void *);
  65 static int remove_dd_func(int, char **, cmdOptions_t *, void *);
  66 static int modify_dd_func(int, char **, cmdOptions_t *, void *);
  67 static int modify_ddset_func(int, char **, cmdOptions_t *, void *);
  68 static int enable_ddset_func(int, char **, cmdOptions_t *, void *);
  69 static int disable_ddset_func(int, char **, cmdOptions_t *, void *);
  70 static int show_config_func(int, char **, cmdOptions_t *, void *);
  71 static int i_enableddset(int, char **, boolean_t);
  72 static xmlTextReaderPtr lookup_next_matching_elem(xmlTextReaderPtr, int *,
  73         const char *, const char *);
  74 static int handle_association_info(xmlChar *, association_t);
  75 static int process_result_response(xmlChar *, int obj);
  76 static int process_get_assoc_response(xmlChar *, association_t);
  77 static int process_get_response(object_type, xmlChar *, uint32_t);
  78 static int cvt_enumerate_rsp_to_get_req(xmlChar *, xmlChar **, object_type,
  79         uint32_t);
  80 static int build_get_xml_doc(int, char **, object_type, xmlChar **);
  81 static int build_delete_xml_doc(int, char **, object_type, char *, xmlChar **);
  82 static int build_create_xml_doc(int, char **, object_type, char *, xmlChar **);
  83 static int build_modify_xml_doc(int, char **, object_type, boolean_t,
  84         xmlChar **);
  85 static int build_rename_xml_doc(char *, object_type, uint32_t, xmlChar **);
  86 static int build_assoc_xml_doc(xmlChar *, association_t, xmlChar **);
  87 static int build_assoc_xml_doc(xmlChar *, association_t, xmlChar **);
  88 static int build_enumerate_xml_doc(object_type, xmlChar **);
  89
  90 #define NEW_XMLARGV(old, n) (xmlChar **)realloc((xmlChar *)old, \
  91         (unsigned)(n+2) * sizeof (xmlChar *))
  92
  93 #define XML_SFREE(x)    (((x) != NULL) ? (xmlFree(x), (x) = NULL) : (void *)0)
  94
  95 #define VERSION_STRING_MAX_LEN  10
  96
  97 #define OPTIONSTRING_NAME       "name"
  98 #define OPTIONSTRING_DDNAME     "Discovery Domain name"
  99 #define OPTIONSTRING_DDSETNAME  "Discovery Domain Set name"
 100 #define OPTIONSTRING_TARGET     "target"
 101 #define OPTIONSTRING_INITIATOR  "initiator"
 102 #define OPTIONSTRING_VERBOSE    "verbose"
 103
 104 #define VERBOSE         0x00000001
 105 #define INITIATOR_ONLY  0x00000010
 106 #define TARGET_ONLY     0x00000100
 107
 108 #if LIBXML_VERSION >= 20904
 109 #define XMLSTRING_CAST (const char *)
 110 #else
 111 #define XMLSTRING_CAST (const xmlChar *)
 112 #endif
 113
 114 /* object table based on definitions in isns_mgmt.h. */
 115 static obj_table_entry_t obj_table[] = {
 116         {NODEOBJECT, Node},
 117         {DDOBJECT, DiscoveryDomain},
 118         {DDSETOBJECT, DiscoveryDomainSet},
 119         {DDOBJECTMEMBER, DiscoveryDomainMember},
 120         {DDSETOBJECTMEMBER, DiscoveryDomainSetMember},
 121         {ISNSSERVER, ServerConfig},
 122         {NULL, 0}
 123 };
 124
 125 /*
 126  *  MAJOR - This should only change when there is an incompatible change made
 127  *  to the interfaces or the output.
 128  *
 129  *  MINOR - This should change whenever there is a new command or new feature
 130  *  with no incompatible change.
 131  */
 132 #define VERSION_STRING_MAJOR        "1"
 133 #define VERSION_STRING_MINOR        "0"
 134 static char *ISNS_FMRI = "network/isns_server:default";
 135
 136 /*
 137  * Add new options here
 138  */
 139
 140 /* tables set up based on cmdparse instructions */
 141 optionTbl_t longOptions[] = {
 142         {"target", no_arg, 't', OPTIONSTRING_TARGET},
 143         {"initiator", no_arg, 'i', OPTIONSTRING_INITIATOR},
 144         {"verbose", no_arg, 'v', OPTIONSTRING_VERBOSE},
 145         {"name", required_arg, 'n', OPTIONSTRING_NAME},
 146         {"dd", required_arg, 'd', OPTIONSTRING_DDNAME},
 147         {"dd-set", required_arg, 's', OPTIONSTRING_DDSETNAME},
 148         {NULL, 0, 0, 0}
 149 };
 150
 151
 152 /*
 153  * Add new subcommands here
 154  */
 155 subCommandProps_t subcommands[] = {
 156         {"list-node", LISTNODE, list_node_func, "itv", B_FALSE, NULL,
 157                 OPERAND_OPTIONAL_MULTIPLE, "node-name"},
 158         {"list-dd", LISTDD, list_dd_func, "v", B_FALSE, NULL,
 159                 OPERAND_OPTIONAL_MULTIPLE, OPTIONSTRING_DDNAME},
 160         {"list-dd-set", LISTDDSET, list_ddset_func, "v", B_FALSE, NULL,
 161                 OPERAND_OPTIONAL_MULTIPLE, OPTIONSTRING_DDSETNAME},
 162         {"create-dd", CREATEDD, create_dd_func, NULL, B_FALSE, NULL,
 163                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDNAME},
 164         {"create-dd-set", CREATEDDSET, create_ddset_func, NULL, B_FALSE, NULL,
 165                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDSETNAME},
 166         {"delete-dd", DELETEDD, delete_dd_func, NULL, B_FALSE, NULL,
 167                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDNAME},
 168         {"delete-dd-set", DELETEDDSET, delete_ddset_func, NULL, B_FALSE, NULL,
 169                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDSETNAME},
 170         {"add-node", ADDNODE, add_node_func, "d", B_TRUE, NULL,
 171                 OPERAND_MANDATORY_MULTIPLE, "node-name"},
 172         {"add-dd", ADDDD, add_dd_func, "s", B_TRUE, NULL,
 173                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDNAME},
 174         {"remove-node", REMOVENODE, remove_node_func, "d", B_TRUE, NULL,
 175                 OPERAND_MANDATORY_MULTIPLE, "node-name"},
 176         {"remove-dd", REMOVEDD, remove_dd_func, "s", B_TRUE, NULL,
 177                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDNAME},
 178         {"modify-dd", MODIFYDD, modify_dd_func, "n", B_TRUE, NULL,
 179                 OPERAND_MANDATORY_SINGLE, OPTIONSTRING_NAME},
 180         {"modify-dd-set", MODIFYDDSET, modify_ddset_func, "n", B_TRUE, NULL,
 181                 OPERAND_MANDATORY_SINGLE, OPTIONSTRING_NAME},
 182         {"enable-dd-set", ENABLEDDSET, enable_ddset_func, NULL, B_FALSE, NULL,
 183                 OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDSETNAME},
 184         {"disable-dd-set", DISABLEDDSET, disable_ddset_func, NULL, B_FALSE,
 185                 NULL, OPERAND_MANDATORY_MULTIPLE, OPTIONSTRING_DDSETNAME},
 186         {"show-config", SHOWCONFIG, show_config_func, NULL, B_FALSE, NULL,
 187                 OPERAND_NONE, NULL},
 188         {NULL, 0, NULL, NULL, 0, NULL, 0, NULL}
 189 };
 190
 191 /*
 192  * ****************************************************************************
 193  *
 194  * check_door_error
 195  *
 196  * input:
 197  *  errno from the door call.
 198  *
 199  * Returns:
 200  *  either door error or smf service error.
 201  *
 202  * ****************************************************************************
 203  */
 204 static int
 205 check_door_error(int door_err, int err)
 206 {
 207         char    *state = NULL;
 208         int     ret;
 209
 210         if (((state = smf_get_state(ISNS_FMRI)) != NULL) &&
 211             (strcmp(state, SCF_STATE_STRING_ONLINE) != 0)) {
 212                 ret = ERROR_ISNS_SMF_SERVICE_NOT_ONLINE;
 213         } else {
 214             (void) fprintf(stderr, "%s\n",
 215                 (door_err == ERROR_DOOR_CALL_FAILED) ?
 216                 getTextMessage(ERROR_DOOR_CALL_FAILED) :
 217                 getTextMessage(ERROR_DOOR_OPEN_FAILED));
 218             (void) fprintf(stderr, "\terrno: %s\n", strerror(err));
 219             ret = door_err;
 220         }
 221
 222         if (state) free(state);
 223
 224         return (ret);
 225 }
 226
 227 /*
 228  * ****************************************************************************
 229  *
 230  * lookup an element based on the element name.
 231  *
 232  * reader       - current xmlReaderReadPtr
 233  * m_falg       - indicate lookup result
 234  * elem         - name of element to look up.
 235  * endelem      - name of end element to look up.
 236  *
 237  * ****************************************************************************
 238  */
 239 static  xmlTextReaderPtr
 240 lookup_next_matching_elem(xmlTextReaderPtr reader, int *m_flag,
 241         const char *elem, const char *endelem)
 242 {
 243
 244         if (reader == NULL) {
 245             *m_flag = NO_MATCH;
 246             return (NULL);
 247         }
 248
 249         do {
 250         /*
 251          * if (xmlTextReaderName(reader) != NULL) {
 252          *      printf("%s ", xmlTextReaderName(reader));
 253          * }
 254          * printf("%d %d %d\n",
 255          * xmlTextReaderDepth(reader),
 256          * xmlTextReaderNodeType(reader),
 257          * xmlTextReaderIsEmptyElement(reader));
 258          */
 259                 /*
 260                  * if match with elem, return the reader with READER_MATCH flag.
 261                  * if match with end elem, return the reader wtih
 262                  * END_READER_MATCH flag.
 263                  */
 264             if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
 265                 if (XMLNCMP(reader, elem) == 0) {
 266                     *m_flag = READER_MATCH;
 267                     return (reader);
 268                 }
 269             } else if (xmlTextReaderNodeType(reader) ==
 270                 XML_READER_TYPE_END_ELEMENT) {
 271                 if (XMLNCMP(reader, endelem) == 0) {
 272                     *m_flag = END_READER_MATCH;
 273                     return (reader);
 274                 }
 275             }
 276         } while (xmlTextReaderRead(reader) == 1);
 277
 278         *m_flag = NO_MATCH;
 279         return (NULL);
 280 }
 281
 282 /*
 283  * ****************************************************************************
 284  *
 285  * Routine for getAssociated operation
 286  *      Construct association request  based on the name and calls door
 287  *      interface.
 288  *
 289  * name         - name attributes of an object for getting an association
 290  * assoc        - association type
 291  *
 292  * ****************************************************************************
 293  */
 294 static int
 295 handle_association_info(xmlChar *name, association_t assoc)
 296 {
 297
 298         xmlChar *doc;
 299         door_arg_t darg;
 300         msg_code_t ret;
 301         int fd;
 302
 303         if ((ret = build_assoc_xml_doc(name, assoc, &doc)) != 0) {
 304             return (ret);
 305         }
 306
 307         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
 308             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
 309             return (ret);
 310         }
 311
 312         (void) bzero(&darg, sizeof (darg));
 313         bzero(&darg, sizeof (darg));
 314         darg.data_ptr = (char *)doc;
 315         darg.data_size = xmlStrlen(doc) + 1;
 316         darg.rbuf = NULL;
 317         darg.rsize = 0;
 318         if ((door_call(fd, &darg)) == -1) {
 319             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
 320             (void) close(fd);
 321             (void) xmlFree(doc);
 322             return (ret);
 323         }
 324
 325         if ((ret = process_get_assoc_response((xmlChar *)darg.rbuf,
 326             assoc)) != 0) {
 327         /*
 328          * door frame work allocated a buffer when the date lager
 329          * that rbuf. indicate if munmap is required on rbuf.
 330          */
 331             (void) munmap(darg.rbuf, darg.rsize);
 332             (void) close(fd);
 333             (void) xmlFree(doc);
 334             return (ret);
 335         }
 336
 337         (void) munmap(darg.rbuf, darg.rsize);
 338
 339         (void) close(fd);
 340         (void) xmlFree(doc);
 341
 342         return (0);
 343 }
 344
 345 /*
 346  * ****************************************************************************
 347  *
 348  * process_error_status
 349  *      The routine process non 0 status and print out error message.
 350  *
 351  * status       - status code
 352  * reader       - reader that points to the message element.
 353  *
 354  * ****************************************************************************
 355  */
 356 static void
 357 print_error_status(int status, int obj, xmlTextReaderPtr reader)
 358 {
 359         int m_flag = 0;
 360
 361         switch (status) {
 362         case ISNS_RSP_BUSY:
 363             (void) fprintf(stderr, "%s\n",
 364                 getTextMessage(ERROR_SERVER_BUSY));
 365             break;
 366         case ISNS_RSP_INTERNAL_ERROR:
 367             (void) fprintf(stderr, "%s\n",
 368                 getTextMessage(ERROR_SERVER_INTERNAL_ERROR));
 369             break;
 370         case ISNS_RSP_OPTION_NOT_UNDERSTOOD:
 371             if ((obj == DiscoveryDomain) ||
 372                 (obj == DiscoveryDomainMember)) {
 373                 (void) fprintf(stderr, "%s\n",
 374                 getTextMessage(ERROR_OPERATION_NOT_ALLOWED_FOR_DEFAULT_DD));
 375             } else {
 376                 (void) fprintf(stderr, "%s\n",
 377                 getTextMessage(ERROR_OPERATION_NOT_ALLOWED_FOR_DEFAULT_DDSET));
 378             }
 379             break;
 380         case PARTIAL_FAILURE:
 381             (void) fprintf(stderr, "%s\n",
 382                 getTextMessage(ERROR_PARTIAL_FAILURE));
 383             break;
 384         case ERR_NO_SUCH_ASSOCIATION:
 385             if ((obj == DiscoveryDomain) ||
 386                 (obj == DiscoveryDomainMember)) {
 387                 (void) fprintf(stderr, "%s\n",
 388                 getTextMessage(ERROR_DDMEMBER_NOT_FOUND));
 389             } else {
 390                 (void) fprintf(stderr, "%s\n",
 391                 getTextMessage(ERROR_DDSETMEMBER_NOT_FOUND));
 392             }
 393             break;
 394         case ERR_ALREADY_ASSOCIATED:
 395             if ((obj == DiscoveryDomain) ||
 396                 (obj == DiscoveryDomainMember)) {
 397                 (void) fprintf(stderr, "%s\n",
 398                 getTextMessage(ERROR_DDMEMBER_ALREADY_EXIST));
 399             } else {
 400                 (void) fprintf(stderr, "%s\n",
 401                 getTextMessage(ERROR_DDSETMEMBER_ALREADY_EXIST));
 402             }
 403             break;
 404         case ERR_NAME_IN_USE:
 405             if ((obj == DiscoveryDomain) ||
 406                 (obj == DiscoveryDomainMember)) {
 407                 (void) fprintf(stderr, "%s\n",
 408                 getTextMessage(ERROR_DD_NAME_IN_USE));
 409             } else {
 410                 (void) fprintf(stderr, "%s\n",
 411                 getTextMessage(ERROR_DDSET_NAME_IN_USE));
 412             }
 413             break;
 414         default:
 415             reader = lookup_next_matching_elem(reader, &m_flag,
 416                 MESSAGEELEMENT, RESULTELEMENT);
 417             if (m_flag == READER_MATCH) {
 418                 (void) xmlTextReaderRead(reader);
 419                 (void) fprintf(stderr, "Error: %s\n",
 420                         (const char *) xmlTextReaderConstValue(reader));
 421             } else {
 422                 (void) fprintf(stderr, "Error: %s\n",
 423                 getTextMessage(ERROR_XML_MESSAGE_ELEM_NOT_FOUND));
 424             }
 425         }
 426 }
 427
 428 /*
 429  * ****************************************************************************
 430  *
 431  * print_partial_failure_info
 432  *      The routine prints partial failure info.
 433  *
 434  * status       - status code
 435  * reader       - reader that points to the message element.
 436  *
 437  * ****************************************************************************
 438  */
 439 static void
 440 print_partial_failure_info(xmlChar *doc)
 441 {
 442         xmlChar expr[ISNS_MAX_LABEL_LEN + 13];
 443         xmlDocPtr x_doc;
 444         xmlXPathContextPtr ctext = NULL;
 445         xmlXPathObjectPtr xpath_obj = NULL;
 446         xmlNodeSetPtr r_nodes = NULL;
 447         xmlAttrPtr attr = NULL;
 448         int i, cnt, obj = 0;
 449
 450         if ((x_doc = xmlParseMemory((const char *)doc, xmlStrlen(doc))) ==
 451             NULL) {
 452             (void) fprintf(stderr, "%s\n",
 453                 getTextMessage(ERROR_NO_ADDITIONAL_PARTIAL_FAILIRE_INFO));
 454         }
 455
 456         ctext = xmlXPathNewContext(x_doc);
 457         if (ctext == NULL) {
 458             (void) fprintf(stderr, "%s\n",
 459                 getTextMessage(ERROR_NO_ADDITIONAL_PARTIAL_FAILIRE_INFO));
 460         }
 461
 462         for (i = 0; obj_table[i].obj_str != NULL; i++) {
 463             (void) xmlStrPrintf(expr, ISNS_MAX_LABEL_LEN + 13,
 464                 XMLSTRING_CAST "%s\"%s\"]", "//*[name()=",
 465                 obj_table[i].obj_str);
 466             xpath_obj = xmlXPathEvalExpression(expr, ctext);
 467             if ((xpath_obj) && (xpath_obj->nodesetval) &&
 468                 (xpath_obj->nodesetval->nodeNr > 0) &&
 469                 (xpath_obj->nodesetval->nodeTab)) {
 470                 obj = obj_table[i].obj_id;
 471                 break;
 472             }
 473         }
 474
 475         if (obj == 0) {
 476             if (xpath_obj) xmlXPathFreeObject(xpath_obj);
 477             (void) fprintf(stderr, "%s\n",
 478                 getTextMessage(ERROR_NO_ADDITIONAL_PARTIAL_FAILIRE_INFO));
 479         }
 480
 481         switch (obj) {
 482             case DiscoveryDomainMember:
 483                 r_nodes = xpath_obj->nodesetval;
 484                 cnt = r_nodes->nodeNr;
 485                 for (i = 0; i < cnt; i++) {
 486                     attr = r_nodes->nodeTab[i]->properties;
 487                     for (; attr != NULL; attr = attr->next) {
 488                         if (xmlStrncmp(attr->name, (xmlChar *)DDNAMEATTR,
 489                             xmlStrlen((xmlChar *)DDNAMEATTR)) == 0) {
 490                                 (void) fprintf(stderr, "DD Name: %s\t",
 491                                 xmlNodeGetContent(attr->children));
 492                         }
 493                         if (xmlStrncmp(attr->name, (xmlChar *)NODENAMEATTR,
 494                             xmlStrlen((xmlChar *)NODENAMEATTR)) == 0) {
 495                                 (void) fprintf(stderr, "Node Name: %s\t",
 496                                 xmlNodeGetContent(attr->children));
 497                         }
 498                     }
 499                     (void) fprintf(stderr, "\n");
 500                 }
 501                 if (xpath_obj) xmlXPathFreeObject(xpath_obj);
 502                 break;
 503             case DiscoveryDomainSetMember:
 504                 r_nodes = xpath_obj->nodesetval;
 505                 cnt = r_nodes->nodeNr;
 506                 for (i = 0; i < cnt; i++) {
 507                     attr = r_nodes->nodeTab[i]->properties;
 508                     for (; attr != NULL; attr = attr->next) {
 509                         if (xmlStrncmp(attr->name, (xmlChar *)DDSETNAMEATTR,
 510                             xmlStrlen((xmlChar *)DDNAMEATTR)) == 0) {
 511                                 (void) fprintf(stderr, "DD Set Name: %s\t",
 512                                 xmlNodeGetContent(attr->children));
 513                         }
 514                         if (xmlStrncmp(attr->name, (xmlChar *)DDNAMEATTR,
 515                             xmlStrlen((xmlChar *)NODENAMEATTR)) == 0) {
 516                                 (void) fprintf(stderr, "DD Name: %s\t",
 517                                 xmlNodeGetContent(attr->children));
 518                         }
 519                     }
 520                     (void) fprintf(stderr, "\n");
 521                 }
 522                 if (xpath_obj) xmlXPathFreeObject(xpath_obj);
 523                 break;
 524             case Node:
 525             case DiscoveryDomain:
 526             case DiscoveryDomainSet:
 527                 r_nodes = xpath_obj->nodesetval;
 528                 cnt = r_nodes->nodeNr;
 529                 for (i = 0; i < cnt; i++) {
 530                     attr = r_nodes->nodeTab[i]->properties;
 531                     for (; attr != NULL; attr = attr->next) {
 532                         if ((xmlStrncmp(attr->name, (xmlChar *)NAMEATTR,
 533                             xmlStrlen((xmlChar *)NAMEATTR))) == 0) {
 534                                 (void) fprintf(stderr, "Object Name: %s\n",
 535                                 xmlNodeGetContent(attr->children));
 536                         }
 537                     }
 538                 }
 539                 if (xpath_obj) xmlXPathFreeObject(xpath_obj);
 540                 break;
 541         }
 542 }
 543
 544 /*
 545  * ****************************************************************************
 546  *
 547  * process_result_response
 548  *      The routine process association data based on the association type.
 549  *
 550  * doc          - result
 551  * obj          - associated object type
 552  *
 553  * ****************************************************************************
 554  */
 555 static int
 556 process_result_response(xmlChar *doc, int obj)
 557 {
 558         xmlTextReaderPtr reader;
 559         int m_flag = 0, status;
 560
 561         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory((const char *)doc,
 562             xmlStrlen(doc), NULL, NULL, 0)) == NULL) {
 563                 return (ERROR_XML_READER_NULL);
 564         }
 565
 566         /* if status is 0, continue on.  Otherwise return an error. */
 567         if (reader = lookup_next_matching_elem(reader, &m_flag, STATUSELEMENT,
 568             RESULTELEMENT)) {
 569             if (m_flag == READER_MATCH) {
 570                 if (xmlTextReaderRead(reader) == 1) {
 571                     status =
 572                     atoi((const char *)xmlTextReaderConstValue(reader));
 573                     if (status != 0) {
 574                         print_error_status(status, obj, reader);
 575                         (void) xmlTextReaderClose(reader);
 576                         (void) xmlFreeTextReader(reader);
 577                         if (status == PARTIAL_FAILURE) {
 578                             print_partial_failure_info(doc);
 579                         }
 580                         return (status);
 581                     }
 582                 } else {
 583                     (void) xmlTextReaderClose(reader);
 584                     (void) xmlFreeTextReader(reader);
 585                     return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 586                 }
 587             } else {
 588                 (void) xmlTextReaderClose(reader);
 589                 (void) xmlFreeTextReader(reader);
 590                 return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 591             }
 592         } else {
 593             (void) fprintf(stderr, "%s\n",
 594                 getTextMessage(ERROR_XML_READER_NULL));
 595             return (ERROR_XML_READER_NULL);
 596         }
 597
 598         (void) xmlTextReaderClose(reader);
 599         (void) xmlFreeTextReader(reader);
 600         return (0);
 601 }
 602
 603 /*
 604  * ****************************************************************************
 605  *
 606  * process_get_assoc_response
 607  *      The routine process association data based on the association type.
 608  *
 609  * doc          - association data
 610  * assoc        - associatiion type
 611  *
 612  * ****************************************************************************
 613  */
 614 static int
 615 process_get_assoc_response(xmlChar *doc, association_t assoc)
 616 {
 617         xmlTextReaderPtr reader;
 618         xmlChar *ddsname, *ddname, *nodename;
 619         wchar_t wc_name[ISNS_MAX_NAME_LEN];
 620         int m_flag = 0, h_printed = 0, status;
 621
 622         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory((const char *)doc,
 623                         xmlStrlen(doc), NULL, NULL, 0)) == NULL) {
 624             return (ERROR_XML_READER_NULL);
 625         }
 626
 627         /* if status is 0, continue on.  Otherwise return an error. */
 628         if (reader = lookup_next_matching_elem(reader, &m_flag, STATUSELEMENT,
 629             RESULTELEMENT)) {
 630             if (m_flag == READER_MATCH) {
 631                 if (xmlTextReaderRead(reader) == 1) {
 632                     status =
 633                     atoi((const char *)xmlTextReaderConstValue(reader));
 634                     if ((status != 0) && (status != PARTIAL_SUCCESS)) {
 635                         /* not an error */
 636                         if ((status !=  ERR_NO_SUCH_ASSOCIATION) &&
 637                             (status !=  ERR_NO_ASSOCIATED_DD_FOUND) &&
 638                             (status !=  ERR_NO_ASSOCIATED_DDSET_FOUND)) {
 639                             (void) xmlTextReaderClose(reader);
 640                             (void) xmlFreeTextReader(reader);
 641                             return (0);
 642                         } else {
 643                             print_error_status(status,
 644                                 ((assoc == node_to_dd) || (dd_to_node)) ?
 645                                 DiscoveryDomain : DiscoveryDomainSet, reader);
 646                             (void) xmlTextReaderClose(reader);
 647                             (void) xmlFreeTextReader(reader);
 648                             return (status);
 649                         }
 650                     }
 651                 } else {
 652                     (void) xmlTextReaderClose(reader);
 653                     (void) xmlFreeTextReader(reader);
 654                     return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 655                 }
 656             } else {
 657                 return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 658             }
 659         } else {
 660             return (ERROR_XML_READER_NULL);
 661         }
 662
 663         m_flag = 0;
 664
 665         switch (assoc) {
 666             case node_to_dd:
 667                 /* process DD elements */
 668                 while (reader = lookup_next_matching_elem(reader, &m_flag,
 669                     DDOBJECTMEMBER, ISNSRESPONSE)) {
 670                     if (m_flag == END_READER_MATCH) {
 671                         (void) xmlTextReaderNext(reader);
 672                         break;
 673                     } else if (m_flag == READER_MATCH) {
 674                         if ((ddname = (xmlTextReaderGetAttribute(reader,
 675                             (const xmlChar *)DDNAMEATTR))) != NULL) {
 676                             if (mbstowcs(wc_name, (const char *)ddname,
 677                                 ISNS_MAX_NAME_LEN) == (size_t)-1) {
 678                                 (void) wcscpy(wc_name, L"-");
 679                             }
 680                             if (h_printed) {
 681                                 (void) printf("\tDD Name: %ws\n", wc_name);
 682                             } else {
 683                                 (void) printf("\tDD Name: %ws\n", wc_name);
 684                                 h_printed = 1;
 685                             }
 686                             xmlFree(ddname);
 687                         } else {
 688                             if (h_printed) {
 689                                 (void) printf("\t         %s\n", "-");
 690                             } else {
 691                                 (void) printf("\tDD Name: %s\n", "-");
 692                                 h_printed = 1;
 693                             }
 694                         }
 695                     }
 696                     m_flag = 0;
 697                     (void) xmlTextReaderRead(reader);
 698                 }
 699             break;
 700         case dd_to_node:
 701                 /* process the DiscoveryDoamin elements */
 702             while (reader = lookup_next_matching_elem(reader, &m_flag,
 703                     DDOBJECTMEMBER, ISNSRESPONSE)) {
 704                 if (m_flag == END_READER_MATCH) {
 705                     (void) xmlTextReaderNext(reader);
 706                     break;
 707                 } else if (m_flag == READER_MATCH) {
 708                     if ((nodename = (xmlTextReaderGetAttribute(reader,
 709                             (const xmlChar *)NODENAMEATTR))) != NULL) {
 710                         if (mbstowcs(wc_name, (const char *)nodename,
 711                             ISNS_MAX_NAME_LEN) == (size_t)-1) {
 712                             (void) wcscpy(wc_name, L"-");
 713                         }
 714                         (void) printf("\tiSCSI name: %ws\n", wc_name);
 715                         xmlFree(nodename);
 716                     } else {
 717                         (void) printf("\tiSCSI name: %s\n", "-");
 718                     }
 719                 }
 720                 m_flag = 0;
 721                 (void) xmlTextReaderRead(reader);
 722             }
 723             break;
 724         case dd_to_ddset:
 725                 /* process the DiscoveryDoaminSet elements */
 726             while (reader = lookup_next_matching_elem(reader, &m_flag,
 727                     DDSETOBJECTMEMBER, ISNSRESPONSE)) {
 728                 if (m_flag == END_READER_MATCH) {
 729                     (void) xmlTextReaderNext(reader);
 730                     break;
 731                 } else if (m_flag == READER_MATCH) {
 732                     if ((ddsname = (xmlTextReaderGetAttribute(reader,
 733                         (const xmlChar *)DDSETNAMEATTR))) != NULL) {
 734                         if (mbstowcs(wc_name, (const char *)ddsname,
 735                             ISNS_MAX_NAME_LEN) == (size_t)-1) {
 736                             (void) wcscpy(wc_name, L"-");
 737                         }
 738                         if (h_printed) {
 739                             (void) printf("\t           %ws\n", wc_name);
 740                         } else {
 741                             (void) printf("\tDD set(s): %ws\n", wc_name);
 742                             h_printed = 1;
 743                         }
 744                         xmlFree(ddsname);
 745                     } else {
 746                         (void) printf("\tDD set(s): %s\n", "-");
 747                     }
 748                 }
 749                 m_flag = 0;
 750                 (void) xmlTextReaderRead(reader);
 751             }
 752             break;
 753         case ddset_to_dd:
 754                 /* process the DiscoveryDoaminSet elements */
 755             while (reader = lookup_next_matching_elem(reader, &m_flag,
 756                     DDSETOBJECTMEMBER, ISNSRESPONSE)) {
 757                 if (m_flag == END_READER_MATCH) {
 758                     (void) xmlTextReaderNext(reader);
 759                     break;
 760                 } else if (m_flag == READER_MATCH) {
 761                         if ((ddname = (xmlTextReaderGetAttribute(reader,
 762                             (const xmlChar *)DDNAMEATTR))) != NULL) {
 763                             if (mbstowcs(wc_name, (const char *)ddname,
 764                                 ISNS_MAX_NAME_LEN) == (size_t)-1) {
 765                                 (void) wcscpy(wc_name, L"-");
 766                             }
 767                             (void) printf("\tDD Name: %ws\n", wc_name);
 768                             xmlFree(ddname);
 769                         } else {
 770                             (void) printf("\tDD Name: %s\n", "-");
 771                         }
 772                 }
 773                 m_flag = 0;
 774                 (void) xmlTextReaderRead(reader);
 775             }
 776             break;
 777         default:
 778             (void) xmlTextReaderClose(reader);
 779             (void) xmlFreeTextReader(reader);
 780             return (UNKNOWN);
 781         }
 782
 783         if (status == PARTIAL_SUCCESS) {
 784             (void) fprintf(stderr, "%s\n",
 785                 getTextMessage(ERROR_PARTIAL_SUCCESS));
 786         }
 787         (void) xmlTextReaderClose(reader);
 788         (void) xmlFreeTextReader(reader);
 789         return (status);
 790 }
 791
 792 /*
 793  * ****************************************************************************
 794  *
 795  * process_get_response :
 796  *      display data from the get response doc based on flag.
 797  *
 798  * obj          - object type
 799  * doc          - docuemet to process
 800  * flag         - options from the subcommand
 801  *
 802  * ****************************************************************************
 803  */
 804 static int
 805 process_get_response(object_type obj, xmlChar *doc, uint32_t flag)
 806 {
 807         xmlTextReaderPtr reader;
 808         int m_flag = 0, ret = 0, status;
 809         xmlChar *name = NULL;
 810         wchar_t wc_name[ISNS_MAX_NAME_LEN];
 811         int tag_printed = 0;
 812
 813         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory((const char *)doc,
 814             xmlStrlen(doc), NULL, NULL, 0)) == NULL) {
 815                 return (ERROR_XML_READER_NULL);
 816         }
 817
 818         /* if status is 0, continue on.  Otherwise return an error. */
 819         if (reader = lookup_next_matching_elem(reader, &m_flag, STATUSELEMENT,
 820             RESULTELEMENT)) {
 821             if (m_flag == READER_MATCH) {
 822                 if (xmlTextReaderRead(reader) == 1) {
 823                     status =
 824                     atoi((const char *)xmlTextReaderConstValue(reader));
 825                     if ((status != 0) && (status != PARTIAL_SUCCESS)) {
 826                         print_error_status(status, obj, reader);
 827                         (void) xmlTextReaderClose(reader);
 828                         (void) xmlFreeTextReader(reader);
 829                         return (status);
 830                     }
 831                 } else {
 832                     (void) xmlTextReaderClose(reader);
 833                     (void) xmlFreeTextReader(reader);
 834                     return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 835                 }
 836             } else {
 837                 (void) xmlTextReaderClose(reader);
 838                 (void) xmlFreeTextReader(reader);
 839                 return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
 840             }
 841         } else {
 842             return (ERROR_XML_READER_NULL);
 843         }
 844
 845         m_flag = 0;
 846
 847         switch (obj) {
 848             case Node:
 849                 /* process the node elements */
 850                 while (reader = lookup_next_matching_elem(reader, &m_flag,
 851                     NODEOBJECT, ISNSRESPONSE)) {
 852                     if (m_flag == END_READER_MATCH) {
 853                         break;
 854                     }
 855
 856                     /* check the type */
 857                     if ((xmlTextReaderMoveToAttribute(reader,
 858                         (const xmlChar *)TYPEATTR)) == 1) {
 859                         if (((flag & TARGET_ONLY) == TARGET_ONLY) &&
 860                             (XMLNCMPVAL(reader, TARGETTYPE) != 0)) {
 861                             /* move to next node object. */
 862                             (void) xmlTextReaderMoveToElement(reader);
 863                             (void) xmlTextReaderNext(reader);
 864                             continue;
 865                         }
 866                         if (((flag & INITIATOR_ONLY) == INITIATOR_ONLY) &&
 867                             (XMLNCMPVAL(reader, INITIATORTYPE) != 0)) {
 868                             /* move to next node object. */
 869                             (void) xmlTextReaderMoveToElement(reader);
 870                             (void) xmlTextReaderNext(reader);
 871                             continue;
 872                         }
 873                     } else {
 874                         ret = ERROR_XML_TYPE_ATTR_NOT_FOUND;
 875                         goto out;
 876                     }
 877
 878                     if (((xmlTextReaderMoveToAttribute(reader,
 879                         (const xmlChar *)NAMEATTR)) == 1) &&
 880                         (const char *)xmlTextReaderConstValue(reader)) {
 881                         if (mbstowcs(wc_name,
 882                             (const char *)xmlTextReaderConstValue(reader),
 883                             ISNS_MAX_NAME_LEN) == (size_t)-1) {
 884                             (void) wcscpy(wc_name, L"-");
 885                         }
 886                         if ((flag & VERBOSE) == VERBOSE) {
 887                             name = xmlTextReaderValue(reader);
 888                             (void) printf("iSCSI Name: %ws\n", wc_name);
 889                         } else {
 890                             (void) printf("iSCSI Name: %ws\n", wc_name);
 891                         }
 892                     } else {
 893                         XML_SFREE(name);
 894                         ret = ERROR_XML_TYPE_ATTR_NOT_FOUND;
 895                         goto out;
 896                     }
 897                     if ((xmlTextReaderMoveToAttribute(reader,
 898                         (const xmlChar *)ALIASATTR)) == 1) {
 899                         if (xmlStrcmp(xmlTextReaderConstValue(reader),
 900                             (xmlChar *)"") == 0) {
 901                             (void) printf("\tAlias: %s\n", "-");
 902                         } else {
 903                             if (mbstowcs(wc_name,
 904                                 (const char *)xmlTextReaderConstValue(reader),
 905                                 ISNS_MAX_NAME_LEN) == (size_t)-1) {
 906                                 (void) wcscpy(wc_name, L"-");
 907                             }
 908                             (void) printf("\tAlias: %ws\n", wc_name);
 909                         }
 910                     }
 911
 912                     /* type attribute exist based on the previous checking. */
 913                     (void) xmlTextReaderMoveToAttribute(reader,
 914                         (const xmlChar *)TYPEATTR);
 915                     (void) printf("\tType: %s\n",
 916                         (const char *)xmlTextReaderConstValue(reader) ?
 917                         (const char *)xmlTextReaderConstValue(reader) : "-");
 918
 919                     if ((flag & VERBOSE) == VERBOSE) {
 920                         /* print more details */
 921                         m_flag = 0;
 922                         /*
 923                          * No details for deregistered node.
 924                          * skip to next isns object.
 925                          */
 926                         if ((reader = lookup_next_matching_elem(reader,
 927                             &m_flag, ENTITYID, ISNSOBJECT))) {
 928                             if (m_flag == READER_MATCH) {
 929                                 /* move to entity id value. */
 930                                 if ((xmlTextReaderRead(reader) == 1) &&
 931                                     xmlTextReaderConstValue(reader)) {
 932                                     if (mbstowcs(wc_name,
 933                                         (const char *)
 934                                         xmlTextReaderConstValue(reader),
 935                                         ISNS_MAX_NAME_LEN) == (size_t)-1) {
 936                                         (void) wcscpy(wc_name,
 937                                             L"-");
 938                                     }
 939                                     (void) printf("\tNetwork Entity: %ws\n",
 940                                         wc_name);
 941                                 } else {
 942                                     (void) printf("\tNework Entity: -\n");
 943                                 }
 944                             } else if (m_flag == END_READER_MATCH) {
 945                                 (void) xmlTextReaderRead(reader);
 946                                 XML_SFREE(name);
 947                                 continue;
 948                             }
 949                         }
 950
 951                         /* print  portal info */
 952                         m_flag = 0;
 953                         while ((reader = lookup_next_matching_elem(reader,
 954                             &m_flag, IPADDR, NODEOBJECT))) {
 955                             if (m_flag == END_READER_MATCH) {
 956                                 (void) xmlTextReaderRead(reader);
 957                                 break;
 958                             }
 959                             /* move to the value of IP addr. */
 960                             if ((xmlTextReaderRead(reader) == 1) &&
 961                                 xmlTextReaderConstValue(reader)) {
 962                                 (void) printf("\tPortal: %s",
 963                                 xmlTextReaderConstValue(reader));
 964                                 /* get port number */
 965                                 m_flag = 0;
 966                                 if (reader = lookup_next_matching_elem(reader,
 967                                     &m_flag, PORTNUMBER, UDPTCPPORT)) {
 968                                     if ((xmlTextReaderRead(reader) == 1) &&
 969                                         xmlTextReaderConstValue(reader)) {
 970                                     (void) printf(":%d\n",
 971                                         atoi((const char *)
 972                                         xmlTextReaderConstValue(reader)));
 973                                     } else {
 974                                         (void) printf(":-\n");
 975                                     }
 976                                 }
 977                                 m_flag = 0;
 978                                 if (reader = lookup_next_matching_elem(reader,
 979                                     &m_flag, GROUPTAG, GROUPTAG)) {
 980                                     if ((xmlTextReaderRead(reader) == 1) &&
 981                                         xmlTextReaderConstValue(reader)) {
 982                                     (void) printf("\t\tPortal Group: %s\n",
 983                                         xmlTextReaderConstValue(reader));
 984                                     } else {
 985                                         (void) printf(":-\n");
 986                                     }
 987                                 }
 988                             }
 989                         } /* Portal end */
 990                         if ((ret = handle_association_info(name,
 991                             node_to_dd)) != 0) {
 992                             XML_SFREE(name);
 993                             goto out;
 994                         }
 995                     } /* verbose end */
 996                     XML_SFREE(name);
 997                     (void) xmlTextReaderRead(reader);
 998                     m_flag = 0;
 999                 } /* end for node while */
1000                 break;
1001             case DiscoveryDomain:
1002                 /* process the DiscoveryDoamin elements */
1003                 while (reader = lookup_next_matching_elem(reader, &m_flag,
1004                     DDOBJECT, ISNSRESPONSE)) {
1005                     if (m_flag == END_READER_MATCH) {
1006                         (void) xmlTextReaderNext(reader);
1007                         break;
1008                     }
1009
1010                     if (((xmlTextReaderMoveToAttribute(reader,
1011                         (const xmlChar *)NAMEATTR)) == 1) &&
1012                         (name = xmlTextReaderValue(reader))) {
1013                         if (mbstowcs(wc_name, (const char *)name,
1014                             ISNS_MAX_NAME_LEN) == (size_t)-1) {
1015                             (void) wcscpy(wc_name, L"-");
1016                         }
1017                         (void) printf("DD name: %ws\n", wc_name);
1018                     } else {
1019                         ret = ERROR_XML_NAME_ATTR_NOT_FOUND;
1020                         XML_SFREE(name);
1021                         goto out;
1022                     }
1023                     if ((ret = handle_association_info(name, dd_to_ddset)) !=
1024                         0) {
1025                         XML_SFREE(name);
1026                         goto out;
1027                     }
1028                     /* handle verbose */
1029                     if ((flag & VERBOSE) == VERBOSE) {
1030                         if ((ret = handle_association_info(name,
1031                             dd_to_node)) != 0) {
1032                             XML_SFREE(name);
1033                             goto out;
1034                         }
1035                     }
1036                     XML_SFREE(name);
1037                     m_flag = 0;
1038                 }
1039                 break;
1040             case DiscoveryDomainSet:
1041                 /* process the DiscoveryDoaminSet elements */
1042                 while (reader = lookup_next_matching_elem(reader, &m_flag,
1043                     DDSETOBJECT, ISNSRESPONSE)) {
1044                     if (m_flag == END_READER_MATCH) {
1045                         (void) xmlTextReaderNext(reader);
1046                         break;
1047                     }
1048
1049                     if (((xmlTextReaderMoveToAttribute(reader,
1050                         (const xmlChar *)NAMEATTR)) == 1) &&
1051                         (const char *)xmlTextReaderConstValue(reader)) {
1052                         if (mbstowcs(wc_name,
1053                             (const char *)xmlTextReaderConstValue(reader),
1054                             ISNS_MAX_NAME_LEN) == (size_t)-1) {
1055                             (void) wcscpy(wc_name, L"-");
1056                         }
1057                         if ((flag & VERBOSE) == VERBOSE) {
1058                             name = xmlTextReaderValue(reader);
1059                             (void) printf("DD Set name: %ws\n", wc_name);
1060                         } else {
1061                             (void) printf("DD Set name: %ws\n", wc_name);
1062                         }
1063                     } else {
1064                         ret = ERROR_XML_NAME_ATTR_NOT_FOUND;
1065                         XML_SFREE(name);
1066                         goto out;
1067                     }
1068                     m_flag = 0;
1069                     if ((reader = lookup_next_matching_elem(reader,
1070                         &m_flag, ENABLEDELEM, ISNSOBJECT))) {
1071                         if (m_flag == READER_MATCH) {
1072                             /* move to entity id value. */
1073                             if ((xmlTextReaderRead(reader) == 1) &&
1074                                 (XMLNCMPVAL(reader, XMLTRUE) == 0)) {
1075                                 (void) printf("\tState: Enabled\n");
1076                             } else {
1077                                 (void) printf("\tState: Disabled\n");
1078                             }
1079                         } else if (m_flag == END_READER_MATCH) {
1080                             (void) xmlTextReaderRead(reader);
1081                         }
1082                     }
1083
1084                     /* handle verbose */
1085                     if ((flag & VERBOSE) == VERBOSE) {
1086                         if ((ret = handle_association_info(name,
1087                             ddset_to_dd)) != 0) {
1088                             XML_SFREE(name);
1089                             goto out;
1090                         }
1091                     }
1092                     XML_SFREE(name);
1093                     m_flag = 0;
1094                 }
1095                 break;
1096             case ServerConfig:
1097                 /* process the DiscoveryDoaminSet elements */
1098                 m_flag = 0;
1099                 reader = lookup_next_matching_elem(reader, &m_flag,
1100                     ISNSSERVER, ISNSRESPONSE);
1101                 if (m_flag == END_READER_MATCH) {
1102                     ret = ERROR_XML_ISNSSERVER_ELEM_NOT_FOUND;
1103                     goto out;
1104                 }
1105                 m_flag = 0;
1106                 if ((reader = lookup_next_matching_elem(reader,
1107                     &m_flag, DATASTORELOCATION, ISNSRESPONSE))) {
1108                     if (m_flag == READER_MATCH) {
1109                         (void) xmlTextReaderRead(reader);
1110                         (void) printf("\tData Store Location: %s\n",
1111                         (const char *)xmlTextReaderConstValue(reader) ?
1112                         (const char *)xmlTextReaderConstValue(reader) : "-");
1113                     }
1114                 }
1115                 m_flag = 0;
1116                 if ((reader = lookup_next_matching_elem(reader,
1117                     &m_flag, ESIRETRYTHRESHOLD, ISNSRESPONSE))) {
1118                     if (m_flag == READER_MATCH) {
1119                         (void) xmlTextReaderRead(reader);
1120                         (void) printf("\tEntity Status Inquiry Non-Response ");
1121                         (void) printf("Threshold: %d\n",
1122                         xmlTextReaderConstValue(reader) ?
1123                         atoi((const char *)xmlTextReaderConstValue(reader))
1124                         : 0);
1125                     }
1126                 }
1127                 m_flag = 0;
1128                 if ((reader = lookup_next_matching_elem(reader,
1129                     &m_flag, MANAGEMENTSCNENABLED, ISNSRESPONSE))) {
1130                     if (m_flag == READER_MATCH) {
1131                         (void) xmlTextReaderRead(reader);
1132                         (void) printf("\tManagement SCN Enabled: %s\n",
1133                         (XMLNCMPVAL(reader, XMLTRUE) == 0) ?
1134                         "yes" : "no");
1135                     }
1136                 }
1137                 m_flag = 0;
1138                 while ((reader = lookup_next_matching_elem(reader,
1139                     &m_flag, CONTROLNODENAME, ISNSSERVER))) {
1140                     if (m_flag == READER_MATCH) {
1141                         if (!xmlTextReaderIsEmptyElement(reader)) {
1142                             (void) xmlTextReaderRead(reader);
1143                             if (mbstowcs(wc_name,
1144                                 (const char *)xmlTextReaderConstValue(reader),
1145                                 ISNS_MAX_NAME_LEN) == (size_t)-1) {
1146                                 (void) wcscpy(wc_name, L"-");
1147                             }
1148                             if (tag_printed) {
1149                                 if (xmlTextReaderConstValue(reader)) {
1150                                     if (mbstowcs(wc_name,
1151                                         (const char *)
1152                                         xmlTextReaderConstValue(reader),
1153                                         ISNS_MAX_NAME_LEN) == (size_t)-1) {
1154                                         (void) wcscpy(wc_name, L"-");
1155                                     }
1156                                     (void) printf(
1157                                     "\t                               %ws\n",
1158                                         wc_name);
1159                                 } else {
1160                                     (void) printf(
1161                                     "\t                               %s\n",
1162                                     "-");
1163                                 }
1164                             } else {
1165                                 if (xmlTextReaderConstValue(reader)) {
1166                                     if (mbstowcs(wc_name,
1167                                         (const char *)
1168                                         xmlTextReaderConstValue(reader),
1169                                         ISNS_MAX_NAME_LEN) == (size_t)-1) {
1170                                         (void) wcscpy(wc_name, L"-");
1171                                     }
1172                                     (void) printf(
1173                                     "\tAuthorized Control Node Names: %ws\n",
1174                                         wc_name);
1175                                 } else {
1176                                     (void) printf(
1177                                     "\tAuthorized Control Node Names: %s\n",
1178                                     "-");
1179                                 }
1180                                 tag_printed = 1;
1181                             }
1182                         } else {
1183                             (void) printf(
1184                                 "\tAuthorized Control Node Names: %s\n", "-");
1185                             break;
1186                         }
1187                     } else {
1188                         break;
1189                     }
1190                 }
1191                 break;
1192             default:
1193                 ret = UNKNOWN;
1194         }
1195
1196 out:
1197         (void) xmlTextReaderClose(reader);
1198         (void) xmlFreeTextReader(reader);
1199         if (status == PARTIAL_SUCCESS) {
1200             (void) fprintf(stderr, "%s\n",
1201                 getTextMessage(ERROR_PARTIAL_SUCCESS));
1202             if (ret == 0) ret = status;
1203         }
1204         return (ret);
1205
1206 }
1207
1208 /*
1209  * ****************************************************************************
1210  *
1211  * cvt_enumerate_rsp_to_get_req:
1212  *      pull out object info from enumerate response and calls
1213  *      build_get_xml_doc based on object type.
1214  *
1215  * doc          - enumerate resonse from the server.
1216  * req_do       - pointer to get request doc.
1217  * object_type  - isns object type.
1218  * flag         - user options
1219  *
1220  * ****************************************************************************
1221  */
1222 static int
1223 cvt_enumerate_rsp_to_get_req(xmlChar *doc, xmlChar **req_doc,
1224         object_type obj, uint32_t flag)
1225 {
1226         xmlTextReaderPtr reader;
1227         xmlChar **argxmlv;
1228         int ret = 0, status;
1229         int i, argxmlc = 0, m_flag = 0;
1230
1231         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory((const char *)doc,
1232             xmlStrlen(doc), NULL, NULL, 0)) == NULL) {
1233             return (ERROR_XML_READER_NULL);
1234         }
1235
1236         /* if status is 0, continue on.  Otherwise return an error. */
1237         if (reader = lookup_next_matching_elem(reader, &m_flag, STATUSELEMENT,
1238             RESULTELEMENT)) {
1239             if (m_flag == READER_MATCH) {
1240                 if (xmlTextReaderRead(reader) == 1) {
1241                     status =
1242                     atoi((const char *)xmlTextReaderConstValue(reader));
1243                     if (status != 0) {
1244                         print_error_status(status, obj, reader);
1245                         (void) xmlTextReaderClose(reader);
1246                         (void) xmlFreeTextReader(reader);
1247                         return (status);
1248                     }
1249                 } else {
1250                     (void) xmlTextReaderClose(reader);
1251                     xmlFreeTextReader(reader);
1252                     return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
1253                 }
1254             } else {
1255                 return (ERROR_XML_STATUS_ELEM_NOT_FOUND);
1256             }
1257         } else {
1258             return (ERROR_XML_READER_NULL);
1259         }
1260
1261         m_flag = 0;
1262
1263         argxmlv = (xmlChar **)malloc(sizeof (xmlChar *));
1264
1265         /* XXX - validate isnsResponse element from response doc. */
1266         switch (obj) {
1267             case Node:
1268                 /* process the node elements */
1269                 while (reader = lookup_next_matching_elem(reader, &m_flag,
1270                     NODEOBJECT, ISNSRESPONSE)) {
1271                     if (m_flag == END_READER_MATCH) {
1272                         (void) xmlTextReaderNext(reader);
1273                         break;
1274                     }
1275
1276                     /* check the type */
1277                     if ((xmlTextReaderMoveToAttribute(reader,
1278                         (const xmlChar *)TYPEATTR)) == 1) {
1279                         if (((flag & TARGET_ONLY) == TARGET_ONLY) &&
1280                             (XMLNCMPVAL(reader, TARGETTYPE) != 0)) {
1281                             /* move to next node object. */
1282                             (void) xmlTextReaderMoveToElement(reader);
1283                             (void) xmlTextReaderNext(reader);
1284                             continue;
1285                         }
1286                         if (((flag & INITIATOR_ONLY) == INITIATOR_ONLY) &&
1287                             (XMLNCMPVAL(reader, INITIATORTYPE) != 0)) {
1288                             /* move to next node object. */
1289                             (void) xmlTextReaderMoveToElement(reader);
1290                             (void) xmlTextReaderNext(reader);
1291                             continue;
1292                         }
1293                     } else {
1294                         ret = ERROR_XML_TYPE_ATTR_NOT_FOUND;
1295                         goto out;
1296                     }
1297
1298                     if (((xmlTextReaderMoveToAttribute(reader,
1299                         (const xmlChar *)NAMEATTR)) == 1) &&
1300                         xmlTextReaderConstValue(reader)) {
1301                         argxmlv = NEW_XMLARGV(argxmlv, argxmlc);
1302                         if (argxmlv == (xmlChar **)NULL) {
1303                             ret = ERROR_MALLOC_FAILED;
1304                             goto out;
1305                         }
1306                         argxmlv[argxmlc++] =
1307                             xmlStrdup(xmlTextReaderConstValue(reader));
1308                         argxmlv[argxmlc] = NULL;
1309                     } else {
1310                         ret = ERROR_XML_NAME_ATTR_NOT_FOUND;
1311                         goto out;
1312                     }
1313                     (void) xmlTextReaderRead(reader);
1314                     m_flag = 0;
1315                 } /* end for node while */
1316                 break;
1317             case DiscoveryDomain:
1318                 /* process the DiscoveryDoamin elements */
1319                 while (reader = lookup_next_matching_elem(reader, &m_flag,
1320                     DDOBJECT, ISNSRESPONSE)) {
1321                     if (m_flag == END_READER_MATCH) {
1322                         (void) xmlTextReaderNext(reader);
1323                         break;
1324                     }
1325
1326                     if (((xmlTextReaderMoveToAttribute(reader,
1327                         (const xmlChar *)NAMEATTR)) == 1) &&
1328                         xmlTextReaderConstValue(reader)) {
1329                         argxmlv = NEW_XMLARGV(argxmlv, argxmlc);
1330                         if (argxmlv == (xmlChar **)NULL) {
1331                             ret = ERROR_MALLOC_FAILED;
1332                             goto out;
1333                         }
1334                         argxmlv[argxmlc++] =
1335                             xmlStrdup(xmlTextReaderConstValue(reader));
1336                         argxmlv[argxmlc] = NULL;
1337                     } else {
1338                             ret = ERROR_XML_NAME_ATTR_NOT_FOUND;
1339                             goto out;
1340                     }
1341                     m_flag = 0;
1342                     (void) xmlTextReaderRead(reader);
1343                 }
1344                 break;
1345             case DiscoveryDomainSet:
1346                 /* process the DiscoveryDoaminSet elements */
1347                 while (reader = lookup_next_matching_elem(reader, &m_flag,
1348                     DDSETOBJECT, ISNSRESPONSE)) {
1349                     if (m_flag == END_READER_MATCH) {
1350                         (void) xmlTextReaderNext(reader);
1351                         break;
1352                     }
1353
1354                     if (((xmlTextReaderMoveToAttribute(reader,
1355                         (const xmlChar *)NAMEATTR)) == 1) &&
1356                         (const char *)xmlTextReaderConstValue(reader)) {
1357                         argxmlv = NEW_XMLARGV(argxmlv, argxmlc);
1358                         if (argxmlv == (xmlChar **)NULL) {
1359                             ret = ERROR_MALLOC_FAILED;
1360                             goto out;
1361                         }
1362                         argxmlv[argxmlc++] =
1363                             xmlStrdup(xmlTextReaderConstValue(reader));
1364                         argxmlv[argxmlc] = NULL;
1365                     } else {
1366                         ret = ERROR_XML_NAME_ATTR_NOT_FOUND;
1367                         goto out;
1368                     }
1369                     m_flag = 0;
1370                     (void) xmlTextReaderRead(reader);
1371                 }
1372                 break;
1373             default:
1374                 ret = UNKNOWN;
1375                 goto out;
1376         }
1377
1378         /* if no object found, stop here.  The status can be still 0. */
1379         if (argxmlc != 0) {
1380             if ((ret = build_get_xml_doc(argxmlc, (char **)argxmlv, obj,
1381                 req_doc)) != 0) {
1382                 return (ret);
1383             }
1384         } else {
1385             if (ret == 0) {
1386                 /* indicate there is no error but not object is found. */
1387                 ret = SUCCESS_WITH_NO_OBJECT;
1388             }
1389         }
1390
1391 out:
1392         (void) xmlTextReaderClose(reader);
1393         (void) xmlFreeTextReader(reader);
1394         if (argxmlc != 0) {
1395             for (i = 0; i < argxmlc; i++) {
1396                 xmlFree(argxmlv[i]);
1397             }
1398             (void) free(argxmlv);
1399         }
1400         return (ret);
1401
1402 }
1403
1404 /*
1405  * ****************************************************************************
1406  *
1407  * build_delete_xml_doc -
1408  *      build remove request doc based the name.
1409  *      the resulted doc is passed in the doc ptr.
1410  *
1411  * name         - object type
1412  * assoc        - association type
1413  * doc          - ptr to the resulted doc
1414  *
1415  * ****************************************************************************
1416  */
1417 static int
1418 build_delete_xml_doc(int operandLen, char **operand, object_type obj,
1419         char *container, xmlChar **doc)
1420 {
1421         xmlTextWriterPtr writer;
1422         xmlBufferPtr xbuf;
1423         int i, len;
1424
1425         if ((xbuf = xmlBufferCreate()) == NULL) {
1426                 return (ERROR_XML_CREATE_BUFFER_FAILED);
1427         }
1428
1429         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
1430                 return (ERROR_XML_CREATE_WRITER_FAILED);
1431         }
1432
1433         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
1434                 return (ERROR_XML_START_DOC_FAILED);
1435         }
1436
1437         /* Start element "isnsRequest". */
1438         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
1439             return (ERROR_XML_START_ELEMENT_FAILED);
1440         }
1441
1442         if ((xmlTextWriterWriteAttribute(writer,
1443             (xmlChar *)XMLNSATTR, (xmlChar *)XMLNSATTRVAL)) < 0) {
1444             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1445         }
1446
1447         /* request delete operation to get the entire list of obejct. */
1448         if (xmlTextWriterStartElement(writer, (xmlChar *)DELETE) < 0) {
1449                 return (ERROR_XML_START_ELEMENT_FAILED);
1450         }
1451
1452         switch (obj) {
1453             case DiscoveryDomain:
1454                 for (i = 0; i < operandLen; i++) {
1455                     /* start Discovery Domain element. */
1456                     if (xmlTextWriterStartElement(writer,
1457                         (xmlChar *)DDOBJECT) < 0) {
1458                         return (ERROR_XML_START_ELEMENT_FAILED);
1459                     }
1460
1461                     /* Start attr "name". */
1462                     if ((xmlTextWriterWriteAttribute(writer,
1463                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i])) < 0) {
1464                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1465                     }
1466
1467                     /* End element "DiscoveryDomain". */
1468                     if (xmlTextWriterEndElement(writer) < 0) {
1469                         return (ERROR_XML_END_ELEMENT_FAILED);
1470                     }
1471                 }
1472                 break;
1473             case DiscoveryDomainSet:
1474                 for (i = 0; i < operandLen; i++) {
1475                     /* start Discovery DomainSet element. */
1476                     if (xmlTextWriterStartElement(writer,
1477                         (xmlChar *)DDSETOBJECT) < 0) {
1478                         return (ERROR_XML_START_ELEMENT_FAILED);
1479                     }
1480
1481                     /* Start attr "name". */
1482                     if (xmlTextWriterWriteAttribute(writer,
1483                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
1484                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1485                     }
1486
1487                     /* End element "DiscoveryDomainSet". */
1488                     if (xmlTextWriterEndElement(writer) < 0) {
1489                         return (ERROR_XML_END_ELEMENT_FAILED);
1490                     }
1491                 }
1492                 break;
1493             case DiscoveryDomainMember:
1494                 for (i = 0; i < operandLen; i++) {
1495                     /* start Discovery Domain Member element. */
1496                     if (xmlTextWriterStartElement(writer,
1497                         (xmlChar *)DDOBJECTMEMBER) < 0) {
1498                         return (ERROR_XML_START_ELEMENT_FAILED);
1499                     }
1500
1501                     /* Start attr "DD Name". */
1502                     if (xmlTextWriterWriteAttribute(writer,
1503                         (xmlChar *)DDNAMEATTR, (xmlChar *)container) < 0) {
1504                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1505                     }
1506
1507                     /* Start attr "Node Name". */
1508                     if (xmlTextWriterWriteAttribute(writer,
1509                         (xmlChar *)NODENAMEATTR, (xmlChar *)operand[i]) < 0) {
1510                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1511                     }
1512
1513                     /* End element "DiscoveryDomainMember. */
1514                     if (xmlTextWriterEndElement(writer) < 0) {
1515                         return (ERROR_XML_END_ELEMENT_FAILED);
1516                     }
1517                 }
1518                 break;
1519             case DiscoveryDomainSetMember:
1520                 for (i = 0; i < operandLen; i++) {
1521                     /* start Discovery Domain Member element. */
1522                     if (xmlTextWriterStartElement(writer,
1523                         (xmlChar *)DDSETOBJECTMEMBER) < 0) {
1524                         return (ERROR_XML_START_ELEMENT_FAILED);
1525                     }
1526
1527                     /* Start attr "DD Set Name". */
1528                     if (xmlTextWriterWriteAttribute(writer,
1529                         (xmlChar *)DDSETNAMEATTR, (xmlChar *)(container)) < 0) {
1530                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1531                     }
1532
1533                     /* Start attr "DD Name". */
1534                     if (xmlTextWriterWriteAttribute(writer,
1535                         (xmlChar *)DDNAMEATTR, (xmlChar *)(operand[i])) < 0) {
1536                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1537                     }
1538
1539                     /* End element "DiscoveryDomainSetMember. */
1540                     if (xmlTextWriterEndElement(writer) < 0) {
1541                         return (ERROR_XML_END_ELEMENT_FAILED);
1542                     }
1543                 }
1544                 break;
1545             default:
1546                     xmlFreeTextWriter(writer);
1547                     return (UNKNOWN);
1548         }
1549
1550         /* end createModify */
1551         if (xmlTextWriterEndElement(writer) < 0) {
1552             xmlFreeTextWriter(writer);
1553             return (ERROR_XML_END_ELEMENT_FAILED);
1554         }
1555
1556         /* End element "isnsRequest". */
1557         if (xmlTextWriterEndElement(writer) < 0) {
1558             xmlFreeTextWriter(writer);
1559             return (ERROR_XML_END_ELEMENT_FAILED);
1560         }
1561         if (xmlTextWriterEndDocument(writer) < 0) {
1562             xmlFreeTextWriter(writer);
1563             return (ERROR_XML_END_DOC_FAILED);
1564         }
1565
1566         xmlFreeTextWriter(writer);
1567
1568         len = xmlStrlen(xbuf->content) + 1;
1569         /* XXX - copy NULL at the end by having one more extra byte */
1570         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
1571             return (ERROR_XML_STRDUP_FAILED);
1572         }
1573
1574         xmlBufferFree(xbuf);
1575
1576         return (0);
1577 }
1578
1579 /*
1580  * ****************************************************************************
1581  *
1582  * build_modify_xml_doc -
1583  *      build create request doc based the name.
1584  *      the resulted doc is passed in the doc ptr.
1585  *
1586  * operannLen   - number of objects
1587  * operand      - object list
1588  * enabled      - indication of enable and disable boolean type element.
1589  * doc          - ptr to the resulted doc
1590  *
1591  * ****************************************************************************
1592  */
1593 static int
1594 build_modify_xml_doc(int operandLen, char **operand, object_type obj,
1595         boolean_t enabled, xmlChar **doc)
1596 {
1597         xmlTextWriterPtr writer;
1598         xmlBufferPtr xbuf;
1599         int i, len;
1600
1601         if ((xbuf = xmlBufferCreate()) == NULL) {
1602                 return (ERROR_XML_CREATE_BUFFER_FAILED);
1603         }
1604
1605         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
1606                 return (ERROR_XML_CREATE_WRITER_FAILED);
1607         }
1608
1609         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
1610                 return (ERROR_XML_START_DOC_FAILED);
1611         }
1612
1613         /* Start element "isnsRequest". */
1614         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
1615             return (ERROR_XML_START_ELEMENT_FAILED);
1616         }
1617
1618         if ((xmlTextWriterWriteAttribute(writer,
1619             (xmlChar *)XMLNSATTR, (xmlChar *)XMLNSATTRVAL)) < 0) {
1620             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1621         }
1622
1623         /* request createModify operation to get the entire list of obejct. */
1624         if (xmlTextWriterStartElement(writer, (xmlChar *)CREATEMODIFY) < 0) {
1625                 return (ERROR_XML_START_ELEMENT_FAILED);
1626         }
1627
1628         switch (obj) {
1629             case DiscoveryDomain:
1630                 for (i = 0; i < operandLen; i++) {
1631                     /* start Discovery Domain element. */
1632                     if (xmlTextWriterStartElement(writer,
1633                         (xmlChar *)DDOBJECT) < 0) {
1634                         return (ERROR_XML_START_ELEMENT_FAILED);
1635                     }
1636
1637                     /* write attr "name". */
1638                     if ((xmlTextWriterWriteAttribute(writer,
1639                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i])) < 0) {
1640                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1641                     }
1642
1643                     /* write bootlist_enabled elem */
1644                     if (xmlTextWriterWriteElement(writer,
1645                         (xmlChar *)BOOTLISTENABLEDELEM, (enabled)?
1646                         (xmlChar *)XMLTRUE : (xmlChar *)XMLFALSE) < 0) {
1647                         return (ERROR_XML_WRITE_ELEMENT_FAILED);
1648                     }
1649
1650                     /* End element "DiscoveryDomain". */
1651                     if (xmlTextWriterEndElement(writer) < 0) {
1652                         return (ERROR_XML_END_ELEMENT_FAILED);
1653                     }
1654                 }
1655                 break;
1656             case DiscoveryDomainSet:
1657                 for (i = 0; i < operandLen; i++) {
1658                     /* start Discovery DomainSet element. */
1659                     if (xmlTextWriterStartElement(writer,
1660                         (xmlChar *)DDSETOBJECT) < 0) {
1661                         return (ERROR_XML_START_ELEMENT_FAILED);
1662                     }
1663
1664                     /* Start attr "name". */
1665                     if (xmlTextWriterWriteAttribute(writer,
1666                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
1667                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1668                     }
1669
1670                     /* write enabled elem */
1671                     if (xmlTextWriterWriteElement(writer,
1672                         (xmlChar *)ENABLEDELEM, (enabled) ?
1673                         (xmlChar *)XMLTRUE : (xmlChar *)XMLFALSE) < 0) {
1674                         return (ERROR_XML_WRITE_ELEMENT_FAILED);
1675                     }
1676
1677                     /* End element "DiscoveryDomainSet". */
1678                     if (xmlTextWriterEndElement(writer) < 0) {
1679                         return (ERROR_XML_END_ELEMENT_FAILED);
1680                     }
1681                 }
1682                 break;
1683             default:
1684                     xmlFreeTextWriter(writer);
1685                     return (UNKNOWN);
1686         }
1687
1688         /* end createModify */
1689         if (xmlTextWriterEndElement(writer) < 0) {
1690             xmlFreeTextWriter(writer);
1691             return (ERROR_XML_END_ELEMENT_FAILED);
1692         }
1693
1694         /* End element "isnsRequest". */
1695         if (xmlTextWriterEndElement(writer) < 0) {
1696             xmlFreeTextWriter(writer);
1697             return (ERROR_XML_END_ELEMENT_FAILED);
1698         }
1699         if (xmlTextWriterEndDocument(writer) < 0) {
1700             xmlFreeTextWriter(writer);
1701             return (ERROR_XML_END_DOC_FAILED);
1702         }
1703
1704         xmlFreeTextWriter(writer);
1705
1706         len = xmlStrlen(xbuf->content) + 1;
1707         /* XXX - copy NULL at the end by having one more extra byte */
1708         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
1709             return (ERROR_XML_STRDUP_FAILED);
1710         }
1711
1712         xmlBufferFree(xbuf);
1713
1714         return (0);
1715 }
1716
1717 /*
1718  * ****************************************************************************
1719  *
1720  * build_rename_xml_doc -
1721  *      build create request doc based the name.
1722  *      the resulted doc is passed in the doc ptr.
1723  *
1724  * assoc        - a new name
1725  * id           - index of the object of which name  to be changed
1726  * doc          - ptr to the resulted doc
1727  *
1728  * ****************************************************************************
1729  */
1730 static int
1731 build_rename_xml_doc(char *name, object_type obj, uint32_t id, xmlChar **doc)
1732 {
1733         xmlTextWriterPtr writer;
1734         xmlBufferPtr xbuf;
1735         int len;
1736         char namebuf[32];
1737
1738         if ((xbuf = xmlBufferCreate()) == NULL) {
1739                 return (ERROR_XML_CREATE_BUFFER_FAILED);
1740         }
1741
1742         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
1743                 return (ERROR_XML_CREATE_WRITER_FAILED);
1744         }
1745
1746         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
1747                 return (ERROR_XML_START_DOC_FAILED);
1748         }
1749
1750         /* Start element "isnsRequest". */
1751         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
1752             return (ERROR_XML_START_ELEMENT_FAILED);
1753         }
1754
1755         if ((xmlTextWriterWriteAttribute(writer,
1756             (xmlChar *)XMLNSATTR, (xmlChar *)XMLNSATTRVAL)) < 0) {
1757             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1758         }
1759
1760         /* request createModify operation to get the entire list of obejct. */
1761         if (xmlTextWriterStartElement(writer, (xmlChar *)CREATEMODIFY) < 0) {
1762                 return (ERROR_XML_START_ELEMENT_FAILED);
1763         }
1764
1765         switch (obj) {
1766             case DiscoveryDomain:
1767                     /* start Discovery Domain element. */
1768                     if (xmlTextWriterStartElement(writer,
1769                         (xmlChar *)DDOBJECT) < 0) {
1770                         return (ERROR_XML_START_ELEMENT_FAILED);
1771                     }
1772
1773                     /* write attr "name". */
1774                     if ((xmlTextWriterWriteAttribute(writer,
1775                         (xmlChar *)NAMEATTR, (xmlChar *)name)) < 0) {
1776                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1777                     }
1778
1779                     /* write attr "id". */
1780                     (void) sprintf(namebuf, "%d", id);
1781                     if ((xmlTextWriterWriteAttribute(writer,
1782                         (xmlChar *)IDATTR, (xmlChar *)namebuf)) < 0) {
1783                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1784                     }
1785
1786                     /* End element "DiscoveryDomain". */
1787                     if (xmlTextWriterEndElement(writer) < 0) {
1788                         return (ERROR_XML_END_ELEMENT_FAILED);
1789                     }
1790                 break;
1791             case DiscoveryDomainSet:
1792                     /* start Discovery DomainSet element. */
1793                     if (xmlTextWriterStartElement(writer,
1794                         (xmlChar *)DDSETOBJECT) < 0) {
1795                         return (ERROR_XML_START_ELEMENT_FAILED);
1796                     }
1797
1798                     /* Start attr "name". */
1799                     if (xmlTextWriterWriteAttribute(writer,
1800                         (xmlChar *)NAMEATTR, (xmlChar *)name) < 0) {
1801                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1802                     }
1803
1804                     /* write attr "id". */
1805                     (void) sprintf(namebuf, "%d", id);
1806                     if ((xmlTextWriterWriteAttribute(writer,
1807                         (xmlChar *)IDATTR, (xmlChar *)namebuf)) < 0) {
1808                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1809                     }
1810
1811                     /* End element "DiscoveryDomainSet". */
1812                     if (xmlTextWriterEndElement(writer) < 0) {
1813                         return (ERROR_XML_END_ELEMENT_FAILED);
1814                     }
1815                 break;
1816             default:
1817                     xmlFreeTextWriter(writer);
1818                     return (UNKNOWN);
1819         }
1820
1821         /* end createModify */
1822         if (xmlTextWriterEndElement(writer) < 0) {
1823             xmlFreeTextWriter(writer);
1824             return (ERROR_XML_END_ELEMENT_FAILED);
1825         }
1826
1827         /* End element "isnsRequest". */
1828         if (xmlTextWriterEndElement(writer) < 0) {
1829             xmlFreeTextWriter(writer);
1830             return (ERROR_XML_END_ELEMENT_FAILED);
1831         }
1832         if (xmlTextWriterEndDocument(writer) < 0) {
1833             xmlFreeTextWriter(writer);
1834             return (ERROR_XML_END_DOC_FAILED);
1835         }
1836
1837         xmlFreeTextWriter(writer);
1838
1839         len = xmlStrlen(xbuf->content) + 1;
1840         /* XXX - copy NULL at the end by having one more extra byte */
1841         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
1842             return (ERROR_XML_STRDUP_FAILED);
1843         }
1844
1845         xmlBufferFree(xbuf);
1846
1847         return (0);
1848 }
1849
1850 /*
1851  * ****************************************************************************
1852  *
1853  * build_create_xml_doc -
1854  *      build create request doc based the name.
1855  *      the resulted doc is passed in the doc ptr.
1856  *
1857  * name         - object type
1858  * assoc        - association type
1859  * doc          - ptr to the resulted doc
1860  *
1861  * ****************************************************************************
1862  */
1863 static int
1864 build_create_xml_doc(int operandLen, char **operand, object_type obj,
1865         char *container, xmlChar **doc)
1866 {
1867         xmlTextWriterPtr writer;
1868         xmlBufferPtr xbuf;
1869         int i, len;
1870
1871         if ((xbuf = xmlBufferCreate()) == NULL) {
1872                 return (ERROR_XML_CREATE_BUFFER_FAILED);
1873         }
1874
1875         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
1876                 return (ERROR_XML_CREATE_WRITER_FAILED);
1877         }
1878
1879         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
1880                 return (ERROR_XML_START_DOC_FAILED);
1881         }
1882
1883         /* Start element "isnsRequest". */
1884         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
1885             return (ERROR_XML_START_ELEMENT_FAILED);
1886         }
1887
1888         /* request createModify operation to get the entire list of obejct. */
1889         if (xmlTextWriterStartElement(writer, (xmlChar *)CREATEMODIFY) < 0) {
1890                 return (ERROR_XML_START_ELEMENT_FAILED);
1891         }
1892
1893         switch (obj) {
1894             case DiscoveryDomain:
1895                 for (i = 0; i < operandLen; i++) {
1896                     /* start Discovery Domain element. */
1897                     if (xmlTextWriterStartElement(writer,
1898                         (xmlChar *)DDOBJECT) < 0) {
1899                         return (ERROR_XML_START_ELEMENT_FAILED);
1900                     }
1901
1902                     /* Start attr "name". */
1903                     if ((xmlTextWriterWriteAttribute(writer,
1904                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i])) < 0) {
1905                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1906                     }
1907
1908                     /* End element "DiscoveryDomain". */
1909                     if (xmlTextWriterEndElement(writer) < 0) {
1910                         return (ERROR_XML_END_ELEMENT_FAILED);
1911                     }
1912                 }
1913                 break;
1914             case DiscoveryDomainSet:
1915                 for (i = 0; i < operandLen; i++) {
1916                     /* start Discovery DomainSet element. */
1917                     if (xmlTextWriterStartElement(writer,
1918                         (xmlChar *)DDSETOBJECT) < 0) {
1919                         return (ERROR_XML_START_ELEMENT_FAILED);
1920                     }
1921
1922                     /* Start attr "name". */
1923                     if (xmlTextWriterWriteAttribute(writer,
1924                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
1925                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1926                     }
1927
1928                     /* End element "DiscoveryDomainSet". */
1929                     if (xmlTextWriterEndElement(writer) < 0) {
1930                         return (ERROR_XML_END_ELEMENT_FAILED);
1931                     }
1932                 }
1933                 break;
1934             case DiscoveryDomainMember:
1935                 for (i = 0; i < operandLen; i++) {
1936                     /* start Discovery Domain Member element. */
1937                     if (xmlTextWriterStartElement(writer,
1938                         (xmlChar *)DDOBJECTMEMBER) < 0) {
1939                         return (ERROR_XML_START_ELEMENT_FAILED);
1940                     }
1941
1942                     /* Start attr "DD Name". */
1943                     if (xmlTextWriterWriteAttribute(writer,
1944                         (xmlChar *)DDNAMEATTR, (xmlChar *)container) < 0) {
1945                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1946                     }
1947
1948                     /* Start attr "Node Name". */
1949                     if (xmlTextWriterWriteAttribute(writer,
1950                         (xmlChar *)NODENAMEATTR, (xmlChar *)operand[i]) < 0) {
1951                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1952                     }
1953
1954                     /* End element "DiscoveryDomainMember. */
1955                     if (xmlTextWriterEndElement(writer) < 0) {
1956                         return (ERROR_XML_END_ELEMENT_FAILED);
1957                     }
1958                 }
1959                 break;
1960             case DiscoveryDomainSetMember:
1961                 for (i = 0; i < operandLen; i++) {
1962                     /* start Discovery Domain Member element. */
1963                     if (xmlTextWriterStartElement(writer,
1964                         (xmlChar *)DDSETOBJECTMEMBER) < 0) {
1965                         return (ERROR_XML_START_ELEMENT_FAILED);
1966                     }
1967
1968                     /* Start attr "DD Set Name". */
1969                     if (xmlTextWriterWriteAttribute(writer,
1970                         (xmlChar *)DDSETNAMEATTR, (xmlChar *)(container)) < 0) {
1971                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1972                     }
1973
1974                     /* Start attr "DD Name". */
1975                     if (xmlTextWriterWriteAttribute(writer,
1976                         (xmlChar *)DDNAMEATTR, (xmlChar *)(operand[i])) < 0) {
1977                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
1978                     }
1979
1980                     /* End element "DiscoveryDomainSetMember. */
1981                     if (xmlTextWriterEndElement(writer) < 0) {
1982                         return (ERROR_XML_END_ELEMENT_FAILED);
1983                     }
1984                 }
1985                 break;
1986             default:
1987                     xmlFreeTextWriter(writer);
1988                     return (UNKNOWN);
1989         }
1990
1991         /* end createModify */
1992         if (xmlTextWriterEndElement(writer) < 0) {
1993             xmlFreeTextWriter(writer);
1994             return (ERROR_XML_END_ELEMENT_FAILED);
1995         }
1996
1997         /* End element "isnsRequest". */
1998         if (xmlTextWriterEndElement(writer) < 0) {
1999             xmlFreeTextWriter(writer);
2000             return (ERROR_XML_END_ELEMENT_FAILED);
2001         }
2002         if (xmlTextWriterEndDocument(writer) < 0) {
2003             xmlFreeTextWriter(writer);
2004             return (ERROR_XML_END_DOC_FAILED);
2005         }
2006
2007         xmlFreeTextWriter(writer);
2008
2009         len = xmlStrlen(xbuf->content) + 1;
2010         /* XXX - copy NULL at the end by having one more extra byte */
2011         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
2012             return (ERROR_XML_STRDUP_FAILED);
2013         }
2014
2015         xmlBufferFree(xbuf);
2016
2017         return (0);
2018 }
2019
2020 /*
2021  * ****************************************************************************
2022  *
2023  * build_assoc_xml_doc -
2024  *      build association request doc based the name.
2025  *      the resulted doc is passed in the doc ptr.
2026  *
2027  * name         - object type
2028  * assoc        - association type
2029  * doc          - ptr to the resulted doc
2030  *
2031  * ****************************************************************************
2032  */
2033 static int
2034 build_assoc_xml_doc(xmlChar *name, association_t assoc, xmlChar **doc)
2035 {
2036         xmlTextWriterPtr writer;
2037         xmlBufferPtr xbuf;
2038         int len;
2039
2040         if ((xbuf = xmlBufferCreate()) == NULL) {
2041                 return (ERROR_XML_CREATE_BUFFER_FAILED);
2042         }
2043
2044         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
2045                 return (ERROR_XML_CREATE_WRITER_FAILED);
2046         }
2047
2048         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
2049                 return (ERROR_XML_START_DOC_FAILED);
2050         }
2051
2052         /* Start element "isnsRequest". */
2053         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
2054             return (ERROR_XML_START_ELEMENT_FAILED);
2055         }
2056
2057         /* request getAssociated operation to get the entire list of obejct. */
2058         if (xmlTextWriterStartElement(writer, (xmlChar *)GETASSOCIATED) < 0) {
2059                 return (ERROR_XML_START_ELEMENT_FAILED);
2060         }
2061
2062         switch (assoc) {
2063             case (node_to_dd):
2064                 /* write association type. */
2065                 if (xmlTextWriterWriteElement(writer,
2066                     (xmlChar *)ASSOCIATIONTYPE,
2067                     (xmlChar *)DDOBJECTMEMBER) < 0) {
2068                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2069                 }
2070
2071                 if (xmlTextWriterStartElement(writer,
2072                     (xmlChar *)ISNSOBJECT) < 0) {
2073                     return (ERROR_XML_START_ELEMENT_FAILED);
2074                 }
2075
2076                 if (xmlTextWriterStartElement(writer,
2077                     (xmlChar *)NODEOBJECT) < 0) {
2078                     return (ERROR_XML_START_ELEMENT_FAILED);
2079                 }
2080
2081                 /* Start attr "name". */
2082                 if (xmlTextWriterWriteAttribute(writer,
2083                     (xmlChar *)NAMEATTR, name) < 0) {
2084                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2085                 }
2086                 if (xmlTextWriterWriteAttribute(writer,
2087                     (xmlChar *)TYPEATTR, (xmlChar *)EMPTYSTR) < 0) {
2088                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2089                 }
2090                 if (xmlTextWriterWriteAttribute(writer,
2091                     (xmlChar *)ALIASATTR, (xmlChar *)EMPTYSTR) < 0) {
2092                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2093                 }
2094
2095                 /* End element "Node". */
2096                 if (xmlTextWriterEndElement(writer) < 0) {
2097                     return (ERROR_XML_END_ELEMENT_FAILED);
2098                 }
2099
2100                 /* End element "isnsObject". */
2101                 if (xmlTextWriterEndElement(writer) < 0) {
2102                     return (ERROR_XML_END_ELEMENT_FAILED);
2103                 }
2104                 break;
2105             case (dd_to_node):
2106                 /* write association type. */
2107                 if (xmlTextWriterWriteElement(writer,
2108                     (xmlChar *)ASSOCIATIONTYPE,
2109                     (xmlChar *)DDOBJECTMEMBER) < 0) {
2110                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2111                 }
2112
2113                 /* start isnsObject */
2114                 if (xmlTextWriterStartElement(writer,
2115                     (xmlChar *)ISNSOBJECT) < 0) {
2116                     return (ERROR_XML_START_ELEMENT_FAILED);
2117                 }
2118
2119                 /* start DiscoveryDomain */
2120                 if (xmlTextWriterStartElement(writer,
2121                     (xmlChar *)DDOBJECT) < 0) {
2122                     return (ERROR_XML_START_ELEMENT_FAILED);
2123                 }
2124
2125                 /* Start attr "name". */
2126                 if (xmlTextWriterWriteAttribute(writer,
2127                     (xmlChar *)NAMEATTR, name) < 0) {
2128                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2129                 }
2130
2131                 /* End element "DiscoveryDomain". */
2132                 if (xmlTextWriterEndElement(writer) < 0) {
2133                     return (ERROR_XML_END_ELEMENT_FAILED);
2134                 }
2135
2136                 /* End element "isnsObject". */
2137                 if (xmlTextWriterEndElement(writer) < 0) {
2138                     return (ERROR_XML_END_ELEMENT_FAILED);
2139                 }
2140                 break;
2141             case (ddset_to_dd):
2142                 /* write association type. */
2143                 if (xmlTextWriterWriteElement(writer,
2144                     (xmlChar *)ASSOCIATIONTYPE,
2145                     (xmlChar *)DDSETOBJECTMEMBER) < 0) {
2146                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2147                 }
2148
2149                 /* start isnsObject */
2150                 if (xmlTextWriterStartElement(writer,
2151                     (xmlChar *)ISNSOBJECT) < 0) {
2152                     return (ERROR_XML_START_ELEMENT_FAILED);
2153                 }
2154
2155                 /* start DiscoveryDomainSet */
2156                 if (xmlTextWriterStartElement(writer,
2157                     (xmlChar *)DDSETOBJECT) < 0) {
2158                     return (ERROR_XML_START_ELEMENT_FAILED);
2159                 }
2160
2161                 /* Start attr "name". */
2162                 if (xmlTextWriterWriteAttribute(writer,
2163                     (xmlChar *)NAMEATTR, name) < 0) {
2164                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2165                 }
2166
2167                 /* End element "DiscoveryDomain". */
2168                 if (xmlTextWriterEndElement(writer) < 0) {
2169                     return (ERROR_XML_END_ELEMENT_FAILED);
2170                 }
2171
2172                 /* End element "isnsObject". */
2173                 if (xmlTextWriterEndElement(writer) < 0) {
2174                     return (ERROR_XML_END_ELEMENT_FAILED);
2175                 }
2176                 break;
2177             case (dd_to_ddset):
2178                 /* write association type. */
2179                 if (xmlTextWriterWriteElement(writer,
2180                     (xmlChar *)ASSOCIATIONTYPE,
2181                     (xmlChar *)DDSETOBJECTMEMBER) < 0) {
2182                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2183                 }
2184
2185                 /* start isnsObject */
2186                 if (xmlTextWriterStartElement(writer,
2187                     (xmlChar *)ISNSOBJECT) < 0) {
2188                     return (ERROR_XML_START_ELEMENT_FAILED);
2189                 }
2190
2191                 /* start DiscoveryDomain */
2192                 if (xmlTextWriterStartElement(writer,
2193                     (xmlChar *)DDOBJECT) < 0) {
2194                     return (ERROR_XML_START_ELEMENT_FAILED);
2195                 }
2196
2197                 /* Start attr "name". */
2198                 if (xmlTextWriterWriteAttribute(writer,
2199                     (xmlChar *)NAMEATTR, name) < 0) {
2200                     return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2201                 }
2202
2203                 /* End element "DiscoveryDomain". */
2204                 if (xmlTextWriterEndElement(writer) < 0) {
2205                     return (ERROR_XML_END_ELEMENT_FAILED);
2206                 }
2207
2208                 /* End element "isnsObject". */
2209                 if (xmlTextWriterEndElement(writer) < 0) {
2210                     return (ERROR_XML_END_ELEMENT_FAILED);
2211                 }
2212                 break;
2213             default:
2214                 return (UNKNOWN);
2215         }
2216
2217         /* end getAssociated */
2218         if (xmlTextWriterEndElement(writer) < 0) {
2219                 return (ERROR_XML_END_ELEMENT_FAILED);
2220         }
2221
2222         /* End element "isnsRequest". */
2223         if (xmlTextWriterEndElement(writer) < 0) {
2224             return (ERROR_XML_END_ELEMENT_FAILED);
2225         }
2226         if (xmlTextWriterEndDocument(writer) < 0) {
2227             return (ERROR_XML_END_DOC_FAILED);
2228         }
2229
2230         xmlFreeTextWriter(writer);
2231
2232         len = xmlStrlen(xbuf->content) + 1;
2233         /* XXX - copy NULL at the end by having one more extra byte */
2234         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
2235             return (ERROR_XML_STRDUP_FAILED);
2236         }
2237
2238         xmlBufferFree(xbuf);
2239         return (0);
2240 }
2241
2242 /*
2243  * ****************************************************************************
2244  *
2245  * build_enumerate_xml_doc -
2246  *      build association request doc based the name.
2247  *      the resulted doc is passed in the doc ptr.
2248  *
2249  * name         - object type
2250  * doc          - ptr to the resulted doc
2251  *
2252  * ****************************************************************************
2253  */
2254 static int
2255 build_enumerate_xml_doc(object_type obj, xmlChar **doc)
2256 {
2257         xmlTextWriterPtr writer;
2258         xmlBufferPtr xbuf;
2259         int len;
2260
2261         if ((xbuf = xmlBufferCreate()) == NULL) {
2262                 return (ERROR_XML_CREATE_BUFFER_FAILED);
2263         }
2264
2265         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
2266                 return (ERROR_XML_CREATE_WRITER_FAILED);
2267         }
2268
2269         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
2270                 return (ERROR_XML_START_DOC_FAILED);
2271         }
2272
2273         /* Start element "isnsRequest". */
2274         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
2275             return (ERROR_XML_START_ELEMENT_FAILED);
2276         }
2277
2278         /* Start attr "xmlns". */
2279         if (xmlTextWriterWriteAttribute(writer,
2280             (xmlChar *)"xmlns",
2281             (xmlChar *)"http://www.sun.com/schema/isnsmanagement")) {
2282             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2283         }
2284
2285         /* request enumerate operation to get the entire list of obejct. */
2286         if (xmlTextWriterStartElement(writer, (xmlChar *)ENUMERATE) < 0) {
2287             return (ERROR_XML_START_ELEMENT_FAILED);
2288         }
2289
2290         switch (obj) {
2291             case (Node):
2292                 if (xmlTextWriterWriteElement(writer,
2293                     (xmlChar *)ISNSOBJECTTYPE, (xmlChar *)NODEOBJECT) < 0) {
2294                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2295                 }
2296                 break;
2297             case (DiscoveryDomain):
2298                 if (xmlTextWriterWriteElement(writer,
2299                     (xmlChar *)ISNSOBJECTTYPE,
2300                     (xmlChar *)DDOBJECT) < 0) {
2301                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2302                 }
2303                 break;
2304             case (DiscoveryDomainSet):
2305                 if (xmlTextWriterWriteElement(writer,
2306                     (xmlChar *)ISNSOBJECTTYPE,
2307                     (xmlChar *)DDSETOBJECT) < 0) {
2308                     return (ERROR_XML_WRITE_ELEMENT_FAILED);
2309                 }
2310                 break;
2311             default:
2312                 return (UNKNOWN);
2313         }
2314
2315         /* end isns object type */
2316         if (xmlTextWriterEndElement(writer) < 0) {
2317             return (ERROR_XML_END_ELEMENT_FAILED);
2318         }
2319
2320         /* End element "isnsRequest". */
2321         if (xmlTextWriterEndElement(writer) < 0) {
2322             return (ERROR_XML_END_ELEMENT_FAILED);
2323         }
2324         if (xmlTextWriterEndDocument(writer) < 0) {
2325             return (ERROR_XML_END_DOC_FAILED);
2326         }
2327
2328         xmlFreeTextWriter(writer);
2329
2330         len = xmlStrlen(xbuf->content) + 1;
2331         /* XXX - copy NULL at the end by having one more extra byte */
2332         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
2333             return (ERROR_XML_STRDUP_FAILED);
2334         }
2335
2336         xmlBufferFree(xbuf);
2337         return (0);
2338 }
2339
2340 /*
2341  * ****************************************************************************
2342  *
2343  * build_get_xml_doc -
2344  *      build association request doc based the name.
2345  *      the resulted doc is passed in the doc ptr.
2346  *
2347  * name         - object type
2348  * assoc        - association type
2349  * doc          - ptr to the resulted doc
2350  *
2351  * ****************************************************************************
2352  */
2353 static int
2354 build_get_xml_doc(int operandLen, char **operand, object_type obj,
2355         xmlChar **doc)
2356 {
2357         xmlTextWriterPtr writer;
2358         xmlBufferPtr xbuf;
2359         int i, len;
2360
2361         if ((xbuf = xmlBufferCreate()) == NULL) {
2362                 return (ERROR_XML_CREATE_BUFFER_FAILED);
2363         }
2364
2365         if ((writer = xmlNewTextWriterMemory(xbuf, 0)) == NULL) {
2366                 return (ERROR_XML_CREATE_WRITER_FAILED);
2367         }
2368
2369         if (xmlTextWriterStartDocument(writer, "1.0", NULL, NULL) < 0) {
2370                 return (ERROR_XML_START_DOC_FAILED);
2371         }
2372
2373         /* Start element "isnsRequest". */
2374         if (xmlTextWriterStartElement(writer, (xmlChar *)ISNSREQUEST) < 0) {
2375             return (ERROR_XML_START_ELEMENT_FAILED);
2376         }
2377
2378         /* Start attr "xmlns". */
2379         if (xmlTextWriterWriteAttribute(writer,
2380             (xmlChar *)"xmlns",
2381             (xmlChar *)"http://www.sun.com/schema/isnsmanagement")) {
2382             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2383         }
2384
2385         /* Start element "get". */
2386         if (xmlTextWriterStartElement(writer, (xmlChar *)GET) < 0) {
2387             return (ERROR_XML_START_ELEMENT_FAILED);
2388         }
2389
2390         switch (obj) {
2391             case (Node):
2392                 for (i = 0; i < operandLen; i++) {
2393                     /* Start element "isnsObject". */
2394                     if (xmlTextWriterStartElement(writer,
2395                         (xmlChar *)ISNSOBJECT) < 0) {
2396                         return (ERROR_XML_START_ELEMENT_FAILED);
2397                     }
2398
2399                     /* Start element Node. */
2400                     if (xmlTextWriterStartElement(writer,
2401                         (xmlChar *)NODEOBJECT) < 0) {
2402                         return (ERROR_XML_START_ELEMENT_FAILED);
2403                     }
2404
2405                     /* Start attr "name". */
2406                     if (xmlTextWriterWriteAttribute(writer,
2407                         (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
2408                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2409                     }
2410                     if (xmlTextWriterWriteAttribute(writer,
2411                         (xmlChar *)TYPEATTR, (xmlChar *)EMPTYSTR) < 0) {
2412                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2413                     }
2414                     if (xmlTextWriterWriteAttribute(writer,
2415                         (xmlChar *)ALIASATTR, (xmlChar *)EMPTYSTR) < 0) {
2416                         return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2417                     }
2418
2419                     /* End element "Node". */
2420                     if (xmlTextWriterEndElement(writer) < 0) {
2421                         return (ERROR_XML_END_ELEMENT_FAILED);
2422                     }
2423
2424                     /* End element "isnsObject". */
2425                     if (xmlTextWriterEndElement(writer) < 0) {
2426                         return (ERROR_XML_END_ELEMENT_FAILED);
2427                     }
2428                 }
2429                 break;
2430             case (DiscoveryDomain):
2431                     for (i = 0; i < operandLen; i++) {
2432                         /* Start element "isnsObject". */
2433                         if (xmlTextWriterStartElement(writer,
2434                             (xmlChar *)ISNSOBJECT) < 0) {
2435                             return (ERROR_XML_START_ELEMENT_FAILED);
2436                         }
2437
2438                         if (xmlTextWriterStartElement(writer,
2439                             (xmlChar *)DDOBJECT) < 0) {
2440                             return (ERROR_XML_START_ELEMENT_FAILED);
2441                         }
2442
2443                         /* Start attr "name". */
2444                         if (xmlTextWriterWriteAttribute(writer,
2445                             (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
2446                             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2447                         }
2448
2449                         /* End element "DiscoveryDomain". */
2450                         if (xmlTextWriterEndElement(writer) < 0) {
2451                             return (ERROR_XML_END_ELEMENT_FAILED);
2452                         }
2453
2454                         /* End element "isnsObject". */
2455                         if (xmlTextWriterEndElement(writer) < 0) {
2456                             return (ERROR_XML_END_ELEMENT_FAILED);
2457                         }
2458                     }
2459                     break;
2460             case (DiscoveryDomainSet):
2461                     for (i = 0; i < operandLen; i++) {
2462                         /* Start element "isnsObject". */
2463                         if (xmlTextWriterStartElement(writer,
2464                             (xmlChar *)ISNSOBJECT) < 0) {
2465                             return (ERROR_XML_START_ELEMENT_FAILED);
2466                         }
2467
2468                         if (xmlTextWriterStartElement(writer,
2469                             (xmlChar *)DDSETOBJECT) < 0) {
2470                             return (ERROR_XML_START_ELEMENT_FAILED);
2471                         }
2472
2473                         /* Start attr "name". */
2474                         if (xmlTextWriterWriteAttribute(writer,
2475                             (xmlChar *)NAMEATTR, (xmlChar *)operand[i]) < 0) {
2476                             return (ERROR_XML_WRITE_ATTRIBUTE_FAILED);
2477                         }
2478
2479                         /* End element "DiscoveryDomain". */
2480                         if (xmlTextWriterEndElement(writer) < 0) {
2481                             return (ERROR_XML_END_ELEMENT_FAILED);
2482                         }
2483
2484                         /* End element "isnsObject". */
2485                         if (xmlTextWriterEndElement(writer) < 0) {
2486                             return (ERROR_XML_END_ELEMENT_FAILED);
2487                         }
2488                     }
2489                     break;
2490             case (ServerConfig):
2491                 if (xmlTextWriterStartElement(writer,
2492                     (xmlChar *)ISNSSERVER) < 0) {
2493                     return (ERROR_XML_START_ELEMENT_FAILED);
2494                 }
2495                 if (xmlTextWriterEndElement(writer) < 0) {
2496                     return (ERROR_XML_END_ELEMENT_FAILED);
2497                 }
2498                 break;
2499             default:
2500             return (UNKNOWN);
2501         }
2502
2503         /* End element "get". */
2504         if (xmlTextWriterEndElement(writer) < 0) {
2505             return (ERROR_XML_END_ELEMENT_FAILED);
2506         }
2507         /* End element "isnsRequest". */
2508         if (xmlTextWriterEndElement(writer) < 0) {
2509             return (ERROR_XML_END_ELEMENT_FAILED);
2510         }
2511         if (xmlTextWriterEndDocument(writer) < 0) {
2512             return (ERROR_XML_END_DOC_FAILED);
2513         }
2514
2515         xmlFreeTextWriter(writer);
2516
2517         len = xmlStrlen(xbuf->content) + 1;
2518         /* XXX - copy NULL at the end by having one more extra byte */
2519         if ((*doc = xmlStrndup(xbuf->content, len)) == NULL) {
2520             return (ERROR_XML_STRDUP_FAILED);
2521         }
2522
2523         xmlBufferFree(xbuf);
2524         return (0);
2525 }
2526
2527 /*
2528  * ****************************************************************************
2529  *
2530  * list_node_func -
2531  *      isnsadm list-node [options] [<node name>, ...]
2532  *
2533  * operandLen   - number of operands user passed into the cli
2534  * operand      - pointer to operand list from user
2535  * options      - pointer to option list from user
2536  *
2537  * ****************************************************************************
2538  */
2539 /*ARGSUSED*/
2540 static int
2541 list_node_func(int operandLen, char *operand[], cmdOptions_t *options,
2542         void *addarg)
2543 {
2544
2545         cmdOptions_t *optionList = options;
2546         xmlChar *doc, *e_doc;
2547         int ret;
2548         door_arg_t              darg;
2549         int                     fd, flag = 0;
2550
2551         for (; optionList->optval; optionList++) {
2552             switch (optionList->optval) {
2553                 case 'i':
2554                     flag |= INITIATOR_ONLY;
2555                     break;
2556                 case 't':
2557                     flag |= TARGET_ONLY;
2558                     break;
2559                 case 'v':
2560                     flag |= VERBOSE;
2561                     break;
2562                 default:
2563                     return (UNKNOWN);
2564             }
2565         }
2566
2567         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
2568             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
2569             return (ret);
2570         }
2571
2572         /* No operand specified. Issue enumerate. */
2573         if (operandLen == 0) {
2574             ret = build_enumerate_xml_doc(Node, &doc);
2575             if (ret != 0) {
2576                 (void) close(fd);
2577                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2578                 return (ret);
2579             }
2580             bzero(&darg, sizeof (darg));
2581             darg.data_ptr = (char *)doc;
2582             darg.data_size = xmlStrlen(doc) + 1;
2583             darg.rbuf = NULL;
2584             darg.rsize = 0;
2585
2586             if ((flag & VERBOSE) == VERBOSE) {
2587                 if ((door_call(fd, &darg)) == -1) {
2588                     ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2589                     (void) close(fd);
2590                     (void) xmlFree(doc);
2591                     return (ret);
2592                 }
2593
2594                 if ((ret = cvt_enumerate_rsp_to_get_req((xmlChar *)darg.rbuf,
2595                     &e_doc, Node, flag)) != 0) {
2596                     (void) munmap(darg.rbuf, darg.rsize);
2597                     (void) close(fd);
2598                     (void) xmlFree(doc);
2599                     if (ret != SUCCESS_WITH_NO_OBJECT) {
2600                         (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2601                     } else {
2602                         ret = SUBCOMMAND_SUCCESS;
2603                     }
2604                     return (ret);
2605                 } else {
2606                     (void) munmap(darg.rbuf, darg.rsize);
2607                     (void) xmlFree(doc);
2608                     doc = e_doc;
2609                     bzero(&darg, sizeof (door_arg_t));
2610                     darg.data_ptr = (char *)doc;
2611                     darg.data_size = xmlStrlen(doc) + 1;
2612                     darg.rbuf = NULL;
2613                     darg.rsize = 0;
2614                 }
2615             }
2616         } else {
2617             if ((ret = build_get_xml_doc(operandLen, operand, Node, &doc)) ==
2618                 0) {
2619                 bzero(&darg, sizeof (darg));
2620                 darg.data_ptr = (char *)doc;
2621                 darg.data_size = xmlStrlen(doc) + 1;
2622                 darg.rbuf = NULL;
2623                 darg.rsize = 0;
2624             } else {
2625                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2626                 (void) close(fd);
2627                 (void) xmlFree(doc);
2628                 return (ret);
2629             }
2630         }
2631
2632         if ((door_call(fd, &darg)) == -1) {
2633             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2634             (void) close(fd);
2635             (void) xmlFree(doc);
2636             return (ret);
2637         }
2638
2639         if ((ret = process_get_response(Node, (xmlChar *)darg.rbuf, flag)) !=
2640             0) {
2641         /*
2642          * door frame work allocated a buffer when the date lager that rbuf.
2643          * indicate if munmap is required on rbuf.
2644          */
2645             (void) munmap(darg.rbuf, darg.rsize);
2646             (void) xmlFree(doc);
2647             (void) close(fd);
2648             return (ret);
2649         }
2650
2651         (void) munmap(darg.rbuf, darg.rsize);
2652         (void) close(fd);
2653         xmlFree(doc);
2654
2655         return (SUBCOMMAND_SUCCESS);
2656 }
2657
2658 /*
2659  * ****************************************************************************
2660  *
2661  * list_dd_func -
2662  *      isnsadm list-dd [options] [<dd name>, ...]
2663  *
2664  * operandLen   - number of operands user passed into the cli
2665  * operand      - pointer to operand list from user
2666  * options      - pointer to option list from user
2667  *
2668  * ****************************************************************************
2669  */
2670 /*ARGSUSED*/
2671 static int
2672 list_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
2673         void *addarg)
2674 {
2675         cmdOptions_t *optionList = options;
2676         xmlChar *doc, *e_doc;
2677         int ret;
2678         door_arg_t              darg;
2679         int                     fd, flag = 0;
2680
2681         for (; optionList->optval; optionList++) {
2682             switch (optionList->optval) {
2683                 case 'v':
2684                     flag |= VERBOSE;
2685                     break;
2686             }
2687         }
2688
2689         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
2690             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
2691             return (ret);
2692         }
2693
2694         /* No operand specified. Issue enumerate. */
2695         if (operandLen == 0) {
2696             ret = build_enumerate_xml_doc(DiscoveryDomain, &doc);
2697             if (ret != 0) {
2698                 (void) close(fd);
2699                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2700                 return (ret);
2701             }
2702             /* get the enumerate resposne first. */
2703             bzero(&darg, sizeof (darg));
2704             darg.data_ptr = (char *)doc;
2705             darg.data_size = xmlStrlen(doc) + 1;
2706             darg.rbuf = NULL;
2707             darg.rsize = 0;
2708             if ((door_call(fd, &darg)) == -1) {
2709                 ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2710                 (void) close(fd);
2711                 (void) xmlFree(doc);
2712                 return (ret);
2713             }
2714             if ((ret = cvt_enumerate_rsp_to_get_req((xmlChar *)darg.rbuf,
2715                 &e_doc, DiscoveryDomain, flag)) != 0) {
2716                 (void) munmap(darg.rbuf, darg.rsize);
2717                 (void) close(fd);
2718                 (void) xmlFree(doc);
2719                 if (ret != SUCCESS_WITH_NO_OBJECT) {
2720                     (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2721                 } else {
2722                     ret = SUBCOMMAND_SUCCESS;
2723                 }
2724                 return (ret);
2725             } else {
2726                 (void) munmap(darg.rbuf, darg.rsize);
2727                 (void) xmlFree(doc);
2728                 doc = e_doc;
2729             }
2730         } else {
2731             if ((ret = build_get_xml_doc(operandLen, operand,
2732                 DiscoveryDomain, &doc)) != 0) {
2733                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2734                 (void) close(fd);
2735                 (void) xmlFree(doc);
2736                 return (ret);
2737             }
2738         }
2739
2740         bzero(&darg, sizeof (darg));
2741         darg.data_ptr = (char *)doc;
2742         darg.data_size = xmlStrlen(doc) + 1;
2743         darg.rbuf = NULL;
2744         darg.rsize = 0;
2745
2746         if ((door_call(fd, &darg)) == -1) {
2747             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2748             (void) close(fd);
2749             (void) xmlFree(doc);
2750             return (ret);
2751         }
2752
2753         if ((ret = process_get_response(DiscoveryDomain, (xmlChar *)darg.rbuf,
2754             flag)) != 0) {
2755             (void) munmap(darg.rbuf, darg.rsize);
2756             (void) close(fd);
2757             (void) xmlFree(doc);
2758             return (ret);
2759         }
2760
2761         (void) munmap(darg.rbuf, darg.rsize);
2762
2763         (void) close(fd);
2764         xmlFree(doc);
2765
2766         return (SUBCOMMAND_SUCCESS);
2767 }
2768
2769 /*
2770  * ****************************************************************************
2771  *
2772  * list_ddset_func -
2773  *      isnsadm list-dd-set [options] [<dd set name>, ...]
2774  *
2775  * operandLen   - number of operands user passed into the cli
2776  * operand      - pointer to operand list from user
2777  * options      - pointer to option list from user
2778  *
2779  * ****************************************************************************
2780  */
2781 /*ARGSUSED*/
2782 static int
2783 list_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
2784         void *addarg)
2785 {
2786         cmdOptions_t *optionList = options;
2787         xmlChar *doc, *e_doc;
2788         msg_code_t ret;
2789         door_arg_t              darg;
2790         int                     fd, flag = 0;
2791
2792         for (; optionList->optval; optionList++) {
2793             switch (optionList->optval) {
2794                 case 'v':
2795                     flag |= VERBOSE;
2796                     break;
2797             }
2798         }
2799
2800         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
2801             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
2802             return (ret);
2803         }
2804
2805         /* No operand specified. Issue enumerate. */
2806         if (operandLen == 0) {
2807             ret = build_enumerate_xml_doc(DiscoveryDomainSet, &doc);
2808             if (ret != 0) {
2809                 (void) close(fd);
2810                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2811                 return (ret);
2812             }
2813             /* get the enumerate resposne. */
2814             bzero(&darg, sizeof (darg));
2815             darg.data_ptr = (char *)doc;
2816             darg.data_size = xmlStrlen(doc) + 1;
2817             darg.rbuf = NULL;
2818             darg.rsize = 0;
2819             if ((door_call(fd, &darg)) == -1) {
2820                 ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2821                 (void) close(fd);
2822                 (void) xmlFree(doc);
2823                 return (ret);
2824             }
2825
2826             if ((ret = cvt_enumerate_rsp_to_get_req((xmlChar *)darg.rbuf,
2827                 &e_doc, DiscoveryDomainSet, flag)) != 0) {
2828                 (void) munmap(darg.rbuf, darg.rsize);
2829                 (void) close(fd);
2830                 (void) xmlFree(doc);
2831                 if (ret != SUCCESS_WITH_NO_OBJECT) {
2832                     (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2833                 } else {
2834                     ret = SUBCOMMAND_SUCCESS;
2835                 }
2836                 return (ret);
2837             } else {
2838                 (void) munmap(darg.rbuf, darg.rsize);
2839                 (void) xmlFree(doc);
2840                 doc = e_doc;
2841                 bzero(&darg, sizeof (darg));
2842                 darg.data_ptr = (char *)doc;
2843                 darg.data_size = xmlStrlen(doc) + 1;
2844                 darg.rbuf = NULL;
2845                 darg.rsize = 0;
2846             }
2847         } else {
2848             if ((ret = build_get_xml_doc(operandLen, operand,
2849                 DiscoveryDomainSet, &doc)) == 0) {
2850                 bzero(&darg, sizeof (darg));
2851                 darg.data_ptr = (char *)doc;
2852                 darg.data_size = xmlStrlen(doc) + 1;
2853                 darg.rbuf = NULL;
2854                 darg.rsize = 0;
2855             } else {
2856                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2857             }
2858         }
2859
2860         if ((door_call(fd, &darg)) == -1) {
2861             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2862             (void) close(fd);
2863             (void) xmlFree(doc);
2864             return (ret);
2865         }
2866
2867         /*
2868          * door frame work allocated a buffer when the date lager that rbuf.
2869          * indicate if munmap is required on rbuf.
2870          */
2871         if ((ret = process_get_response(DiscoveryDomainSet,
2872             (xmlChar *)darg.rbuf, flag)) != 0) {
2873             (void) munmap(darg.rbuf, darg.rsize);
2874             (void) close(fd);
2875             (void) xmlFree(doc);
2876             return (ret);
2877         }
2878
2879         (void) munmap(darg.rbuf, darg.rsize);
2880         (void) close(fd);
2881         (void) xmlFree(doc);
2882
2883         return (SUBCOMMAND_SUCCESS);
2884 }
2885
2886 /*
2887  * ****************************************************************************
2888  *
2889  * create_dd_func -
2890  *      create a DiscoveryDomain create-dd <dd name>, ...
2891  *
2892  * operandLen   - number of operands user passed into the cli
2893  * operand      - pointer to operand list from user
2894  * options      - pointer to option list from user
2895  *
2896  * ****************************************************************************
2897  */
2898 /*ARGSUSED*/
2899 static int
2900 create_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
2901         void *addarg)
2902 {
2903         xmlChar *doc;
2904         msg_code_t ret;
2905         door_arg_t              darg;
2906         int                     fd;
2907
2908         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
2909             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
2910             return (ret);
2911         }
2912
2913         if ((ret = build_create_xml_doc(operandLen, operand,
2914                 DiscoveryDomain, NULL, &doc)) == 0) {
2915                 bzero(&darg, sizeof (darg));
2916                 darg.data_ptr = (char *)doc;
2917                 darg.data_size = xmlStrlen(doc) + 1;
2918                 darg.rbuf = NULL;
2919                 darg.rsize = 0;
2920         } else {
2921                 (void) close(fd);
2922                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2923                 return (ret);
2924         }
2925
2926         if ((door_call(fd, &darg)) == -1) {
2927             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2928             (void) close(fd);
2929             (void) xmlFree(doc);
2930             return (ret);
2931         }
2932
2933         /*
2934          * door frame work allocated a buffer when the date lager that rbuf.
2935          * indicate if munmap is required on rbuf.
2936          */
2937         if ((ret = process_result_response((xmlChar *)darg.rbuf,
2938                 DiscoveryDomain)) != 0) {
2939             (void) munmap(darg.rbuf, darg.rsize);
2940             (void) close(fd);
2941             (void) xmlFree(doc);
2942             return (ret);
2943         }
2944
2945         (void) munmap(darg.rbuf, darg.rsize);
2946         (void) close(fd);
2947         xmlFree(doc);
2948
2949         return (SUBCOMMAND_SUCCESS);
2950 }
2951
2952 /*
2953  * ****************************************************************************
2954  *
2955  * create_ddset_func -
2956  *      create a DiscoveryDomainSet create-dd-set <dd set name>, ...
2957  *
2958  * operandLen   - number of operands user passed into the cli
2959  * operand      - pointer to operand list from user
2960  * options      - pointer to option list from user
2961  *
2962  * ****************************************************************************
2963  */
2964 /*ARGSUSED*/
2965 static int
2966 create_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
2967     void *addarg)
2968 {
2969         xmlChar *doc;
2970         msg_code_t ret;
2971         door_arg_t              darg;
2972         int                     fd;
2973
2974         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
2975             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
2976             return (ret);
2977         }
2978
2979         if ((ret = build_create_xml_doc(operandLen, operand,
2980                 DiscoveryDomainSet, NULL, &doc)) == 0) {
2981                 bzero(&darg, sizeof (darg));
2982                 darg.data_ptr = (char *)doc;
2983                 darg.data_size = xmlStrlen(doc) + 1;
2984                 darg.rbuf = NULL;
2985                 darg.rsize = 0;
2986         } else {
2987                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
2988                 (void) close(fd);
2989                 return (ret);
2990         }
2991
2992         if ((door_call(fd, &darg)) == -1) {
2993             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
2994             (void) close(fd);
2995             (void) xmlFree(doc);
2996             return (ret);
2997         }
2998
2999         /*
3000          * door frame work allocated a buffer when the date lager that rbuf.
3001          * indicate if munmap is required on rbuf.
3002          */
3003         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3004                 DiscoveryDomainSet)) != 0) {
3005             (void) munmap(darg.rbuf, darg.rsize);
3006             (void) close(fd);
3007             (void) xmlFree(doc);
3008             return (ret);
3009         }
3010
3011         (void) munmap(darg.rbuf, darg.rsize);
3012
3013         (void) close(fd);
3014         xmlFree(doc);
3015
3016         return (SUBCOMMAND_SUCCESS);
3017 }
3018
3019 /*
3020  * ****************************************************************************
3021  *
3022  * modify_dd_func -
3023  *      Modify a dd attr. currently rename function is supported
3024  *      modify-dd -n name <dd name>
3025  *
3026  * operandLen   - number of operands user passed into the cli
3027  * operand      - pointer to operand list from user
3028  * options      - pointer to option list from user
3029  *
3030  * ****************************************************************************
3031  */
3032 /*ARGSUSED*/
3033 static int
3034 modify_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
3035         void *addarg)
3036 {
3037         xmlChar *doc;
3038         xmlTextReaderPtr reader;
3039         msg_code_t ret;
3040         door_arg_t      darg;
3041         int     fd, m_flag = 0;
3042         uint32_t    id;
3043
3044         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3045             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3046             return (ret);
3047         }
3048
3049         if ((ret = build_get_xml_doc(operandLen, operand,
3050                 DiscoveryDomain, &doc)) == 0) {
3051                 bzero(&darg, sizeof (darg));
3052                 darg.data_ptr = (char *)doc;
3053                 darg.data_size = xmlStrlen(doc) + 1;
3054                 darg.rbuf = NULL;
3055                 darg.rsize = 0;
3056         } else {
3057                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3058                 (void) close(fd);
3059                 return (ret);
3060         }
3061
3062         if ((door_call(fd, &darg)) == -1) {
3063             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3064             (void) close(fd);
3065             (void) xmlFree(doc);
3066             return (ret);
3067         }
3068
3069         /* Free the request that is created by xmlStrnDup. */
3070         (void) xmlFree(doc);
3071
3072         /*
3073          * door frame work allocated a buffer when the date lager that rbuf.
3074          * indicate if munmap is required on rbuf.
3075          */
3076         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3077                 DiscoveryDomain)) != 0) {
3078             (void) munmap(darg.rbuf, darg.rsize);
3079             (void) close(fd);
3080             return (ret);
3081         }
3082
3083         /* setup xml parser on the response. */
3084         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory
3085             ((const char *)darg.rbuf, xmlStrlen((xmlChar *)darg.rbuf),
3086             NULL, NULL, 0)) == NULL) {
3087             (void) munmap(darg.rbuf, darg.rsize);
3088             (void) close(fd);
3089             return (ERROR_XML_READER_NULL);
3090         }
3091
3092         if (reader = lookup_next_matching_elem(reader, &m_flag, DDOBJECT,
3093             ISNSRESPONSE)) {
3094             if (m_flag == READER_MATCH) {
3095                 if ((xmlTextReaderMoveToAttribute(reader,
3096                         (const xmlChar *)IDATTR)) == 1) {
3097                     id = atoi((const char *)xmlTextReaderConstValue(reader));
3098                 } else {
3099                         (void) xmlTextReaderClose(reader);
3100                         (void) xmlFreeTextReader(reader);
3101                         return (ERROR_XML_ID_ATTR_NOT_FOUND);
3102                 }
3103             } else {
3104                 (void) xmlTextReaderClose(reader);
3105                 (void) xmlFreeTextReader(reader);
3106                 return (ERROR_XML_DD_OBJECT_NOT_FOUND);
3107             }
3108         } else {
3109             (void) fprintf(stderr, "%s\n",
3110                 getTextMessage(ERROR_XML_READER_NULL));
3111             return (ERROR_XML_READER_NULL);
3112         }
3113
3114         (void) xmlTextReaderClose(reader);
3115         (void) xmlFreeTextReader(reader);
3116
3117         if ((ret = build_rename_xml_doc(options->optarg, DiscoveryDomain,
3118                 id, &doc)) == 0) {
3119                 bzero(&darg, sizeof (darg));
3120                 darg.data_ptr = (char *)doc;
3121                 darg.data_size = xmlStrlen(doc) + 1;
3122                 darg.rbuf = NULL;
3123                 darg.rsize = 0;
3124         } else {
3125                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3126                 (void) close(fd);
3127                 return (ret);
3128         }
3129
3130         if ((door_call(fd, &darg)) == -1) {
3131             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3132             (void) close(fd);
3133             (void) xmlFree(doc);
3134             return (ret);
3135         }
3136
3137         /*
3138          * door frame work allocated a buffer when the date lager that rbuf.
3139          * indicate if munmap is required on rbuf.
3140          */
3141         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3142                 DiscoveryDomain)) != 0) {
3143             (void) munmap(darg.rbuf, darg.rsize);
3144             (void) close(fd);
3145             (void) xmlFree(doc);
3146             return (ret);
3147         }
3148
3149         (void) munmap(darg.rbuf, darg.rsize);
3150         (void) close(fd);
3151         xmlFree(doc);
3152
3153         return (SUBCOMMAND_SUCCESS);
3154 }
3155
3156 /*
3157  * ****************************************************************************
3158  *
3159  * modify_ddset_func -
3160  *      Modify a dd attr. currently rename function is supported
3161  *      modify-dd-set -n name <dd name>
3162  *
3163  * operandLen   - number of operands user passed into the cli
3164  * operand      - pointer to operand list from user
3165  * options      - pointer to option list from user
3166  *
3167  * ****************************************************************************
3168  */
3169 /*ARGSUSED*/
3170 static int
3171 modify_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
3172         void *addarg)
3173 {
3174         xmlChar *doc;
3175         xmlTextReaderPtr reader;
3176         msg_code_t ret;
3177         door_arg_t      darg;
3178         int     fd, m_flag = 0;
3179         uint32_t    id;
3180
3181         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3182             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3183             return (ret);
3184         }
3185
3186         if ((ret = build_get_xml_doc(operandLen, operand,
3187                 DiscoveryDomainSet, &doc)) == 0) {
3188                 bzero(&darg, sizeof (darg));
3189                 darg.data_ptr = (char *)doc;
3190                 darg.data_size = xmlStrlen(doc) + 1;
3191                 darg.rbuf = NULL;
3192                 darg.rsize = 0;
3193         } else {
3194                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3195                 (void) close(fd);
3196                 return (ret);
3197         }
3198
3199         if ((door_call(fd, &darg)) == -1) {
3200             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3201             (void) close(fd);
3202             (void) xmlFree(doc);
3203             return (ret);
3204         }
3205
3206         /* Free the request that is created by xmlStrnDup. */
3207         (void) xmlFree(doc);
3208
3209         /*
3210          * door frame work allocated a buffer when the date lager that rbuf.
3211          * indicate if munmap is required on rbuf.
3212          */
3213         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3214                 DiscoveryDomainSet)) != 0) {
3215             (void) munmap(darg.rbuf, darg.rsize);
3216             (void) close(fd);
3217             return (ret);
3218         }
3219
3220         /* setup xml parser on the response. */
3221         if ((reader = (xmlTextReaderPtr)xmlReaderForMemory
3222             ((const char *)darg.rbuf, xmlStrlen((xmlChar *)darg.rbuf),
3223             NULL, NULL, 0)) == NULL) {
3224             (void) munmap(darg.rbuf, darg.rsize);
3225             (void) close(fd);
3226             return (ERROR_XML_READER_NULL);
3227         }
3228
3229         if (reader = lookup_next_matching_elem(reader, &m_flag, DDSETOBJECT,
3230             ISNSRESPONSE)) {
3231             if (m_flag == READER_MATCH) {
3232                 if ((xmlTextReaderMoveToAttribute(reader,
3233                         (const xmlChar *)IDATTR)) == 1) {
3234                     id = atoi((const char *)xmlTextReaderConstValue(reader));
3235                 } else {
3236                         (void) xmlTextReaderClose(reader);
3237                         (void) xmlFreeTextReader(reader);
3238                         return (ERROR_XML_ID_ATTR_NOT_FOUND);
3239                 }
3240             } else {
3241                 (void) xmlTextReaderClose(reader);
3242                 (void) xmlFreeTextReader(reader);
3243                 (void) fprintf(stderr, "%s\n",
3244                     getTextMessage(ERROR_XML_NAME_ATTR_NOT_FOUND));
3245                 return (ERROR_XML_DD_SET_OBJECT_NOT_FOUND);
3246             }
3247         }
3248
3249         (void) xmlTextReaderClose(reader);
3250         (void) xmlFreeTextReader(reader);
3251
3252         if ((ret = build_rename_xml_doc(options->optarg, DiscoveryDomainSet,
3253                 id, &doc)) == 0) {
3254                 bzero(&darg, sizeof (darg));
3255                 darg.data_ptr = (char *)doc;
3256                 darg.data_size = xmlStrlen(doc) + 1;
3257                 darg.rbuf = NULL;
3258                 darg.rsize = 0;
3259         } else {
3260                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3261                 (void) close(fd);
3262                 return (ret);
3263         }
3264
3265         if ((door_call(fd, &darg)) == -1) {
3266             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3267             (void) close(fd);
3268             (void) xmlFree(doc);
3269             return (ret);
3270         }
3271
3272         /*
3273          * door frame work allocated a buffer when the date lager that rbuf.
3274          * indicate if munmap is required on rbuf.
3275          */
3276         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3277                 DiscoveryDomainSet)) != 0) {
3278             (void) munmap(darg.rbuf, darg.rsize);
3279             (void) close(fd);
3280             (void) xmlFree(doc);
3281             return (ret);
3282         }
3283
3284         (void) munmap(darg.rbuf, darg.rsize);
3285         (void) close(fd);
3286         xmlFree(doc);
3287
3288         return (SUBCOMMAND_SUCCESS);
3289 }
3290
3291 /*
3292  * ****************************************************************************
3293  *
3294  * add_node_func -
3295  *      Add a node to a DiscoveryDomain add-node -d dd-name <node name>, ...
3296  *
3297  * operandLen   - number of operands user passed into the cli
3298  * operand      - pointer to operand list from user
3299  * options      - pointer to option list from user
3300  *
3301  * ****************************************************************************
3302  */
3303 /*ARGSUSED*/
3304 static int
3305 add_node_func(int operandLen, char *operand[], cmdOptions_t *options,
3306         void *addarg)
3307 {
3308         xmlChar *doc;
3309         msg_code_t ret;
3310         door_arg_t      darg;
3311         int     fd;
3312
3313         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3314             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3315             return (ret);
3316         }
3317
3318         if ((ret = build_create_xml_doc(operandLen, operand,
3319                 DiscoveryDomainMember, options->optarg, &doc)) == 0) {
3320                 bzero(&darg, sizeof (darg));
3321                 darg.data_ptr = (char *)doc;
3322                 darg.data_size = xmlStrlen(doc) + 1;
3323                 darg.rbuf = NULL;
3324                 darg.rsize = 0;
3325         } else {
3326                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3327                 (void) close(fd);
3328                 return (ret);
3329         }
3330
3331         if ((door_call(fd, &darg)) == -1) {
3332             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3333             (void) close(fd);
3334             (void) xmlFree(doc);
3335             return (ret);
3336         }
3337
3338         /*
3339          * door frame work allocated a buffer when the date lager that rbuf.
3340          * indicate if munmap is required on rbuf.
3341          */
3342         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3343                 DiscoveryDomainMember)) != 0) {
3344             (void) munmap(darg.rbuf, darg.rsize);
3345             (void) close(fd);
3346             (void) xmlFree(doc);
3347             return (ret);
3348         }
3349
3350         (void) munmap(darg.rbuf, darg.rsize);
3351         (void) close(fd);
3352         xmlFree(doc);
3353
3354         return (SUBCOMMAND_SUCCESS);
3355 }
3356
3357 /*
3358  * ****************************************************************************
3359  *
3360  * add_dd_func -
3361  *      Add a dd to a DiscoveryDomainSet add-dd -s dd-set name <dd name>, ...
3362  *
3363  * operandLen   - number of operands user passed into the cli
3364  * operand      - pointer to operand list from user
3365  * options      - pointer to option list from user
3366  *
3367  * ****************************************************************************
3368  */
3369 /*ARGSUSED*/
3370 static int
3371 add_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
3372         void *addarg)
3373 {
3374         xmlChar *doc;
3375         msg_code_t ret;
3376         door_arg_t      darg;
3377         int     fd;
3378
3379         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3380             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3381             return (ret);
3382         }
3383
3384         if ((ret = build_create_xml_doc(operandLen, operand,
3385                 DiscoveryDomainSetMember, options->optarg, &doc)) == 0) {
3386                 bzero(&darg, sizeof (darg));
3387                 darg.data_ptr = (char *)doc;
3388                 darg.data_size = xmlStrlen(doc) + 1;
3389                 darg.rbuf = NULL;
3390                 darg.rsize = 0;
3391         } else {
3392                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3393                 (void) close(fd);
3394                 return (ret);
3395         }
3396
3397         if ((door_call(fd, &darg)) == -1) {
3398             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3399             (void) close(fd);
3400             (void) xmlFree(doc);
3401             return (ret);
3402         }
3403
3404         /*
3405          * door frame work allocated a buffer when the date lager that rbuf.
3406          * indicate if munmap is required on rbuf.
3407          */
3408         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3409                 DiscoveryDomainSetMember)) != 0) {
3410             (void) munmap(darg.rbuf, darg.rsize);
3411             (void) close(fd);
3412             (void) xmlFree(doc);
3413             return (ret);
3414         }
3415
3416         (void) munmap(darg.rbuf, darg.rsize);
3417         (void) close(fd);
3418         xmlFree(doc);
3419
3420         return (SUBCOMMAND_SUCCESS);
3421 }
3422
3423 /*
3424  * ****************************************************************************
3425  *
3426  * remove_node_func -
3427  *      Remove a node from DiscoveryDomain
3428  *      remov-node -d dd-name <node name>, ...
3429  *
3430  * operandLen   - number of operands user passed into the cli
3431  * operand      - pointer to operand list from user
3432  * options      - pointer to option list from user
3433  *
3434  * ****************************************************************************
3435  */
3436 /*ARGSUSED*/
3437 static int
3438 remove_node_func(int operandLen, char *operand[], cmdOptions_t *options,
3439         void *addarg)
3440 {
3441         xmlChar *doc;
3442         msg_code_t ret;
3443         door_arg_t      darg;
3444         int     fd;
3445
3446         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3447             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3448             return (ret);
3449         }
3450
3451         if ((ret = build_delete_xml_doc(operandLen, operand,
3452                 DiscoveryDomainMember, options->optarg, &doc)) == 0) {
3453                 bzero(&darg, sizeof (darg));
3454                 darg.data_ptr = (char *)doc;
3455                 darg.data_size = xmlStrlen(doc) + 1;
3456                 darg.rbuf = NULL;
3457                 darg.rsize = 0;
3458         } else {
3459                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3460                 (void) close(fd);
3461                 return (ret);
3462         }
3463
3464         if ((door_call(fd, &darg)) == -1) {
3465             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3466             (void) close(fd);
3467             (void) xmlFree(doc);
3468             return (ret);
3469         }
3470
3471         /*
3472          * door frame work allocated a buffer when the date lager that rbuf.
3473          * indicate if munmap is required on rbuf.
3474          */
3475         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3476                 DiscoveryDomainMember)) != 0) {
3477             (void) munmap(darg.rbuf, darg.rsize);
3478             (void) close(fd);
3479             (void) xmlFree(doc);
3480             return (ret);
3481         }
3482
3483         (void) munmap(darg.rbuf, darg.rsize);
3484         (void) close(fd);
3485         xmlFree(doc);
3486
3487         return (SUBCOMMAND_SUCCESS);
3488 }
3489
3490 /*
3491  * ****************************************************************************
3492  *
3493  * remove_dd_func -
3494  *      Remove a dd from DiscoveryDomainSet
3495  *      remove-dd -s dd-set name <dd name>, ...
3496  *
3497  * operandLen   - number of operands user passed into the cli
3498  * operand      - pointer to operand list from user
3499  * options      - pointer to option list from user
3500  *
3501  * ****************************************************************************
3502  */
3503 /*ARGSUSED*/
3504 static int
3505 remove_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
3506         void *addarg)
3507 {
3508         xmlChar *doc;
3509         msg_code_t ret;
3510         door_arg_t      darg;
3511         int     fd;
3512
3513         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3514             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3515             return (ret);
3516         }
3517
3518         if ((ret = build_delete_xml_doc(operandLen, operand,
3519                 DiscoveryDomainSetMember, options->optarg, &doc)) == 0) {
3520                 bzero(&darg, sizeof (darg));
3521                 darg.data_ptr = (char *)doc;
3522                 darg.data_size = xmlStrlen(doc) + 1;
3523                 darg.rbuf = NULL;
3524                 darg.rsize = 0;
3525         } else {
3526                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3527                 (void) close(fd);
3528                 return (ret);
3529         }
3530
3531         if ((door_call(fd, &darg)) == -1) {
3532             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3533             (void) close(fd);
3534             (void) xmlFree(doc);
3535             return (ret);
3536         }
3537
3538         /*
3539          * door frame work allocated a buffer when the date lager that rbuf.
3540          * indicate if munmap is required on rbuf.
3541          */
3542         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3543                 DiscoveryDomainSetMember)) != 0) {
3544             (void) munmap(darg.rbuf, darg.rsize);
3545             (void) close(fd);
3546             (void) xmlFree(doc);
3547             return (ret);
3548         }
3549
3550         (void) munmap(darg.rbuf, darg.rsize);
3551         (void) close(fd);
3552         xmlFree(doc);
3553
3554         return (SUBCOMMAND_SUCCESS);
3555 }
3556
3557 /*
3558  * ****************************************************************************
3559  *
3560  * delete_dd_func -
3561  *      remove a DiscoveryDomain remove-dd <dd name>, ...
3562  *
3563  * operandLen   - number of operands user passed into the cli
3564  * operand      - pointer to operand list from user
3565  * options      - pointer to option list from user
3566  *
3567  * ****************************************************************************
3568  */
3569 /*ARGSUSED*/
3570 static int
3571 delete_dd_func(int operandLen, char *operand[], cmdOptions_t *options,
3572         void *addarg)
3573 {
3574         xmlChar *doc;
3575         msg_code_t ret;
3576         door_arg_t              darg;
3577         int                     fd;
3578
3579         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3580             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3581             return (ret);
3582         }
3583
3584         if ((ret = build_delete_xml_doc(operandLen, operand,
3585                 DiscoveryDomain, NULL, &doc)) == 0) {
3586                 bzero(&darg, sizeof (darg));
3587                 darg.data_ptr = (char *)doc;
3588                 darg.data_size = xmlStrlen(doc) + 1;
3589                 darg.rbuf = NULL;
3590                 darg.rsize = 0;
3591         } else {
3592                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3593                 (void) close(fd);
3594                 return (ret);
3595         }
3596
3597         if ((door_call(fd, &darg)) == -1) {
3598             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3599             (void) close(fd);
3600             (void) xmlFree(doc);
3601             return (ret);
3602         }
3603
3604         /*
3605          * door frame work allocated a buffer when the date lager that rbuf.
3606          * indicate if munmap is required on rbuf.
3607          */
3608         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3609                 DiscoveryDomain)) != 0) {
3610             (void) munmap(darg.rbuf, darg.rsize);
3611             (void) close(fd);
3612             (void) xmlFree(doc);
3613             return (ret);
3614         }
3615
3616         (void) munmap(darg.rbuf, darg.rsize);
3617
3618         (void) close(fd);
3619         xmlFree(doc);
3620
3621         return (SUBCOMMAND_SUCCESS);
3622 }
3623
3624 /*
3625  * ****************************************************************************
3626  *
3627  * delete_ddset_func -
3628  *      delete DiscoveryDomainSet(s) delete-dd-set <dd set name>, ...
3629  *
3630  * operandLen   - number of operands user passed into the cli
3631  * operand      - pointer to operand list from user
3632  * options      - pointer to option list from user
3633  *
3634  * ****************************************************************************
3635  */
3636 /*ARGSUSED*/
3637 static int
3638 delete_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
3639     void *addarg)
3640 {
3641         xmlChar *doc;
3642         msg_code_t ret;
3643         door_arg_t              darg;
3644         int                     fd;
3645
3646         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3647             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3648             return (ret);
3649         }
3650
3651         if ((ret = build_delete_xml_doc(operandLen, operand,
3652                 DiscoveryDomainSet, NULL, &doc)) == 0) {
3653                 bzero(&darg, sizeof (darg));
3654                 darg.data_ptr = (char *)doc;
3655                 darg.data_size = xmlStrlen(doc) + 1;
3656                 darg.rbuf = NULL;
3657                 darg.rsize = 0;
3658         } else {
3659                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3660                 (void) close(fd);
3661                 return (ret);
3662         }
3663
3664         if ((door_call(fd, &darg)) == -1) {
3665             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3666             (void) close(fd);
3667             (void) xmlFree(doc);
3668             return (ret);
3669         }
3670
3671         /*
3672          * door frame work allocated a buffer when the date lager that rbuf.
3673          * indicate if munmap is required on rbuf.
3674          */
3675         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3676                 DiscoveryDomainSet)) != 0) {
3677             (void) munmap(darg.rbuf, darg.rsize);
3678             (void) close(fd);
3679             (void) xmlFree(doc);
3680             return (ret);
3681         }
3682
3683         (void) munmap(darg.rbuf, darg.rsize);
3684         (void) close(fd);
3685         xmlFree(doc);
3686
3687         return (SUBCOMMAND_SUCCESS);
3688 }
3689
3690 /*
3691  * ****************************************************************************
3692  *
3693  * i_enableddset
3694  *      enables/disables DiscoveryDomainSet(s)
3695  *
3696  * operandLen   - number of operands user passed into the cli
3697  * operand      - pointer to operand list from user
3698  * enable       - indication of enable/disable
3699  *
3700  * ****************************************************************************
3701  */
3702 static int
3703 i_enableddset(int operandLen, char *operand[], boolean_t enable)
3704 {
3705         xmlChar *doc;
3706         door_arg_t              darg;
3707         int fd, ret = 0;
3708
3709         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3710             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3711             return (ret);
3712         }
3713
3714         if ((ret = build_modify_xml_doc(operandLen, operand,
3715                 DiscoveryDomainSet, enable, &doc)) == 0) {
3716                 bzero(&darg, sizeof (darg));
3717                 darg.data_ptr = (char *)doc;
3718                 darg.data_size = xmlStrlen(doc) + 1;
3719                 darg.rbuf = NULL;
3720                 darg.rsize = 0;
3721         } else {
3722                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3723                 (void) close(fd);
3724                 return (ret);
3725         }
3726
3727         if ((door_call(fd, &darg)) == -1) {
3728             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3729             (void) close(fd);
3730             (void) xmlFree(doc);
3731             return (ret);
3732         }
3733
3734         xmlFree(doc);
3735
3736         if ((ret = process_result_response((xmlChar *)darg.rbuf,
3737                 DiscoveryDomainSet)) != 0) {
3738             (void) munmap(darg.rbuf, darg.rsize);
3739             (void) close(fd);
3740             return (ret);
3741         }
3742
3743         (void) munmap(darg.rbuf, darg.rsize);
3744         (void) close(fd);
3745         return (SUBCOMMAND_SUCCESS);
3746 }
3747
3748 /*
3749  * ****************************************************************************
3750  *
3751  * enable_ddset_func -
3752  *      enables DiscoveryDomainSet(s) enable-dd-set <dd set name>, ...
3753  *
3754  * operandLen   - number of operands user passed into the cli
3755  * operand      - pointer to operand list from user
3756  * options      - pointer to option list from user
3757  *
3758  * ****************************************************************************
3759  */
3760 /*ARGSUSED*/
3761 static int
3762 enable_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
3763     void *addarg)
3764 {
3765         return (i_enableddset(operandLen, operand, B_TRUE));
3766 }
3767
3768 /*
3769  * ****************************************************************************
3770  *
3771  * disabledsetFunc -
3772  *      disable DiscoveryDomainSet(s) disable-dd-set <dd set name>, ...
3773  *
3774  * operandLen   - number of operands user passed into the cli
3775  * operand      - pointer to operand list from user
3776  * options      - pointer to option list from user
3777  *
3778  * ****************************************************************************
3779  */
3780 /*ARGSUSED*/
3781 static int
3782 disable_ddset_func(int operandLen, char *operand[], cmdOptions_t *options,
3783     void *addarg)
3784 {
3785         return (i_enableddset(operandLen, operand, B_FALSE));
3786 }
3787
3788 /*
3789  * ****************************************************************************
3790  *
3791  * show_config_func -
3792  *      isnsadm show-config
3793  *
3794  * operandLen   - number of operands user passed into the cli
3795  * operand      - pointer to operand list from user
3796  * options      - pointer to option list from user
3797  *
3798  * ****************************************************************************
3799  */
3800 /*ARGSUSED*/
3801 static int
3802 show_config_func(int operandLen, char *operand[], cmdOptions_t *options,
3803         void *addarg)
3804 {
3805         xmlChar *doc;
3806         int ret;
3807         door_arg_t              darg;
3808         int                     fd, flag = 0;
3809
3810         if ((fd = open(ISNS_DOOR_NAME, 0)) == -1) {
3811             ret = check_door_error(ERROR_DOOR_OPEN_FAILED, errno);
3812             return (ret);
3813         }
3814
3815         if ((ret = build_get_xml_doc(operandLen, operand,
3816                 ServerConfig, &doc)) == 0) {
3817                 bzero(&darg, sizeof (darg));
3818                 darg.data_ptr = (char *)doc;
3819                 darg.data_size = xmlStrlen(doc) + 1;
3820                 darg.rbuf = NULL;
3821                 darg.rsize = 0;
3822         } else {
3823                 (void) fprintf(stderr, "%s\n", getTextMessage(ret));
3824                 (void) close(fd);
3825                 (void) xmlFree(doc);
3826                 return (ret);
3827         }
3828
3829         if ((door_call(fd, &darg)) == -1) {
3830             ret = check_door_error(ERROR_DOOR_CALL_FAILED, errno);
3831             (void) close(fd);
3832             (void) xmlFree(doc);
3833             return (ret);
3834         }
3835
3836         if ((ret = process_get_response(ServerConfig, (xmlChar *)darg.rbuf,
3837             flag)) != 0) {
3838             (void) munmap(darg.rbuf, darg.rsize);
3839             (void) close(fd);
3840             (void) xmlFree(doc);
3841             return (ret);
3842         }
3843
3844         (void) munmap(darg.rbuf, darg.rsize);
3845         (void) close(fd);
3846         xmlFree(doc);
3847
3848         return (SUBCOMMAND_SUCCESS);
3849 }
3850
3851 /*
3852  * *************************************************************************
3853  *
3854  * main
3855  *
3856  * *************************************************************************
3857  */
3858 int
3859 main(int argc, char *argv[])
3860 {
3861         synTables_t                     synTables;
3862         char                            versionString[VERSION_STRING_MAX_LEN];
3863         int                             ret;
3864         int                             funcRet;
3865         void                            *subcommandArgs = NULL;
3866
3867         (void) setlocale(LC_ALL, "");
3868
3869         (void) sprintf(versionString, "%2s.%2s",
3870             VERSION_STRING_MAJOR, VERSION_STRING_MINOR);
3871         synTables.versionString = versionString;
3872         synTables.longOptionTbl = &longOptions[0];
3873         synTables.subCommandPropsTbl = &subcommands[0];
3874
3875         ret = cmdParse(argc, argv, synTables, subcommandArgs, &funcRet);
3876
3877         if (ret == 1) {
3878                 return (COMMAND_SYNTAX_FAILED);
3879         } else if (ret == -1) {
3880                 perror(argv[0]);
3881                 return (1);
3882         } else if (ret == 0) {
3883                 /*
3884                  * strawman way to sort out the error code.
3885                  * isnsi server protocol error range 0 - 99
3886                  * isns server maangement op error range 100 -199
3887                  * isnsadm error range 200 -299
3888                  */
3889             if (funcRet == SUBCOMMAND_SUCCESS) {
3890                 return (0);
3891             } else if (funcRet > SUBCOMMAND_SUCCESS) {
3892                 if (funcRet != ERROR_DOOR_CALL_FAILED &&
3893                     funcRet != ERROR_DOOR_OPEN_FAILED) {
3894                     (void) fprintf(stderr, "%s\n", getTextMessage(funcRet));
3895                 }
3896                 return (1);
3897             } else {
3898                 return (1);
3899             }
3900         }
3901
3902         return (0);
3903 } /* end main */