?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / isns / isnsd / xml / data.c
blob5887e81b45cf3e6e5bc160512a5eca8f9f9ed339
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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <libgen.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <libxml/parser.h>
40 #include <libxml/xpath.h>
41
42 #include "isns_server.h"
43 #include "isns_obj.h"
44 #include "isns_log.h"
45
46 #if LIBXML_VERSION >= 20904
47 #define XMLSTRING_CAST (const char *)
48 #else
49 #define XMLSTRING_CAST (const xmlChar *)
50 #endif
51
52 /*
53 * external variables
54 */
55 extern const int NUM_OF_ATTRS[MAX_OBJ_TYPE_FOR_SIZE];
56 extern const int TYPE_OF_PARENT[MAX_OBJ_TYPE_FOR_SIZE];
57 extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];
58
59 extern char data_store[MAXPATHLEN];
60
61 /*
62 * local variables
63 */
64 static xmlDocPtr xml_doc = NULL;
65 static char *xml_file = NULL;
66 static char *xml_tmp_file = NULL;
67 static char *xml_bak_file = NULL;
68
69 static const int OBJ_DTD_ORDER[MAX_OBJ_TYPE_FOR_SIZE] = {
70 0,
71 1, /* OBJ_ENTITY */
72 2, /* OBJ_ISCSI */
73 3, /* OBJ_PORTAL */
74 4, /* OBJ_PG */
75 5, /* OBJ_DD */
76 6, /* OBJ_DDS */
77 0, /* MAX_OBJ_TYPE */
78 0, /* OBJ_DUMMY1 */
79 0, /* OBJ_DUMMY2 */
80 0, /* OBJ_DUMMY3 */
81 0, /* OBJ_DUMMY4 */
82 12, /* OBJ_ASSOC_ISCSI */
83 14, /* OBJ_ASSOC_DD */
84 };
85
86 #define DEF_XML_ROOT(ISNS_DATA, VENDOR, SMI, VERSION, ONE_DOT_O) \
87 (xmlChar *)ISNS_DATA, \
88 (xmlChar *)VENDOR, \
89 (xmlChar *)SMI, \
90 (xmlChar *)VERSION, \
91 (xmlChar *)ONE_DOT_O
92 static const xmlChar *xml_root[] = {
93 #include "data.def"
94 };
95
96 #define DEF_XML_DATA(TAG, TYPE, ARG1, ARG2) (xmlChar *)TAG,
97 static const xmlChar* xmlTag[] = {
98 #include "data.def"
99 };
100
101 #define DEF_XML_DATA(TAG, TYPE, ARG1, ARG2) TYPE,
102 static const char *xmlType[] = {
103 #include "data.def"
104 };
105
106 #define DEF_XML_DATA(TAG, TYPE, ARG1, ARG2) ARG1,
107 static const int xmlArg1[] = {
108 #include "data.def"
109 };
110
111 #define DEF_XML_DATA(TAG, TYPE, ARG1, ARG2) ARG2,
112 static const int xmlArg2[] = {
113 #include "data.def"
114 };
115
116 #define DEF_XML_PROP(INDEX, TYPE, NAME, TAG, ID) TYPE,
117 static const unsigned char xmlPropType[] = {
118 #include "data.def"
119 };
120
121 #define DEF_XML_PROP(INDEX, TYPE, NAME, TAG, ID) (xmlChar *)NAME,
122 static const xmlChar *xmlPropName[] = {
123 #include "data.def"
124 };
125
126 #define DEF_XML_PROP(INDEX, TYPE, NAME, TAG, ID) TAG,
127 static const int xmlPropTag[] = {
128 #include "data.def"
129 };
130
131 #define DEF_XML_PROP(INDEX, TYPE, NAME, TAG, ID) ID,
132 static const int xmlPropID[] = {
133 #include "data.def"
134 };
135
136 #define ARRAY_LENGTH(ARRAY) (sizeof (ARRAY) / sizeof (ARRAY[0]))
137
138 /*
139 * ****************************************************************************
140 *
141 * get_index_by_name:
142 * find the index in the global tables for the name of an attribute.
143 *
144 * name - the name of an attribute.
145 * return - index or -1 for error.
146 *
147 * ****************************************************************************
148 */
149 static int
150 get_index_by_name(
151 const xmlChar *name
152 )
153 {
154 int i;
155 for (i = 0; i < ARRAY_LENGTH(xmlTag); i++) {
156 if (xmlStrEqual(xmlTag[i], name)) {
157 return (i);
158 }
159 }
160 return (-1);
161 }
162
163 /*
164 * ****************************************************************************
165 *
166 * get_index_by_otype:
167 * find the index in the global tables for the type of an object.
168 *
169 * name - the type of an object.
170 * return - index or -1 for error.
171 *
172 * ****************************************************************************
173 */
174 static int
175 get_index_by_otype(
176 int otype
177 )
178 {
179 int i;
180 for (i = 0; i < ARRAY_LENGTH(xmlTag); i++) {
181 if (xmlArg1[i] == otype && xmlType[i][0] == 'o') {
182 return (i);
183 }
184 }
185 return (-1);
186 }
187
188 /*
189 * ****************************************************************************
190 *
191 * get_index_by_tag:
192 * find the index in the global tables for the tag of an attribute.
193 *
194 * name - the tag of an attribute.
195 * return - index or -1 for error.
196 *
197 * ****************************************************************************
198 */
199 static int
200 get_index_by_tag(
201 int tag
202 )
203 {
204 int i;
205 for (i = 0; i < ARRAY_LENGTH(xmlTag); i++) {
206 if (xmlArg1[i] == tag &&
207 xmlType[i][0] != 'o' &&
208 xmlType[i][0] != 'a') {
209 return (i);
210 }
211 }
212 return (-1);
213 }
214
215 /*
216 * ****************************************************************************
217 *
218 * get_xml_doc:
219 * open the xml file and assign the global xml doc if the xml file
220 * is not opened, set the doc pointer with the opened xml file for
221 * returnning.
222 *
223 * docp - the doc pointer for returning.
224 * return - error code.
225 *
226 * ****************************************************************************
227 */
228 static int
229 get_xml_doc(
230 xmlDocPtr *docp
231 )
232 {
233 int ec = 0;
234
235 if (xml_doc == NULL) {
236 /* validate the xml file */
237
238 /* open the xml file */
239 xml_doc = xmlParseFile(xml_file);
240 }
241
242 *docp = xml_doc;
243
244 if (xml_doc == NULL) {
245 ec = ISNS_RSP_INTERNAL_ERROR;
246 }
247
248 return (ec);
249 }
250
251 /*
252 * ****************************************************************************
253 *
254 * close_xml_doc:
255 * close the global xml doc and ignore any changes that has been
256 * made in it.
257 *
258 * ****************************************************************************
259 */
260 static void
261 close_xml_doc(
262 )
263 {
264 if (xml_doc) {
265 /* just close it */
266 xmlFreeDoc(xml_doc);
267 xml_doc = NULL;
268 }
269 }
270
271 /*
272 * ****************************************************************************
273 *
274 * convert_xml2attr:
275 * convert a xml data to a TLV format isns attribute.
276 *
277 * tag - the tag of attribute.
278 * type - the data type of the xml data.
279 * value - the xml data.
280 * attr - TLV format attribute for returning.
281 * return - error code.
282 *
283 * ****************************************************************************
284 */
285 static int
286 convert_xml2attr(
287 const int tag,
288 const unsigned char type,
289 xmlChar *value,
290 isns_attr_t *attr
291 )
292 {
293 uint32_t len;
294 int ec = 0;
295
296 attr->tag = tag;
297 switch (type) {
298 case 'u':
299 /* 4-bytes non-negative integer */
300 attr->len = 4;
301 attr->value.ui = atoi((const char *)value);
302 break;
303 case 's':
304 /* literal string */
305 len = strlen((char *)value);
306 len += 4 - (len % 4);
307 attr->len = len;
308 attr->value.ptr = (uchar_t *)malloc(attr->len);
309 if (attr->value.ptr != NULL) {
310 (void) strcpy((char *)attr->value.ptr,
311 (char *)value);
312 } else {
313 ec = ISNS_RSP_INTERNAL_ERROR;
314 }
315 break;
316 case 'p':
317 /* IPv6 block data */
318 attr->len = sizeof (in6_addr_t);
319 attr->value.ip = (in6_addr_t *)malloc(attr->len);
320 if (attr->value.ip != NULL) {
321 (void) inet_pton(AF_INET6,
322 (char *)value,
323 attr->value.ip);
324 } else {
325 ec = ISNS_RSP_INTERNAL_ERROR;
326 }
327 break;
328 default:
329 break;
330 }
331
332 return (ec);
333 }
334
335 /*
336 * ****************************************************************************
337 *
338 * convert_attr2xml:
339 * convert a TLV format isns attribute to xml node format.
340 *
341 * node - the xml node where the new node is being added to.
342 * attr - the TLV format attribute.
343 * name - the name of the attribute in xml node.
344 * type - the data type of the attribute.
345 * elm_flag - 0: adding a xml attlist.
346 * 1: adding a xml child node.
347 * 2: adding a previous sibling node.
348 * 3: adding a xml content node.
349 * 4: adding a xml attribute.
350 * return - xml node.
351 *
352 * ****************************************************************************
353 */
354 static xmlNodePtr
355 convert_attr2xml(
356 xmlNodePtr node,
357 const isns_attr_t *attr,
358 const xmlChar *name,
359 const char type,
360 const int elm_flag
361 )
362 {
363 xmlChar buff[INET6_ADDRSTRLEN + 1] = { 0 };
364 xmlChar *value = NULL;
365 xmlNodePtr child = NULL;
366
367 switch (type) {
368 case 'u':
369 /* 4-bytes non-negative integer */
370 if (xmlStrPrintf(buff, sizeof (buff),
371 XMLSTRING_CAST "%u",
372 attr->value.ui) > 0) {
373 value = (xmlChar *)&buff;
374 }
375 break;
376 case 's':
377 /* literal string */
378 value = (xmlChar *)attr->value.ptr;
379 break;
380 case 'p':
381 /* IPv6 block data */
382 value = (xmlChar *)inet_ntop(AF_INET6,
383 (char *)attr->value.ip,
384 (char *)buff,
385 sizeof (buff));
386 break;
387 default:
388 break;
389 }
390
391 if (!value) {
392 return (NULL);
393 }
394
395 switch (elm_flag) {
396 case 0: /* attlist */
397 if (xmlSetProp(node, name, value)) {
398 child = node;
399 }
400 break;
401 case 1: /* child element */
402 child = xmlNewChild(node, NULL, name, value);
403 break;
404 case 2: /* prev sibling element */
405 child = xmlNewNode(NULL, name);
406 if (child != NULL &&
407 xmlAddPrevSibling(node, child) == NULL) {
408 xmlFreeNode(child);
409 node = NULL;
410 } else {
411 node = child;
412 }
413 /* LINTED E_CASE_FALLTHRU */
414 case 3: /* set content */
415 if (node) {
416 xmlNodeSetContent(node, value);
417 }
418 child = node;
419 break;
420 case 4: /* new attr value */
421 if (xmlSetProp(node, name, value)) {
422 child = node;
423 }
424 break;
425 default:
426 ASSERT(0);
427 break;
428 }
429
430 return (child);
431 }
432
433 /*
434 * ****************************************************************************
435 *
436 * parse_xml_prop:
437 * parse the properties of a xml node and convert them to the attributes
438 * of an isns object, these xml properties are the UID attribute and
439 * key attributes of the isns object.
440 *
441 * node - the xml node that contains the properties.
442 * obj - the isns object.
443 * i - the index of the attribute in the global tables.
444 * return - error code.
445 *
446 * ****************************************************************************
447 */
448 static int
449 parse_xml_prop(
450 xmlNodePtr node,
451 isns_obj_t *obj,
452 int i
453 )
454 {
455 int ec = 0;
456 const char *props = &xmlType[i][1];
457 const xmlChar *prop_name;
458 xmlChar *prop_value;
459 unsigned char prop_type;
460 int prop_tag;
461 int prop_id;
462 char prop;
463 int j;
464
465 j = 0;
466 prop = props[j ++];
467 while (ec == 0 &&
468 prop >= 'a' && prop <= 'z') {
469 prop -= 'a';
470 prop_id = xmlPropID[prop];
471 prop_tag = xmlPropTag[prop];
472 prop_name = xmlPropName[prop];
473 prop_type = xmlPropType[prop];
474 prop_value = xmlGetProp(node, prop_name);
475
476 if (prop_value) {
477 ec = convert_xml2attr(
478 prop_tag,
479 prop_type,
480 prop_value,
481 &(obj->attrs[prop_id]));
482 xmlFree(prop_value);
483 }
484 prop = props[j ++];
485 }
486
487 return (ec);
488 }
489
490 /*
491 * ****************************************************************************
492 *
493 * parse_xml_attr:
494 * parse a xml node and convert it to one isns object attribute.
495 * this attribute is the non-key attribute of the isns object.
496 *
497 * node - the xml node.
498 * obj - the isns object.
499 * i - the index of the attribute in the global tables.
500 * return - error code.
501 *
502 * ****************************************************************************
503 */
504 static int
505 parse_xml_attr(
506 xmlNodePtr node,
507 isns_obj_t *obj,
508 int i
509 )
510 {
511 int ec = 0;
512 const unsigned char attr_type = xmlType[i][0];
513 const int attr_tag = xmlArg1[i];
514 const int attr_id = xmlArg2[i];
515 xmlChar *attr_value;
516
517 attr_value = xmlNodeGetContent(node);
518
519 if (attr_value) {
520 ec = convert_xml2attr(
521 attr_tag,
522 attr_type,
523 attr_value,
524 &(obj->attrs[attr_id]));
525 xmlFree(attr_value);
526 }
527
528 return (ec);
529 }
530
531 /*
532 * ****************************************************************************
533 *
534 * parse_xml_obj:
535 * parse one isns object from the xml doc.
536 *
537 * nodep - the pointer of the xml node for parsing.
538 * objp - the pointer of isns object for returning.
539 * return - error code.
540 *
541 * ****************************************************************************
542 */
543 static int
544 parse_xml_obj(
545 xmlNodePtr *nodep,
546 isns_obj_t **objp
547 )
548 {
549 int ec = 0;
550 int i, j;
551
552 xmlNodePtr node = *nodep;
553 xmlNodePtr children;
554
555 isns_obj_t *obj = *objp;
556
557 while (node && ec == 0) {
558 if (node->type == XML_ELEMENT_NODE) {
559 children = node->children;
560 i = get_index_by_name(node->name);
561 ASSERT(i >= 0);
562 j = xmlType[i][0];
563 if (j == 'o' && obj == NULL) {
564 obj = obj_calloc(xmlArg1[i]);
565 if (obj == NULL) {
566 ec = ISNS_RSP_INTERNAL_ERROR;
567 break;
568 }
569 if ((ec = parse_xml_prop(node, obj, i)) == 0 &&
570 (children == NULL ||
571 (ec = parse_xml_obj(&children, &obj)) ==
572 0)) {
573 if (children != NULL &&
574 children != node->children) {
575 *nodep = children;
576 }
577 *objp = obj;
578 } else {
579 free_object(obj);
580 }
581 break;
582 /* LINTED E_NOP_IF_STMT */
583 } else if (j == 'o') {
584 } else if (j != 0) {
585 ASSERT(obj);
586 if (children != NULL) {
587 ec = parse_xml_attr(children, obj, i);
588 *nodep = children;
589 } else {
590 /* assign a default value */
591 *nodep = node;
592 }
593 } else {
594 /* unknown xml node */
595 break;
596 }
597 /* LINTED E_NOP_ELSE_STMT */
598 } else {
599 /* carry return or blank spaces, skip it */
600 }
601 node = node->next;
602 }
603
604 return (ec);
605 }
606
607 /*
608 * ****************************************************************************
609 *
610 * locate_xml_node:
611 * locate the xml node from xml doc by matching the object UID.
612 *
613 * doc - the xml doc.
614 * otype - the matching object type.
615 * match_uid - the matching object UID.
616 * node - the pointer of matched xml node for returning.
617 * context - the xml context for matching process.
618 * result - the xml result for matching process.
619 * return - error code.
620 *
621 * ****************************************************************************
622 */
623 static int
624 locate_xml_node(
625 xmlDocPtr doc,
626 int otype,
627 int match_uid,
628 xmlNodePtr *node,
629 xmlXPathContextPtr *context,
630 xmlXPathObjectPtr *result
631 )
632 {
633 int ec = 0;
634
635 xmlNodeSetPtr nodeset;
636 xmlNodePtr curr;
637 xmlChar expr[32] = { (xmlChar)'/', (xmlChar)'/', 0 };
638
639 char prop;
640 const xmlChar *prop_name;
641 xmlChar *prop_value;
642 int uid;
643
644 int i, j;
645
646 *node = NULL;
647
648 i = get_index_by_otype(otype);
649 ASSERT(i >= 0);
650
651 *context = xmlXPathNewContext(doc);
652
653 if (*context &&
654 xmlStrPrintf(&expr[2], 30, XMLSTRING_CAST "%s",
655 xmlTag[i]) != -1) {
656 *result = xmlXPathEvalExpression(expr, *context);
657 if (*result) {
658 prop = xmlArg2[i] - 'a';
659 prop_name = xmlPropName[prop];
660 ASSERT(xmlPropType[prop] == 'u');
661 nodeset = (*result)->nodesetval;
662 for (j = 0;
663 nodeset && (j < nodeset->nodeNr);
664 j++) {
665 curr = nodeset->nodeTab[j];
666 prop_value = xmlGetProp(curr, prop_name);
667 if (prop_value) {
668 uid = atoi((const char *)prop_value);
669 xmlFree(prop_value);
670 if (uid == match_uid) {
671 /* found it */
672 *node = curr;
673 return (ec);
674 }
675 }
676 }
677 } else {
678 ec = ISNS_RSP_INTERNAL_ERROR;
679 }
680 } else {
681 ec = ISNS_RSP_INTERNAL_ERROR;
682 }
683
684 if (*result) {
685 xmlXPathFreeObject(*result);
686 *result = NULL;
687 }
688 if (*context) {
689 xmlXPathFreeContext(*context);
690 *context = NULL;
691 }
692
693 return (ec);
694 }
695
696 /*
697 * ****************************************************************************
698 *
699 * make_xml_node:
700 * generate a xml node for presenting an isns object.
701 *
702 * obj - an isns object.
703 * return - the xml node.
704 *
705 * ****************************************************************************
706 */
707 static xmlNodePtr
708 make_xml_node(
709 const isns_obj_t *obj
710 )
711 {
712 const isns_attr_t *attr;
713
714 xmlNodePtr node;
715 const char *props;
716 char prop;
717 const xmlChar *name;
718 unsigned char type;
719 int prop_id;
720 int i, j;
721
722 i = get_index_by_otype(obj->type);
723 ASSERT(i >= 0);
724 node = xmlNewNode(NULL, xmlTag[i]);
725 if (!node) {
726 return (NULL);
727 }
728
729 /* generate xml attributes of the node */
730 props = &xmlType[i][1];
731 prop = *(props ++);
732 while (prop >= 'a' && prop <= 'z') {
733 prop -= 'a';
734 prop_id = xmlPropID[prop];
735 name = xmlPropName[prop];
736 type = xmlPropType[prop];
737 attr = &obj->attrs[prop_id];
738 if (!convert_attr2xml(node, attr, name, type, 0)) {
739 xmlFreeNode(node);
740 return (NULL);
741 }
742 /* attr->tag = 0; */
743 prop = *(props ++);
744 }
745
746 /* generate sub elements for isns attributes of the object */
747 i = 0;
748 while (i < NUM_OF_ATTRS[obj->type]) {
749 attr = &obj->attrs[i ++];
750 j = get_index_by_tag(attr->tag);
751 if (j >= 0) {
752 name = xmlTag[j];
753 type = xmlType[j][0];
754 if (!convert_attr2xml(node, attr, name, type, 1)) {
755 xmlFreeNode(node);
756 return (NULL);
757 }
758 }
759 }
760
761 return (node);
762 }
763
764 /*
765 * ****************************************************************************
766 *
767 * xml_init_data:
768 * initialization of the xml data store.
769 *
770 * return - error code.
771 *
772 * ****************************************************************************
773 */
774 static int
775 xml_init_data(
776 )
777 {
778 #define XML_PATH "/etc/isns"
779 #define XML_FILE_NAME "/isnsdata.xml"
780 #define XML_DOT_TMP ".tmp"
781 #define XML_DOT_BAK ".bak"
782
783 int fd;
784 xmlDocPtr doc;
785 xmlNodePtr root;
786
787 int len;
788 char *xml_path, *p = NULL;
789
790 char *cwd = NULL;
791
792 int has_bak = 0;
793
794 /* cannot reset the xml file when server is running */
795 if (xml_file != NULL) {
796 return (1);
797 }
798
799 /* set the data store file name along with the backup */
800 /* file name and temporary file name */
801 len = strlen(data_store);
802 if (len > 0) {
803 xml_file = data_store;
804 p = strdup(xml_file);
805 xml_bak_file = (char *)malloc(len + 5);
806 xml_tmp_file = (char *)malloc(len + 5);
807 if (p != NULL &&
808 xml_bak_file != NULL &&
809 xml_tmp_file != NULL) {
810 xml_path = dirname(p);
811 (void) strcpy(xml_bak_file, xml_file);
812 (void) strcat(xml_bak_file, XML_DOT_BAK);
813 (void) strcpy(xml_tmp_file, xml_file);
814 (void) strcat(xml_tmp_file, XML_DOT_TMP);
815 } else {
816 return (1);
817 }
818 } else {
819 xml_path = XML_PATH;
820 xml_file = XML_PATH XML_FILE_NAME;
821 xml_bak_file = XML_PATH XML_FILE_NAME XML_DOT_BAK;
822 xml_tmp_file = XML_PATH XML_FILE_NAME XML_DOT_TMP;
823 }
824
825 /* save current working directory */
826 cwd = getcwd(NULL, MAXPATHLEN);
827 if (cwd == NULL) {
828 return (1);
829 }
830 /* check access permission on data store directory */
831 if (chdir(xml_path) != 0) {
832 if (errno == ENOENT) {
833 if (mkdir(xml_path, S_IRWXU) != 0 ||
834 chdir(xml_path) != 0) {
835 return (1);
836 }
837 } else {
838 return (1);
839 }
840 }
841 /* go back to original working directory */
842 (void) chdir(cwd);
843 free(cwd);
844 free(p);
845
846 /* do not keep blank spaces */
847 (void) xmlKeepBlanksDefault(0);
848
849 /* remove the tmp file if it exists */
850 if (access(xml_tmp_file, F_OK) == 0) {
851 (void) remove(xml_tmp_file);
852 }
853
854 /* test if we can write the bak file */
855 fd = open(xml_bak_file, O_RDWR);
856 if (fd == -1) {
857 fd = open(xml_bak_file, O_RDWR | O_CREAT,
858 S_IRUSR | S_IWUSR);
859 if (fd == -1) {
860 return (1);
861 } else {
862 (void) close(fd);
863 (void) remove(xml_bak_file);
864 }
865 } else {
866 has_bak = 1;
867 (void) close(fd);
868 }
869
870 /* Test if we have the data store file, create an empty */
871 /* data store if we do not have the data store file and */
872 /* the backup data store. */
873 fd = open(xml_file, O_RDWR);
874 if (fd == -1) {
875 if (has_bak == 0) {
876 doc = xmlNewDoc(BAD_CAST "1.0");
877 root = xmlNewNode(NULL, xml_root[0]);
878 if (doc != NULL &&
879 root != NULL &&
880 xmlSetProp(root, xml_root[1], xml_root[2]) !=
881 NULL &&
882 xmlSetProp(root, xml_root[3], xml_root[4]) !=
883 NULL) {
884 (void) xmlDocSetRootElement(doc, root);
885 if (xmlSaveFormatFile(xml_file, doc, 1) == -1) {
886 xmlFreeDoc(doc);
887 return (-1);
888 }
889 xmlFreeDoc(doc);
890 } else {
891 if (doc != NULL) {
892 xmlFreeDoc(doc);
893 }
894 if (root != NULL) {
895 xmlFreeNode(root);
896 }
897 return (1);
898 }
899 } else {
900 isnslog(LOG_WARNING, "get_xml_doc",
901 "initializing with backup data");
902 if (rename(xml_bak_file, xml_file) != 0) {
903 return (1);
904 }
905 }
906 } else {
907 (void) close(fd);
908 }
909
910 return (0);
911 }
912
913 /*
914 * ****************************************************************************
915 *
916 * xml_load_obj:
917 * load an isns object from the xml data store.
918 *
919 * p - the pointer of current xml node.
920 * objp - the pointer of the object for returning.
921 * level - the direction of xml parsing for returning.
922 * return - error code.
923 *
924 * ****************************************************************************
925 */
926 static int
927 xml_load_obj(
928 void **p,
929 isns_obj_t **objp,
930 uchar_t *level
931 )
932 {
933 xmlDocPtr doc = NULL;
934 xmlNodePtr node = (xmlNodePtr)*p;
935 int ec = 0;
936
937 *objp = NULL;
938
939 if (node == NULL) {
940 *level = '^';
941 ec = get_xml_doc(&doc);
942 if (doc == NULL) {
943 return (ec);
944 }
945 node = xmlDocGetRootElement(doc);
946 if (node != NULL) {
947 node = node->children;
948 }
949 } else if (node->children != NULL) {
950 *level = '>';
951 node = node->children;
952 } else if (node->next != NULL) {
953 *level = 'v';
954 node = node->next;
955 } else {
956 *level = 'v';
957 while (node != NULL && node->next == NULL) {
958 if (node->type == XML_ELEMENT_NODE) {
959 *level = '<';
960 }
961 node = node->parent;
962 }
963 if (node != NULL) {
964 node = node->next;
965 }
966 }
967
968 /* there is a node, parse it */
969 if (node) {
970 ec = parse_xml_obj(&node, objp);
971 *p = (void *)node;
972 }
973
974 if (ec == 0 && *objp != NULL) {
975 ec = update_deref_obj(*objp);
976 if (ec != 0) {
977 free_object(*objp);
978 *objp = NULL;
979 }
980 }
981
982 /* no object available, close the xml doc */
983 if (*objp == NULL) {
984 (void) close_xml_doc();
985 }
986
987 return (ec);
988 }
989
990 /*
991 * ****************************************************************************
992 *
993 * xml_add_obj:
994 * add an isns object to the xml data store.
995 *
996 * obj - the object being added.
997 * return - error code.
998 *
999 * ****************************************************************************
1000 */
1001 static int
1002 xml_add_obj(
1003 const isns_obj_t *obj
1004 )
1005 {
1006 int ec = 0;
1007
1008 xmlDocPtr doc;
1009 xmlXPathContextPtr context = NULL;
1010 xmlXPathObjectPtr result = NULL;
1011 xmlNodePtr node, prev;
1012 xmlNodePtr candidate;
1013
1014 uint32_t puid, parent_type;
1015
1016 int i;
1017
1018 /* get the xml doc */
1019 ec = get_xml_doc(&doc);
1020 if (doc == NULL) {
1021 goto add_done;
1022 }
1023
1024 /* create the candidate node */
1025 candidate = make_xml_node(obj);
1026 if (candidate == NULL) {
1027 ec = ISNS_RSP_INTERNAL_ERROR;
1028 goto add_done;
1029 }
1030
1031 /* locate the position */
1032 parent_type = TYPE_OF_PARENT[obj->type];
1033 if (parent_type > 0) {
1034 puid = get_parent_uid(obj);
1035 ec = locate_xml_node(doc, parent_type, puid,
1036 &node, &context, &result);
1037 } else {
1038 node = xmlDocGetRootElement(doc);
1039 }
1040
1041 /* cannot locate the point for inserting the node */
1042 if (node == NULL) {
1043 xmlFreeNode(candidate);
1044 ec = ISNS_RSP_INTERNAL_ERROR;
1045 goto add_done;
1046 }
1047
1048 /* add it with the apporiate child order */
1049 if (node->children) {
1050 node = node->children;
1051 while (node) {
1052 if (node->type == XML_ELEMENT_NODE) {
1053 i = get_index_by_name(node->name);
1054 ASSERT(i >= 0);
1055 if (xmlType[i][0] == 'o' &&
1056 OBJ_DTD_ORDER[xmlArg1[i]] >=
1057 OBJ_DTD_ORDER[obj->type]) {
1058 break;
1059 }
1060 }
1061 prev = node;
1062 node = node->next;
1063 }
1064 if (node == NULL) {
1065 node = xmlAddNextSibling(prev, candidate);
1066 } else {
1067 node = xmlAddPrevSibling(node, candidate);
1068 }
1069 } else {
1070 node = xmlAddChild(node, candidate);
1071 }
1072
1073 if (node == NULL) {
1074 /* Failed, free the candidate node. */
1075 xmlFreeNode(candidate);
1076 ec = ISNS_RSP_INTERNAL_ERROR;
1077 }
1078
1079 add_done:
1080 if (result) {
1081 xmlXPathFreeObject(result);
1082 }
1083 if (context) {
1084 xmlXPathFreeContext(context);
1085 }
1086
1087 return (ec);
1088 }
1089
1090 /*
1091 * ****************************************************************************
1092 *
1093 * xml_modify_obj:
1094 * modify an isns object in the xml data store.
1095 *
1096 * obj - the new object.
1097 * return - error code.
1098 *
1099 * ****************************************************************************
1100 */
1101 static int
1102 xml_modify_obj(
1103 const isns_obj_t *obj
1104 )
1105 {
1106 int ec = 0;
1107 xmlDocPtr doc;
1108 xmlXPathContextPtr context = NULL;
1109 xmlXPathObjectPtr result = NULL;
1110 xmlNodePtr node, child;
1111 const char *props;
1112 char prop;
1113 int prop_id;
1114 int prop_tag;
1115 const xmlChar *name;
1116 unsigned char type;
1117 const isns_attr_t *attr;
1118 int i, j, k;
1119 int make_child;
1120
1121 /* get the doc pointer */
1122 ec = get_xml_doc(&doc);
1123 if (doc == NULL) {
1124 return (ec);
1125 }
1126
1127 /* locate the node for the object */
1128 i = get_index_by_otype(obj->type);
1129 ASSERT(i >= 0);
1130 prop = xmlArg2[i] - 'a';
1131 prop_id = xmlPropID[prop];
1132 attr = &obj->attrs[prop_id];
1133 ec = locate_xml_node(doc,
1134 obj->type,
1135 attr->value.ui,
1136 &node, &context, &result);
1137
1138 /* modify it */
1139 if (node != NULL) {
1140 props = &xmlType[i][1];
1141 prop = *(props ++);
1142 while (prop >= 'a' && prop <= 'z') {
1143 prop -= 'a';
1144 prop_id = xmlPropID[prop];
1145 prop_tag = xmlPropTag[prop];
1146 attr = &obj->attrs[prop_id];
1147 /* no need to update the key attributes, skip it. */
1148 /* btw, dd and dd-set names are non-key attributes. */
1149 if (prop_tag == ISNS_DD_NAME_ATTR_ID ||
1150 prop_tag == ISNS_DD_SET_NAME_ATTR_ID) {
1151 name = xmlPropName[prop];
1152 type = xmlPropType[prop];
1153 if (!convert_attr2xml(node,
1154 attr, name, type, 4)) {
1155 ec = ISNS_RSP_INTERNAL_ERROR;
1156 goto modify_done;
1157 }
1158 }
1159 /* attr->tag = 0; */
1160 prop = *(props ++);
1161 }
1162 /* set the child */
1163 child = node->children;
1164 if (child == NULL) {
1165 make_child = 1;
1166 } else {
1167 make_child = 0;
1168 }
1169 for (i = 0; i < NUM_OF_ATTRS[obj->type]; i++) {
1170 attr = &obj->attrs[i];
1171 j = get_index_by_tag(attr->tag);
1172 if (j < 0) {
1173 continue;
1174 }
1175 name = xmlTag[j];
1176 type = xmlType[j][0];
1177 if (make_child == 1) {
1178 /* make a child node */
1179 if (!convert_attr2xml(node, attr,
1180 name, type, 1)) {
1181 ec = ISNS_RSP_INTERNAL_ERROR;
1182 goto modify_done;
1183 }
1184 continue;
1185 }
1186 while (child) {
1187 if (child->type == XML_ELEMENT_NODE) {
1188 k = get_index_by_name(child->name);
1189 ASSERT(k >= 0);
1190 if (xmlType[k][0] == 'o' ||
1191 xmlType[k][0] == 'a' ||
1192 xmlArg1[k] > attr->tag) {
1193 if (!convert_attr2xml(child,
1194 attr, name, type, 2)) {
1195 /* internal error */
1196 ec = 11;
1197 goto modify_done;
1198 }
1199 break;
1200 } else if (xmlArg1[k] == attr->tag) {
1201 /* replace content */
1202 if (!convert_attr2xml(child,
1203 attr, name, type, 3)) {
1204 /* internal error */
1205 ec = 11;
1206 goto modify_done;
1207 }
1208 break;
1209 }
1210 }
1211 child = child->next;
1212 }
1213 if (child == NULL) {
1214 /* make a child node */
1215 if (!convert_attr2xml(node, attr,
1216 name, type, 1)) {
1217 ec = ISNS_RSP_INTERNAL_ERROR;
1218 goto modify_done;
1219 }
1220 }
1221 }
1222 } else {
1223 /* This case is for registering a node which has */
1224 /* membership in one or more non-default DD(s). */
1225 ec = xml_add_obj(obj);
1226 }
1227
1228 modify_done:
1229 if (result) {
1230 xmlXPathFreeObject(result);
1231 }
1232 if (context) {
1233 xmlXPathFreeContext(context);
1234 }
1235
1236 return (ec);
1237 }
1238
1239 /*
1240 * ****************************************************************************
1241 *
1242 * xml_delete_obj:
1243 * delete an isns object from the xml data store.
1244 *
1245 * obj - the object being deleted.
1246 * return - error code.
1247 *
1248 * ****************************************************************************
1249 */
1250 static int
1251 xml_delete_obj(
1252 const isns_obj_t *obj
1253 )
1254 {
1255 int ec = 0;
1256 xmlDocPtr doc;
1257 xmlXPathContextPtr context = NULL;
1258 xmlXPathObjectPtr result = NULL;
1259 xmlNodePtr node;
1260
1261 isns_type_t otype;
1262 uint32_t uid;
1263
1264 /* get the xml doc */
1265 ec = get_xml_doc(&doc);
1266 if (doc == NULL) {
1267 return (ec);
1268 }
1269
1270 otype = obj->type;
1271 #ifdef WRITE_DATA_ASYNC
1272 /* it is a thin clone */
1273 uid = obj->attrs[0].value.ui;
1274 #else
1275 uid = get_obj_uid(obj);
1276 #endif
1277
1278 /* locate the object */
1279 ec = locate_xml_node(doc,
1280 otype,
1281 uid,
1282 &node, &context, &result);
1283
1284 /* destroy it */
1285 if (node) {
1286 xmlUnlinkNode(node);
1287 xmlFreeNode(node);
1288 }
1289
1290 if (result) {
1291 xmlXPathFreeObject(result);
1292 }
1293 if (context) {
1294 xmlXPathFreeContext(context);
1295 }
1296
1297 return (ec);
1298 }
1299
1300 /*
1301 * ****************************************************************************
1302 *
1303 * xml_delete_assoc:
1304 * delete a DD or DD-set membership from the xml data store.
1305 *
1306 * assoc - the membership being deleted.
1307 * return - error code.
1308 *
1309 * ****************************************************************************
1310 */
1311 static int
1312 xml_delete_assoc(
1313 const isns_obj_t *assoc
1314 )
1315 {
1316 int ec = 0;
1317 xmlDocPtr doc;
1318 xmlXPathContextPtr context = NULL;
1319 xmlXPathObjectPtr result = NULL;
1320 xmlNodePtr node;
1321
1322 uint32_t puid, parent_type;
1323 uint32_t uid, match_uid;
1324
1325 char prop;
1326 const xmlChar *prop_name;
1327 xmlChar *prop_value;
1328 int i;
1329
1330 /* get the xml doc */
1331 ec = get_xml_doc(&doc);
1332 if (doc == NULL) {
1333 return (ec);
1334 }
1335
1336 /* get the container object UID */
1337 parent_type = TYPE_OF_PARENT[assoc->type];
1338 ASSERT(parent_type != 0);
1339 puid = get_parent_uid(assoc);
1340 ASSERT(puid != 0);
1341
1342 /* get the member object UID */
1343 i = get_index_by_otype(assoc->type);
1344 prop = xmlArg2[i] - 'a';
1345 prop_name = xmlPropName[prop];
1346 match_uid = assoc->attrs[UID_ATTR_INDEX[assoc->type]].value.ui;
1347
1348 /* locate the container object */
1349 ec = locate_xml_node(doc, parent_type, puid,
1350 &node, &context, &result);
1351
1352 /* get the membership nodes */
1353 if (node != NULL) {
1354 node = node->children;
1355 }
1356
1357 /* get the matching membership node */
1358 while (node) {
1359 if (node->type == XML_ELEMENT_NODE) {
1360 i = get_index_by_name(node->name);
1361 ASSERT(i >= 0);
1362 if (xmlType[i][0] == 'o' &&
1363 xmlArg1[i] == assoc->type) {
1364 prop_value = xmlGetProp(node, prop_name);
1365 if (prop_value) {
1366 uid = atoi((const char *)prop_value);
1367 xmlFree(prop_value);
1368 if (uid == match_uid) {
1369 break;
1370 }
1371 }
1372 }
1373 }
1374 node = node->next;
1375 }
1376
1377 /* destroy it */
1378 if (node) {
1379 xmlUnlinkNode(node);
1380 xmlFreeNode(node);
1381 }
1382
1383 if (result) {
1384 xmlXPathFreeObject(result);
1385 }
1386 if (context) {
1387 xmlXPathFreeContext(context);
1388 }
1389
1390 return (ec);
1391 }
1392
1393 /*
1394 * ****************************************************************************
1395 *
1396 * xml_update_commit:
1397 * backup the current written file and commit all updates from
1398 * the xml doc to the written file.
1399 *
1400 * return - error code.
1401 *
1402 * ****************************************************************************
1403 */
1404 static int
1405 xml_update_commit(
1406 )
1407 {
1408 int ec = 0;
1409
1410 if (xml_doc) {
1411 /* write to tmp file */
1412 if (xmlSaveFormatFile(xml_tmp_file, xml_doc, 1) == -1 ||
1413 /* backup the current file */
1414 rename(xml_file, xml_bak_file) != 0 ||
1415 /* rename the tmp file to the current file */
1416 rename(xml_tmp_file, xml_file) != 0) {
1417 /* failed saving file */
1418 ec = ISNS_RSP_INTERNAL_ERROR;
1419 }
1420 /* close the xml_doc */
1421 xmlFreeDoc(xml_doc);
1422 xml_doc = NULL;
1423 }
1424
1425 return (ec);
1426 }
1427
1428 /*
1429 * ****************************************************************************
1430 *
1431 * xml_update_retreat:
1432 * ignore all of updates in the xml doc.
1433 *
1434 * return - 0: always successful.
1435 *
1436 * ****************************************************************************
1437 */
1438 static int
1439 xml_update_retreat(
1440 )
1441 {
1442 if (xml_doc) {
1443 /* close the xml_doc */
1444 xmlFreeDoc(xml_doc);
1445 xml_doc = NULL;
1446 }
1447
1448 return (0);
1449 }
unleashed repo fork