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