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