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