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