OpenSolaris_b135/lib/libiscsitgt/common/xml.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <inttypes.h>
#include <assert.h>
#include <libxml/xmlreader.h>
#include <strings.h>
#include <ctype.h>
#include <stdlib.h>
#include <syslog.h>
#include <sys/stat.h>
#include "iscsitgt_impl.h"
/*
* Forward declarations
*/
static char *strip_space(char *value);
static tgt_node_t *node_alloc();
static void node_free(tgt_node_t *x);
static Boolean_t node_name(tgt_node_t *x, const xmlChar *n);
static Boolean_t node_value(tgt_node_t *x, const xmlChar *n, Boolean_t s);
static tgt_node_t *node_parent(tgt_node_t *x);
static tgt_node_t *node_child(tgt_node_t *x);
static tgt_node_t *node_alloc_attr(tgt_node_t *x);
static void buf_add_node_attr(char **b, tgt_node_t *x);
static void buf_add_comment(char **b, char *comment);
static void buf_add_str(char **b, char *str);
#define XML_COMMENT_STR "!--"
#define XML_COMMENT_END "--"
void
tgt_node_free(tgt_node_t *n)
{
tgt_node_t *c;
tgt_node_t *c1;
if (n == NULL)
return;
for (c = n->x_child; c; ) {
c1 = c->x_sibling;
tgt_node_free(c);
c = c1;
}
for (c = n->x_attr; c; ) {
c1 = c->x_sibling;
node_free(c);
c = c1;
}
node_free(n);
}
/*
* tgt_dump2buf -- dumps node tree to buffer, allocating memory as it goes
*
* It is up to the caller, when finished with 'buf', to call free()
*/
void
tgt_dump2buf(tgt_node_t *n, char **buf)
{
tgt_node_t *c;
if (n == NULL)
return;
if (strcmp(n->x_name, XML_COMMENT_STR) == 0) {
buf_add_comment(buf, n->x_value);
return;
}
buf_add_node_attr(buf, n);
if (n->x_value != NULL)
tgt_buf_add_tag(buf, n->x_value, Tag_String);
for (c = n->x_child; c; c = c->x_sibling)
tgt_dump2buf(c, buf);
tgt_buf_add_tag(buf, n->x_name, Tag_End);
}
char *common_attr_list[] = {
XML_ELEMENT_NAME,
XML_ELEMENT_VERS,
XML_ELEMENT_INCORE,
0
};
Boolean_t
tgt_node_process(xmlTextReaderPtr r, tgt_node_t **node)
{
const xmlChar *name;
const xmlChar *value;
char **ap;
xmlElementType node_type;
tgt_node_t *n;
tgt_node_t *an;
n = *node;
if (n == NULL) {
n = node_alloc();
if (n == NULL)
return (False);
*node = n;
}
name = (xmlChar *)xmlTextReaderConstName(r);
if (name == NULL) {
node_free(n);
*node = NULL;
return (False);
}
node_type = (xmlElementType)xmlTextReaderNodeType(r);
value = (xmlChar *)xmlTextReaderConstValue(r);
if (node_type == XML_ELEMENT_NODE) {
if (n->x_state != NodeAlloc) {
n = node_child(n);
*node = n;
if (n == NULL)
return (False);
}
if (xmlTextReaderAttributeCount(r) > 0) {
for (ap = common_attr_list; *ap; ap++) {
value = xmlTextReaderGetAttribute(r,
(xmlChar *)*ap);
if (value != NULL) {
if ((an = node_alloc_attr(n)) == NULL)
return (False);
if (node_name(an, (xmlChar *)*ap) ==
False) {
node_free(an);
return (False);
}
if (node_value(an, value, True) ==
False) {
node_free(an);
return (False);
}
free((char *)value);
}
}
}
if (node_name(n, name) == False) {
node_free(n);
*node = NULL;
return (False);
}
} else if ((value != NULL) && (node_type == XML_TEXT_NODE)) {
if (node_value(n, value, True) == False) {
node_free(n);
*node = NULL;
return (False);
}
} else if (node_type == XML_ELEMENT_DECL) {
n = node_parent(n);
if (n == NULL)
return (False);
*node = n;
} else if (node_type == XML_COMMENT_NODE) {
n = node_child(n);
if (node_name(n, (xmlChar *)XML_COMMENT_STR) == False) {
node_free(n);
*node = NULL;
return (False);
}
if (node_value(n, (xmlChar *)value, False) == False) {
node_free(n);
*node = NULL;
return (False);
}
} else if (node_type != XML_DTD_NODE) {
node_free(n);
*node = NULL;
return (False);
}
return (True);
}
Boolean_t
tgt_find_attr_str(tgt_node_t *n, char *attr, char **value)
{
tgt_node_t *a;
if ((n == NULL) || (n->x_attr == NULL))
return (False);
for (a = n->x_attr; a; a = a->x_sibling)
if (strcmp(a->x_name, attr) == 0) {
*value = a->x_value ? strdup(a->x_value) : NULL;
return (True);
}
return (False);
}
Boolean_t
tgt_find_value_str(tgt_node_t *n, char *name, char **value)
{
tgt_node_t *c;
if ((n == NULL) || (n->x_name == NULL))
return (False);
if (strcmp(n->x_name, name) == 0) {
*value = n->x_value ? strdup(n->x_value) : NULL;
return (True);
}
for (c = n->x_child; c; c = c->x_sibling) {
if (tgt_find_value_str(c, name, value) == True)
return (True);
}
return (False);
}
Boolean_t
tgt_find_value_int(tgt_node_t *n, char *name, int *value)
{
tgt_node_t *c;
if ((n == NULL) || (n->x_name == NULL))
return (False);
if (strcmp(n->x_name, name) == 0) {
if (n->x_value == NULL)
return (False);
*value = strtol(n->x_value, NULL, 0);
return (True);
}
for (c = n->x_child; c; c = c->x_sibling) {
if (tgt_find_value_int(c, name, value) == True)
return (True);
}
return (False);
}
/*
* []----
* | xml_find_value_intchk -- if node exists, check to see if value is okay
* []----
*/
Boolean_t
tgt_find_value_intchk(tgt_node_t *n, char *name, int *value)
{
char *str;
char chk[32];
Boolean_t rval;
if (tgt_find_value_str(n, name, &str) == True) {
*value = strtol(str, NULL, 0);
/*
* Validate that the input string hasn't overrun what
* what an integer can handle. This is done by simply
* printing out the result of the conversion into a buffer
* and comparing it to the incoming string. That way when
* someone enters 4294967296 which strtol returns as 0
* we'll catch it.
*/
if ((str[0] == '0') && (str[1] != '\0')) {
if (str[1] == 'x')
(void) snprintf(chk, sizeof (chk), "0x%x",
*value);
else if (str[1] == 'X')
(void) snprintf(chk, sizeof (chk), "0X%x",
*value);
else
(void) snprintf(chk, sizeof (chk), "0%o",
*value);
} else
(void) snprintf(chk, sizeof (chk), "%d", *value);
if (strcmp(chk, str) == 0)
rval = True;
else
rval = False;
free(str);
return (rval);
} else
return (True);
}
Boolean_t
tgt_find_value_boolean(tgt_node_t *n, char *name, Boolean_t *value)
{
tgt_node_t *c;
if ((n == NULL) || (n->x_name == NULL))
return (False);
if (strcmp(n->x_name, name) == 0) {
if (n->x_value == NULL)
return (False);
*value = strcmp(n->x_value, "true") == 0 ? True : False;
return (True);
}
for (c = n->x_child; c; c = c->x_sibling) {
if (tgt_find_value_boolean(c, name, value) == True)
return (True);
}
return (False);
}
tgt_node_t *
tgt_node_next(tgt_node_t *n, char *name, tgt_node_t *cur)
{
tgt_node_t *x;
tgt_node_t *p;
if (n == NULL)
return (NULL);
if (cur != NULL) {
for (x = cur->x_sibling; x; x = x->x_sibling)
if (strcmp(x->x_name, name) == 0)
return (x);
return (NULL);
}
if (n->x_name == NULL)
return (NULL);
if (strcmp(n->x_name, name) == 0)
return (n);
for (x = n->x_child; x; x = x->x_sibling)
if ((p = tgt_node_next(x, name, 0)) != NULL)
return (p);
return (NULL);
}
tgt_node_t *
tgt_node_next_child(tgt_node_t *n, char *name, tgt_node_t *cur)
{
if (cur != NULL) {
n = cur->x_sibling;
} else {
if (n != NULL)
n = n->x_child;
else
return (NULL);
}
while (n) {
if (strcmp(n->x_name, name) == 0)
return (n);
n = n->x_sibling;
}
return (NULL);
}
void
tgt_node_add(tgt_node_t *p, tgt_node_t *c)
{
if ((p == NULL) || (c == NULL))
return;
c->x_parent = p;
if (p->x_child == NULL)
p->x_child = c;
else {
c->x_sibling = p->x_child;
p->x_child = c;
}
}
void
tgt_node_add_attr(tgt_node_t *p, tgt_node_t *a)
{
if ((p == NULL) || (a == NULL))
return;
if (p->x_attr == NULL)
p->x_attr = a;
else {
a->x_sibling = p->x_attr;
p->x_attr = a;
}
}
tgt_node_t *
tgt_node_alloc(char *name, xml_val_type_t type, void *value)
{
tgt_node_t *d = node_alloc();
int value_len = 0;
char *value_str = NULL;
if (d == NULL)
return (NULL);
switch (type) {
case String:
if (value)
value_len = strlen((char *)value) + 1;
break;
case Int:
value_len = sizeof (int) * 2 + 3;
break;
case Uint64:
value_len = sizeof (uint64_t) * 2 + 3;
break;
}
if (value_len &&
(value_str = (char *)calloc(sizeof (char), value_len)) == NULL)
return (NULL);
if (node_name(d, (xmlChar *)name) == False) {
free(value_str);
return (NULL);
}
if (value_str) {
switch (type) {
case String:
(void) snprintf(value_str, value_len, "%s",
(char *)value);
break;
case Int:
(void) snprintf(value_str, value_len, "%d",
*(int *)value);
break;
case Uint64:
(void) snprintf(value_str, value_len, "0x%llx",
*(uint64_t *)value);
break;
}
}
(void) node_value(d, (xmlChar *)value_str, True);
free(value_str);
return (d);
}
Boolean_t
tgt_xml_encode(uint8_t *ip, size_t ip_size, char **buf, size_t *buf_size)
{
char *bp;
*buf_size = (ip_size * 2) + 1;
if ((*buf = (char *)malloc(*buf_size)) == NULL) {
*buf_size = 0;
return (False);
}
for (bp = *buf; ip_size; ip_size--) {
(void) sprintf(bp, "%.2x", *ip);
ip++;
bp += 2;
}
/* make it null terminated */
*bp = 0;
return (True);
}
Boolean_t
tgt_xml_decode(char *buf, uint8_t **ip, size_t *ip_size)
{
uint8_t *i;
size_t buf_size = strlen(buf);
*ip_size = buf_size / 2;
if ((*ip = (uint8_t *)malloc(*ip_size)) == NULL) {
*ip_size = 0;
return (False);
}
for (i = *ip; buf_size; buf_size -= 2) {
char x[3];
bcopy(buf, x, 2);
x[2] = 0;
*i++ = strtol(x, NULL, 16);
buf += 2;
}
return (True);
}
Boolean_t
tgt_node_remove(tgt_node_t *parent, tgt_node_t *child, match_type_t m)
{
tgt_node_t *s;
tgt_node_t *c = NULL;
if ((parent == NULL) || (child == NULL))
return (False);
for (s = parent->x_child; s; c = s, s = s->x_sibling) {
/*
* See if the new child node matches one of the children
* in the parent.
*/
if ((strcmp(s->x_name, child->x_name) == 0) &&
((m == MatchName) || (strcmp(s->x_value,
child->x_value) == 0))) {
if (parent->x_child == s) {
parent->x_child = s->x_sibling;
} else {
c->x_sibling = s->x_sibling;
}
tgt_node_free(s);
break;
}
}
if (s == NULL)
return (False);
else
return (True);
}
void
tgt_node_replace(tgt_node_t *parent, tgt_node_t *child, match_type_t m)
{
tgt_node_t *s;
tgt_node_t *c;
if ((parent == NULL) || (child == NULL))
return;
for (s = parent->x_child; s; s = s->x_sibling) {
/*
* See if the new child node matches one of the children
* in the parent.
*/
if ((strcmp(s->x_name, child->x_name) == 0) &&
((m == MatchName) || (strcmp(s->x_value,
child->x_value) == 0))) {
/*
* We have a match. Now save the values of the new
* child in this current node.
*/
free(s->x_name);
free(s->x_value);
s->x_name = strdup(child->x_name);
s->x_value = strdup(child->x_value);
if (s->x_child) {
tgt_node_free(s->x_child);
s->x_child = NULL;
}
for (c = child->x_child; c; c = c->x_sibling)
(void) tgt_node_add(s, tgt_node_dup(c));
break;
}
}
if (s == NULL) {
/*
* Never found the child so add it
*/
(void) tgt_node_add(parent, tgt_node_dup(child));
}
}
Boolean_t
tgt_update_value_str(tgt_node_t *node, char *name, char *str)
{
if ((node == NULL) || (strcmp(name, node->x_name) != 0))
return (False);
if (node->x_value != NULL)
free(node->x_value);
node->x_value = strdup(str);
node->x_state = NodeValue;
return (True);
}
tgt_node_t *
tgt_node_find(tgt_node_t *n, char *name)
{
tgt_node_t *rval;
for (rval = n->x_child; rval; rval = rval->x_sibling)
if (strcmp(rval->x_name, name) == 0)
break;
return (rval);
}
tgt_node_t *
tgt_node_dup(tgt_node_t *n)
{
tgt_node_t *d = node_alloc();
tgt_node_t *c;
if (d == NULL)
return (NULL);
if (node_name(d, (xmlChar *)n->x_name) == False)
return (NULL);
if (n->x_value && (node_value(d, (xmlChar *)n->x_value, True) == False))
return (NULL);
for (c = n->x_child; c; c = c->x_sibling)
(void) tgt_node_add(d, tgt_node_dup(c));
for (c = n->x_attr; c; c = c->x_sibling)
(void) tgt_node_add_attr(d, tgt_node_dup(c));
return (d);
}
#define MAX_REPLACEMENT_ENTITY 8
#define MAX_REPLACEMENT_BUFFER 1024
void
tgt_buf_add(char **b, char *element, const char *cdata)
{
char entity[MAX_REPLACEMENT_ENTITY];
char buf[MAX_REPLACEMENT_BUFFER];
int len, i;
bzero(buf, sizeof (buf));
tgt_buf_add_tag(b, element, Tag_Start);
/*
* we have to transform the predefined xml entities;
*/
if (cdata != NULL) {
len = strlen(cdata);
for (i = 0; i < len; i++) {
switch (cdata[i]) {
case '&':
(void) strcpy(entity, "&");
break;
case '<':
(void) strcpy(entity, "<");
break;
case '>':
(void) strcpy(entity, ">");
break;
case '\'':
(void) strcpy(entity, "'");
break;
case '"':
(void) strcpy(entity, """);
break;
default:
entity[0] = cdata[i];
entity[1] = '\0';
break;
}
(void) strlcat(buf, entity, sizeof (buf));
}
tgt_buf_add_tag(b, buf, Tag_String);
}
tgt_buf_add_tag(b, element, Tag_End);
}
/*
* []----
* | tgt_buf_add_tag -- adds string to buffer allocating space, sets up tags too
* |
* | Helper function to build a string by allocating memory as we go.
* | If the string argument 'str' is defined to be a start or end tag
* | as declared by 'type' argument add the appropriate characters.
* []----
*/
void
tgt_buf_add_tag(char **b, const char *str, val_type_t type)
{
char *buf;
int len;
/*
* We will add potentially up to 3 extra characters plus the NULL byte
*/
len = strlen(str) + 4;
if ((buf = malloc(len)) == NULL)
return;
(void) snprintf(buf, len, "%s%s%s%s", type == Tag_String ? "" : "<",
type == Tag_End ? "/" : "", str, type == Tag_String ? "" : ">");
buf_add_str(b, buf);
free(buf);
}
/*
* []----
* | tgt_buf_add_tag_and_attr -- variant on tgt_buf_add_tag which also gives
* | attr
* []----
*/
void
tgt_buf_add_tag_and_attr(char **b, char *str, char *attr)
{
char *buf;
int len;
/*
* In addition to the 'str' and 'attr' strings the code will add
* three characters plus a null byte.
*/
len = strlen(str) + strlen(attr) + 4;
if ((buf = malloc(len)) == NULL)
return;
(void) snprintf(buf, len, "<%s %s>", str, attr);
buf_add_str(b, buf);
free(buf);
}
/*
* []----
* | Utility functions
* []----
*/
static tgt_node_t *
node_alloc()
{
tgt_node_t *x = (tgt_node_t *)calloc(sizeof (tgt_node_t), 1);
if (x == NULL)
return (NULL);
x->x_state = NodeAlloc;
return (x);
}
static void
node_free(tgt_node_t *x)
{
x->x_state = NodeFree;
if (x->x_name)
free(x->x_name);
if (x->x_value)
free(x->x_value);
free(x);
}
static Boolean_t
node_name(tgt_node_t *x, const xmlChar *n)
{
assert(x->x_state == NodeAlloc);
if ((n == NULL) || (strlen((char *)n) == 0))
return (False);
x->x_state = NodeName;
x->x_name = strip_space((char *)n);
return (True);
}
static Boolean_t
node_value(tgt_node_t *x, const xmlChar *n, Boolean_t do_strip)
{
assert(x->x_state == NodeName);
if ((n == NULL) || (strlen((char *)n) == NULL))
return (False);
x->x_state = NodeValue;
x->x_value = (do_strip == True) ?
strip_space((char *)n) : strdup((char *)n);
return (True);
}
static tgt_node_t *
node_parent(tgt_node_t *x)
{
return (x->x_parent);
}
static tgt_node_t *
node_child(tgt_node_t *x)
{
tgt_node_t *n;
if ((n = node_alloc()) == NULL)
return (NULL);
if (x->x_child == NULL) {
x->x_child = n;
} else {
n->x_sibling = x->x_child;
x->x_child = n;
}
n->x_parent = x;
return (n);
}
static tgt_node_t *
node_alloc_attr(tgt_node_t *x)
{
tgt_node_t *n;
tgt_node_t *next;
n = node_alloc();
if (x->x_attr == NULL) {
x->x_attr = n;
} else {
for (next = x->x_attr; next->x_sibling; next = next->x_sibling)
;
next->x_sibling = n;
}
if (n != NULL)
n->x_parent = x;
return (n);
}
static void
buf_add_str(char **b, char *str)
{
int len;
int olen = 0;
char *p = *b;
/*
* Make sure we have enough room for the string and tag characters
* plus a NULL byte.
*/
if (str == NULL)
return;
len = strlen(str) + 1;
if (p == NULL) {
if ((p = malloc(len)) == NULL)
return;
} else {
olen = strlen(p);
p = realloc(p, olen + len);
}
(void) strncpy(p + olen, str, len);
*b = p;
}
static void
buf_add_node_attr(char **b, tgt_node_t *x)
{
char *buf;
tgt_node_t *n;
int len;
/* ---- null byte and starting '<' character ---- */
len = strlen(x->x_name) + 2;
if ((buf = malloc(len)) == NULL)
return;
(void) snprintf(buf, len, "<%s", x->x_name);
buf_add_str(b, buf);
free(buf);
for (n = x->x_attr; n; n = n->x_sibling) {
len = strlen(n->x_name) + strlen(n->x_value) + 5;
if ((buf = malloc(len)) == NULL)
return;
(void) snprintf(buf, len, " %s='%s'", n->x_name, n->x_value);
buf_add_str(b, buf);
free(buf);
}
buf_add_str(b, ">");
}
static void
buf_add_comment(char **b, char *comment)
{
char *p = *b;
int len;
int olen;
if (comment == NULL)
return;
/*
* Room for the strings, plus the brackets and NULL byte
*/
len = strlen(comment) + strlen(XML_COMMENT_STR) +
strlen(XML_COMMENT_END) + 3;
if (p == NULL)
p = malloc(len);
else {
olen = strlen(p);
p = realloc(p, olen + len);
}
(void) snprintf(p + olen, len, "<%s%s%s>", XML_COMMENT_STR, comment,
XML_COMMENT_END);
*b = p;
}
static char *
strip_space(char *value)
{
char *p;
char *n;
for (p = value; p && *p; p++)
if (!isspace(*p))
break;
if ((p == NULL) || (*p == '\0'))
return (NULL);
p = strdup(p);
for (n = (p + strlen(p) - 1); n >= p; n--)
if (!isspace(*n)) {
n++;
break;
}
*n = '\0';
return (p);
}