OpenSolaris_b135/lib/libpool/common/pool_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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <thread.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <libxml/debugXML.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlerror.h>
#include <libxml/xpath.h>
#include <libxml/xmlmemory.h>
#include <pool.h>
#include "pool_internal.h"
#include "pool_impl.h"
#include "pool_xml_impl.h"
/*
* libpool XML Manipulation Routines
*
* pool_xml.c implements the XML manipulation routines used by the libpool
* XML datastore. The functions are grouped into the following logical areas
* - Result Sets
* The XPath API is used to search the XML document represented by a
* configuration. The results of XPath queries are represented through
* pool_result_set_t structures as part of the abstraction of the datastore
* representation. (see pool.c comment for more details)
*
* - Property Manipulation
* Validated XML (XML associated with a DTD) does not allow the introduction
* of attributes which are not recognised by the DTD. This is a limitation
* since we want to allow libpool to associate an arbitrary number of
* properties with an element. The property manipulation code overcomes this
* limitation by allowing property sub-elements to be created and manipulated
* through a single API so that they are indistinguishable from attributes
* to the libpool user.
*
* - XML Element/Attribute Manipulation
* These routines manipulate XML elements and attributes and are the routines
* which interact most directly with libxml.
*
* - File Processing/IO
* Since libpool must present its data in a consistent fashion, we have to
* implement file locking above libxml. These routines allow us to lock files
* during processing and maintain data integrity between processes. Note
* that locks are at the process scope and are advisory (see fcntl).
*
* - Utilities
* Sundry utility functions that aren't easily categorised.
*/
#define MAX_PROP_SIZE 1024 /* Size of property buffer */
/*
* The PAGE_READ_SIZE value is used to determine the size of the input buffer
* used to parse XML files.
*/
#define PAGE_READ_SIZE 8192
#define ELEM_TYPE_COUNT 6 /* Count of Element types */
typedef struct dtype_tbl
{
xmlChar *dt_name;
int dt_type;
} dtype_tbl_t;
typedef struct elem_type_tbl
{
xmlChar *ett_elem;
dtype_tbl_t (*ett_dtype)[];
} elem_type_tbl_t;
extern int xmlDoValidityCheckingDefaultValue;
/*
* The _xml_lock is used to lock the state of libpool during
* xml initialisation operations.
*/
static mutex_t _xml_lock;
const char *element_class_tags[] = {
"any",
"system",
"pool",
"res_comp",
"res_agg",
"comp",
NULL
};
static const char *data_type_tags[] = {
"uint",
"int",
"float",
"boolean",
"string"
};
const char *dtd_location = "file:///usr/share/lib/xml/dtd/rm_pool.dtd.1";
static elem_type_tbl_t elem_tbl[ELEM_TYPE_COUNT] = {0};
/* libpool initialisation indicator */
static int _libpool_xml_initialised = PO_FALSE;
/*
* Utility functions
*/
/*
* Those functions which are not static are shared with pool_kernel.c
* They provide the required XML support for exporting a kernel
* configuration as an XML document.
*/
void xml_init(void);
static int create_shadow(xmlNodePtr node);
static int pool_xml_free_doc(pool_conf_t *conf);
static int prop_sort(const void *a, const void *b);
static int dtd_exists(const char *path);
static void build_dtype_accelerator(void);
static dtype_tbl_t (*build_dtype_tbl(const xmlChar *rawdata))[];
static int get_fast_dtype(xmlNodePtr node, xmlChar *name);
static int pool_assoc_default_resource_type(pool_t *,
pool_resource_elem_class_t);
/*
* XML Data access and navigation APIs
*/
static int pool_build_xpath_buf(pool_xml_connection_t *, const pool_elem_t *,
pool_elem_class_t, pool_value_t **, char_buf_t *, int);
/*
* SHARED WITH pool_kernel.c for XML export support
*/
xmlNodePtr node_create(xmlNodePtr parent, const xmlChar *name);
static xmlNodePtr node_create_with_id(xmlNodePtr parent, const xmlChar *name);
/* Configuration */
static int pool_xml_close(pool_conf_t *);
static int pool_xml_validate(const pool_conf_t *, pool_valid_level_t);
static int pool_xml_commit(pool_conf_t *conf);
static int pool_xml_export(const pool_conf_t *conf, const char *location,
pool_export_format_t fmt);
static int pool_xml_rollback(pool_conf_t *conf);
static pool_result_set_t *pool_xml_exec_query(const pool_conf_t *conf,
const pool_elem_t *src, const char *src_attr,
pool_elem_class_t classes, pool_value_t **props);
static int pool_xml_remove(pool_conf_t *conf);
static int pool_xml_res_transfer(pool_resource_t *, pool_resource_t *,
uint64_t);
static int pool_xml_res_xtransfer(pool_resource_t *, pool_resource_t *,
pool_component_t **);
/* Connections */
static void pool_xml_connection_free(pool_xml_connection_t *prov);
/* Result Sets */
static pool_xml_result_set_t *pool_xml_result_set_alloc(const pool_conf_t *);
static void pool_xml_result_set_free(pool_xml_result_set_t *rs);
static pool_elem_t *pool_xml_rs_next(pool_result_set_t *set);
static pool_elem_t *pool_xml_rs_prev(pool_result_set_t *set);
static pool_elem_t *pool_xml_rs_first(pool_result_set_t *set);
static pool_elem_t *pool_xml_rs_last(pool_result_set_t *set);
static int pool_xml_rs_set_index(pool_result_set_t *set, int index);
static int pool_xml_rs_get_index(pool_result_set_t *set);
static int pool_xml_rs_count(pool_result_set_t *set);
static int pool_xml_rs_close(pool_result_set_t *set);
/* Element (and sub-type) */
static void pool_xml_elem_init(pool_conf_t *conf, pool_xml_elem_t *elem,
pool_elem_class_t, pool_resource_elem_class_t, pool_component_elem_class_t);
static int pool_xml_elem_wrap(xmlNodePtr node, pool_elem_class_t class,
pool_resource_elem_class_t, pool_component_elem_class_t);
static pool_elem_t *pool_xml_elem_create(pool_conf_t *, pool_elem_class_t,
pool_resource_elem_class_t, pool_component_elem_class_t);
static int pool_xml_elem_remove(pool_elem_t *pe);
static int pool_xml_set_container(pool_elem_t *, pool_elem_t *);
static pool_elem_t *pool_xml_get_container(const pool_elem_t *);
/*
* Pool element specific
*/
static int pool_xml_pool_associate(pool_t *, const pool_resource_t *);
static int pool_xml_pool_dissociate(pool_t *, const pool_resource_t *);
/*
* Resource elements specific
*/
static int pool_xml_resource_is_system(const pool_resource_t *);
static int pool_xml_resource_can_associate(const pool_resource_t *);
/* Properties */
static pool_value_class_t pool_xml_get_property(const pool_elem_t *,
const char *, pool_value_t *);
static int pool_xml_put_property(pool_elem_t *, const char *,
const pool_value_t *);
static int pool_xml_rm_property(pool_elem_t *, const char *);
static xmlNodePtr property_create(xmlNodePtr, const char *,
pool_value_class_t);
/* Internal Attribute/Property manipulation */
static int pool_is_xml_attr(xmlDocPtr, const char *, const char *);
static pool_value_class_t pool_xml_get_attr(xmlNodePtr node, xmlChar *name,
pool_value_t *value);
int pool_xml_set_attr(xmlNodePtr node, xmlChar *name,
const pool_value_t *value);
static pool_value_class_t pool_xml_get_prop(xmlNodePtr node, xmlChar *name,
pool_value_t *value);
int pool_xml_set_prop(xmlNodePtr node, xmlChar *name,
const pool_value_t *value);
static pool_value_t **pool_xml_get_properties(const pool_elem_t *, uint_t *);
/* XML Error handling */
void pool_error_func(void *ctx, const char *msg, ...);
/* XML File Input Processing */
static int pool_xml_open_file(pool_conf_t *conf);
static int pool_xml_parse_document(pool_conf_t *);
/*
* Initialise this module
*/
void
xml_init()
{
(void) mutex_lock(&_xml_lock);
if (_libpool_xml_initialised == PO_TRUE) {
(void) mutex_unlock(&_xml_lock);
return;
}
xmlInitParser();
/*
* DTD validation, with line numbers.
*/
(void) xmlLineNumbersDefault(1);
xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
xmlDoValidityCheckingDefaultValue = 1;
/* Try to improve indentation and readability */
(void) xmlKeepBlanksDefault(0);
/* Send all XML errors to our debug handler */
xmlSetGenericErrorFunc(NULL, pool_error_func);
/* Load up DTD element a-dtype data to improve performance */
build_dtype_accelerator();
_libpool_xml_initialised = PO_TRUE;
(void) mutex_unlock(&_xml_lock);
}
/*
* Get the next ID for this configuration
*/
static int
get_unique_id(xmlNodePtr node, char *id)
{
pool_value_t val = POOL_VALUE_INITIALIZER;
uint64_t nid = 0;
if (node->doc->_private) {
if (pool_get_ns_property(
pool_conf_to_elem((pool_conf_t *)node->doc->_private),
"_next_id", &val) == POC_UINT)
(void) pool_value_get_uint64(&val, &nid);
}
if (snprintf(id, KEY_BUFFER_SIZE, "id_%llx", nid) > KEY_BUFFER_SIZE) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
pool_value_set_uint64(&val, ++nid);
return (pool_put_ns_property(
pool_conf_to_elem((pool_conf_t *)node->doc->_private), "_next_id",
&val));
}
/* Document building functions */
/*
* node_create() creates a child node of type name of the supplied parent in
* the supplied document. If the parent or document is NULL, create the node
* but do not associate it with a parent or document.
*/
xmlNodePtr
node_create(xmlNodePtr parent, const xmlChar *name)
{
xmlNodePtr node;
if (parent == NULL)
node = xmlNewNode(NULL, name);
else
node = xmlNewChild(parent, NULL, name, NULL);
return (node);
}
/*
* node_create_with_id() creates a child node of type name of the supplied
* parent with the ref_id generated by get_unique_id(). Actual node creation
* is performed by node_create() and this function just sets the ref_id
* property to the value of the id.
*/
static xmlNodePtr
node_create_with_id(xmlNodePtr parent, const xmlChar *name)
{
char id[KEY_BUFFER_SIZE]; /* Must be big enough for key below */
xmlNodePtr node = node_create(parent, name);
if (node != NULL) {
if (get_unique_id(node, id) != PO_SUCCESS) {
xmlUnlinkNode(node);
xmlFreeNode(node); /* recurses all children */
pool_seterror(POE_DATASTORE);
return (NULL);
}
if (xmlSetProp(node, BAD_CAST c_ref_id, BAD_CAST id) == NULL) {
xmlUnlinkNode(node);
xmlFreeNode(node); /* recurses all children */
pool_seterror(POE_DATASTORE);
return (NULL);
}
}
return (node);
}
/* Supporting Data Conversion Routines */
/* XML Parser Utility Functions */
/*
* Handler for XML Errors. Called by libxml at libxml Error.
*/
/*ARGSUSED*/
void
pool_error_func(void *ctx, const char *msg, ...)
{
va_list ap;
va_start(ap, msg);
do_dprintf(msg, ap);
va_end(ap);
}
/*
* Free the shadowed elements from within the supplied document and then
* free the document. This function should always be called when freeing
* a pool document to ensure that all "shadow" resources are reclaimed.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_free_doc(pool_conf_t *conf)
{
/* Only do any of this if there is a document */
if (((pool_xml_connection_t *)conf->pc_prov)->pxc_doc != NULL) {
pool_elem_t *pe;
pool_result_set_t *rs;
/* Delete all the "shadowed" children of the doc */
rs = pool_exec_query(conf, NULL, NULL, PEC_QRY_ANY, NULL);
if (rs == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
for (pe = rs->prs_next(rs); pe != NULL; pe = rs->prs_next(rs)) {
/*
* Work out the element type and free the elem
*/
free(pe);
}
(void) pool_rs_close(rs);
xmlFreeDoc(((pool_xml_connection_t *)conf->pc_prov)->pxc_doc);
}
((pool_xml_connection_t *)conf->pc_prov)->pxc_doc = NULL;
return (PO_SUCCESS);
}
/*
* Remove an element from the document. Note that only three types of elements
* can be removed, res, comp and pools. comp are moved around to the
* default res when a res is deleted.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_elem_remove(pool_elem_t *pe)
{
pool_xml_elem_t *pxe = (pool_xml_elem_t *)pe;
/*
* You can only destroy three elements: pools, resources and
* components.
*/
switch (pe->pe_class) {
case PEC_POOL:
case PEC_RES_COMP:
case PEC_RES_AGG:
case PEC_COMP:
if (pxe->pxe_node) {
xmlUnlinkNode(pxe->pxe_node);
xmlFreeNode(pxe->pxe_node); /* recurses all children */
}
free(pxe);
break;
default:
break;
}
return (PO_SUCCESS);
}
/*
* Create a property element.
*/
static xmlNodePtr
property_create(xmlNodePtr parent, const char *name, pool_value_class_t type)
{
xmlNodePtr element;
pool_value_t val = POOL_VALUE_INITIALIZER;
if ((element = node_create(parent, BAD_CAST "property")) == NULL) {
pool_seterror(POE_DATASTORE);
return (NULL);
}
if (pool_value_set_string(&val, name) != PO_SUCCESS) {
xmlFree(element);
return (NULL);
}
(void) pool_xml_set_attr(element, BAD_CAST c_name, &val);
if (pool_value_set_string(&val, data_type_tags[type]) != PO_SUCCESS) {
xmlFree(element);
return (NULL);
}
(void) pool_xml_set_attr(element, BAD_CAST c_type, &val);
return (element);
}
/*
* External clients need to be able to put/get properties and this is the
* way to do it.
* This function is an interceptor, since it will *always* try to manipulate
* an attribute first. If the attribute doesn't exist, then it will treat
* the request as a property request.
*/
static pool_value_class_t
pool_xml_get_property(const pool_elem_t *pe, const char *name,
pool_value_t *val)
{
pool_value_class_t type;
pool_xml_elem_t *pxe = (pool_xml_elem_t *)pe;
/*
* "type" is a special attribute which is not visible ever outside of
* libpool. Use the specific type accessor function.
*/
if (strcmp(name, c_type) == 0) {
return (pool_xml_get_attr(pxe->pxe_node, BAD_CAST name,
val));
}
if (is_ns_property(pe, name) != NULL) { /* in ns */
if ((type = pool_xml_get_attr(pxe->pxe_node,
BAD_CAST property_name_minus_ns(pe, name), val))
== POC_INVAL)
return (pool_xml_get_prop(pxe->pxe_node, BAD_CAST name,
val));
} else
return (pool_xml_get_prop(pxe->pxe_node, BAD_CAST name, val));
return (type);
}
/*
* Put a property on an element. Check if the property is an attribute,
* if it is update that value. If not add a property element.
*
* There are three possible conditions here:
* - the name is a ns
* - the name is an attribute
* - the name isn't an attribute
* - the name is not a ns
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_put_property(pool_elem_t *pe, const char *name,
const pool_value_t *val)
{
pool_xml_elem_t *pxe = (pool_xml_elem_t *)pe;
/*
* "type" is a special attribute which is not visible ever outside of
* libpool. Use the specific type accessor function.
*/
if (strcmp(name, c_type) == 0) {
return (pool_xml_set_attr(pxe->pxe_node, BAD_CAST name,
val));
}
if (is_ns_property(pe, name) != NULL) { /* in ns */
if (pool_xml_set_attr(pxe->pxe_node,
BAD_CAST property_name_minus_ns(pe, name), val) == PO_FAIL)
return (pool_xml_set_prop(pxe->pxe_node, BAD_CAST name,
val));
} else
return (pool_xml_set_prop(pxe->pxe_node, BAD_CAST name, val));
return (PO_SUCCESS);
}
/*
* Remove a property from an element. Check if the property is an attribute,
* if it is fail. Otherwise remove the property subelement.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_rm_property(pool_elem_t *pe, const char *name)
{
pool_xml_elem_t *pxe = (pool_xml_elem_t *)pe;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr path;
char buf[MAX_PROP_SIZE];
int ret;
if (xmlHasProp(pxe->pxe_node, BAD_CAST name) != NULL) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
/* use xpath to find the node with the appropriate value for name */
(void) snprintf(buf, sizeof (buf), "property[@name=\"%s\"]", name);
if ((ctx = xmlXPathNewContext(pxe->pxe_node->doc)) == NULL) {
pool_seterror(POE_PUTPROP);
return (PO_FAIL);
}
ctx->node = pxe->pxe_node;
path = xmlXPathEval(BAD_CAST buf, ctx);
if (path && (path->type == XPATH_NODESET) &&
(path->nodesetval->nodeNr == 1)) {
xmlUnlinkNode(path->nodesetval->nodeTab[0]);
xmlFreeNode(path->nodesetval->nodeTab[0]);
ret = PO_SUCCESS;
} else {
pool_seterror(POE_BADPARAM);
ret = PO_FAIL;
}
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
return (ret);
}
/*
* Get the data type for an attribute name from the element node. The data
* type is returned and the value of the attribute updates the supplied value
* pointer.
*/
static pool_value_class_t
pool_xml_get_attr(xmlNodePtr node, xmlChar *name, pool_value_t *value)
{
pool_value_class_t data_type;
xmlChar *data;
uint64_t uval;
int64_t ival;
if (xmlHasProp(node, name) == NULL && pool_is_xml_attr(node->doc,
(const char *) node->name, (const char *) name) == PO_FALSE) {
pool_seterror(POE_BADPARAM);
return (POC_INVAL);
}
if (xmlHasProp(node, BAD_CAST c_a_dtype) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (POC_INVAL);
}
data = xmlGetProp(node, name);
data_type = get_fast_dtype(node, name);
if (data_type != POC_STRING && data == NULL) {
pool_seterror(POE_INVALID_CONF);
return (POC_INVAL);
}
switch (data_type) {
case POC_UINT:
errno = 0;
uval = strtoull((char *)data, NULL, 0);
if (errno != 0) {
data_type = POC_INVAL;
}
else
pool_value_set_uint64(value, uval);
break;
case POC_INT:
errno = 0;
ival = strtoll((char *)data, NULL, 0);
if (errno != 0) {
data_type = POC_INVAL;
}
else
pool_value_set_int64(value, ival);
break;
case POC_DOUBLE:
pool_value_set_double(value, atof((const char *)data));
break;
case POC_BOOL:
if (strcmp((const char *)data, "true") == 0)
pool_value_set_bool(value, PO_TRUE);
else
pool_value_set_bool(value, PO_FALSE);
break;
case POC_STRING:
if (pool_value_set_string(value, data ?
(const char *)data : "") != PO_SUCCESS) {
xmlFree(data);
return (POC_INVAL);
}
break;
case POC_INVAL:
default:
break;
}
xmlFree(data);
return (data_type);
}
/*
* Set the data type for an attribute name from the element node. The
* supplied value is used to update the designated name using the data
* type supplied.
*/
int
pool_xml_set_attr(xmlNodePtr node, xmlChar *name, const pool_value_t *value)
{
xmlChar buf[MAX_PROP_SIZE] = {0};
uint64_t ures;
int64_t ires;
uchar_t bres;
double dres;
const char *sres;
pool_value_class_t data_type;
if (xmlHasProp(node, name) == NULL && pool_is_xml_attr(node->doc,
(const char *) node->name, (const char *) name) == PO_FALSE) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
if (xmlHasProp(node, BAD_CAST c_a_dtype) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
data_type = get_fast_dtype(node, name);
if (data_type != value->pv_class) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
switch (value->pv_class) {
case POC_UINT:
(void) pool_value_get_uint64(value, &ures);
(void) snprintf((char *)buf, sizeof (buf), "%llu",
(u_longlong_t)ures);
break;
case POC_INT:
(void) pool_value_get_int64(value, &ires);
(void) snprintf((char *)buf, sizeof (buf), "%lld",
(longlong_t)ires);
break;
case POC_DOUBLE:
(void) pool_value_get_double(value, &dres);
(void) snprintf((char *)buf, sizeof (buf), "%f", dres);
break;
case POC_BOOL:
(void) pool_value_get_bool(value, &bres);
if (bres == PO_FALSE)
(void) snprintf((char *)buf, sizeof (buf),
"false");
else
(void) snprintf((char *)buf, sizeof (buf),
"true");
break;
case POC_STRING:
(void) pool_value_get_string(value, &sres);
if (sres != NULL)
(void) snprintf((char *)buf, sizeof (buf), "%s",
sres);
break;
case POC_INVAL:
default:
break;
}
if (xmlSetProp(node, name, buf) == NULL) {
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Get the data type for a property name from the element node. The data
* type is returned and the value of the property updates the supplied value
* pointer. The user is responsible for freeing the memory associated with
* a string.
*/
static pool_value_class_t
pool_xml_get_prop(xmlNodePtr node, xmlChar *name, pool_value_t *value)
{
pool_value_class_t data_type;
xmlChar *data, *node_data;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr path;
char buf[MAX_PROP_SIZE];
int64_t uval;
int64_t ival;
/* use xpath to find the node with the appropriate value for name */
(void) snprintf(buf, sizeof (buf), "property[@name=\"%s\"]", name);
if ((ctx = xmlXPathNewContext(node->doc)) == NULL) {
pool_seterror(POE_BADPARAM);
return (POC_INVAL);
}
ctx->node = node;
path = xmlXPathEval(BAD_CAST buf, ctx);
if (path && (path->type == XPATH_NODESET) &&
(path->nodesetval->nodeNr == 1)) {
int i;
if (xmlHasProp(path->nodesetval->nodeTab[0],
BAD_CAST c_type) == NULL) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_INVALID_CONF);
return (POC_INVAL);
}
/* type is a string representation of the type */
data = xmlGetProp(path->nodesetval->nodeTab[0],
BAD_CAST c_type);
node_data = xmlNodeGetContent(path->nodesetval->nodeTab[0]);
data_type = POC_INVAL;
for (i = 0; i < (sizeof (data_type_tags) /
sizeof (data_type_tags[0])); i++) {
if (strcmp((char *)data, data_type_tags[i]) == 0) {
data_type = i;
break;
}
}
switch (data_type) {
case POC_UINT:
errno = 0;
uval = strtoull((char *)node_data, NULL, 0);
if (errno != 0)
data_type = POC_INVAL;
else
pool_value_set_uint64(value, uval);
break;
case POC_INT:
errno = 0;
ival = strtoll((char *)node_data, NULL, 0);
if (errno != 0)
data_type = POC_INVAL;
else
pool_value_set_int64(value, ival);
break;
case POC_DOUBLE:
pool_value_set_double(value,
atof((const char *)node_data));
break;
case POC_BOOL:
if (strcmp((const char *)node_data, "true")
== 0)
pool_value_set_bool(value, PO_TRUE);
else
pool_value_set_bool(value, PO_FALSE);
break;
case POC_STRING:
if (pool_value_set_string(value,
(const char *)node_data) != PO_SUCCESS) {
data_type = POC_INVAL;
break;
}
break;
case POC_INVAL:
default:
break;
}
xmlFree(data);
xmlFree(node_data);
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
return (data_type);
} else { /* No property exists, clean up and return */
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_BADPARAM);
return (POC_INVAL);
}
}
/*
* Set the data type for a property name from the element node. The
* supplied value is used to update the designated name using the data
* type supplied.
*/
int
pool_xml_set_prop(xmlNodePtr node, xmlChar *name, const pool_value_t *value)
{
/* First check if we have a property with this name (and type???). */
xmlXPathContextPtr ctx;
xmlXPathObjectPtr path;
xmlChar buf[MAX_PROP_SIZE];
xmlNodePtr element;
uint64_t ures;
int64_t ires;
uchar_t bres;
double dres;
const char *sres;
/* use xpath to find the node with the appropriate value for name */
(void) snprintf((char *)buf, sizeof (buf), "property[@name=\"%s\"]",
name);
if ((ctx = xmlXPathNewContext(node->doc)) == NULL) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
ctx->node = node;
path = xmlXPathEval(buf, ctx);
if (path == NULL || path->type != XPATH_NODESET) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
} else {
if (path->nodesetval->nodeNr == 0)
element = property_create
(node, (const char *)name, value->pv_class);
else if (path->nodesetval->nodeNr == 1) {
int i;
xmlChar *data;
element = path->nodesetval->nodeTab[0];
if (xmlHasProp(element, BAD_CAST c_type) == NULL) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
data = xmlGetProp(element, BAD_CAST c_type);
for (i = 0; i < (sizeof (data_type_tags) /
sizeof (data_type_tags[0])); i++)
if (strcmp((char *)data, data_type_tags[i])
== 0) {
break;
}
xmlFree(data);
if (value->pv_class != i) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
} else {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
}
switch (value->pv_class) {
case POC_UINT:
(void) pool_value_get_uint64(value, &ures);
(void) snprintf((char *)buf, sizeof (buf), "%llu",
(u_longlong_t)ures);
break;
case POC_INT:
(void) pool_value_get_int64(value, &ires);
(void) snprintf((char *)buf, sizeof (buf), "%lld",
(longlong_t)ires);
break;
case POC_DOUBLE:
(void) pool_value_get_double(value, &dres);
(void) snprintf((char *)buf, sizeof (buf), "%f", dres);
break;
case POC_BOOL:
(void) pool_value_get_bool(value, &bres);
if (bres == PO_FALSE)
(void) snprintf((char *)buf, sizeof (buf),
"false");
else
(void) snprintf((char *)buf, sizeof (buf),
"true");
break;
case POC_STRING:
(void) pool_value_get_string(value, &sres);
(void) snprintf((char *)buf, sizeof (buf), "%s", sres);
break;
case POC_INVAL:
default:
break;
}
xmlNodeSetContent(element, buf);
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
return (PO_SUCCESS);
}
/*
* Return a NULL terminated array of pool_value_t which represents all
* of the properties stored for an element
*
* Return NULL on failure. It is the caller's responsibility to free
* the returned array of values.
*/
pool_value_t **
pool_xml_get_properties(const pool_elem_t *pe, uint_t *nprops)
{
pool_value_t **result;
pool_xml_elem_t *pxe = (pool_xml_elem_t *)pe;
int i, j;
pool_conf_t *conf = TO_CONF(pe);
xmlElementPtr elemDTD;
xmlAttributePtr attr;
xmlXPathContextPtr ctx;
xmlXPathObjectPtr path;
char_buf_t *cb = NULL;
*nprops = 0;
elemDTD = xmlGetDtdElementDesc(pxe->pxe_node->doc->extSubset,
pxe->pxe_node->name);
for (attr = elemDTD->attributes; attr != NULL; attr = attr->nexth) {
if (strcmp((const char *)attr->name, c_a_dtype) != 0 ||
strcmp((const char *)attr->name, c_type) != 0)
(*nprops)++;
}
if ((ctx = xmlXPathNewContext(
((pool_xml_connection_t *)conf->pc_prov)->pxc_doc)) == NULL) {
pool_seterror(POE_BADPARAM);
return (NULL);
}
ctx->node = pxe->pxe_node;
path = xmlXPathEval(BAD_CAST "property", ctx);
if (path != NULL && path->type == XPATH_NODESET &&
path->nodesetval != NULL)
(*nprops) += path->nodesetval->nodeNr;
if ((result = calloc(*nprops + 1, sizeof (pool_value_t *))) == NULL) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
pool_seterror(POE_SYSTEM);
return (NULL);
}
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
free(result);
return (NULL);
}
/*
* Now store our attributes and properties in result
*/
for (i = 0, attr = elemDTD->attributes; attr != NULL;
attr = attr->nexth, i++) {
if (strcmp((const char *)attr->name, c_a_dtype) == 0 ||
strcmp((const char *)attr->name, c_type) == 0) {
i--;
continue;
}
result[i] = pool_value_alloc();
if (pool_xml_get_attr(pxe->pxe_node,
BAD_CAST attr->name, result[i]) == POC_INVAL) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
free_char_buf(cb);
return (NULL);
}
if (strcmp((const char *)attr->name, c_type) != 0) {
if (set_char_buf(cb, "%s.%s",
pool_elem_class_string(pe), attr->name) !=
PO_SUCCESS) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
free_char_buf(cb);
return (NULL);
}
if (pool_value_set_name(result[i], cb->cb_buf) !=
PO_SUCCESS) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
free_char_buf(cb);
return (NULL);
}
} else {
if (pool_value_set_name(result[i],
(const char *)attr->name) != PO_SUCCESS) {
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
free_char_buf(cb);
return (NULL);
}
}
}
free_char_buf(cb);
for (j = 0; j < path->nodesetval->nodeNr; j++, i++) {
xmlChar *name = xmlGetProp(path->nodesetval->nodeTab[j],
BAD_CAST c_name);
result[i] = pool_value_alloc();
if (pool_xml_get_prop(pxe->pxe_node, name, result[i]) ==
POC_INVAL) {
xmlFree(name);
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
return (NULL);
}
if (pool_value_set_name(result[i], (const char *)name) !=
PO_SUCCESS) {
xmlFree(name);
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
return (NULL);
}
xmlFree(name);
}
xmlXPathFreeObject(path);
xmlXPathFreeContext(ctx);
return (result);
}
/*
* Store a pointer to one of our data types in the _private member of each
* XML data node contained within the passed node. Note this function is
* recursive and so all sub-nodes are also shadowed. Only shadow the nodes
* which we are interested in, i.e. system, pool, res and comp
*/
static int
create_shadow(xmlNodePtr node)
{
xmlNodePtr sib;
int ret = PO_SUCCESS;
/* Create a data structure of the appropriate type */
if (0 == (xmlStrcmp(node->name,
BAD_CAST element_class_tags[PEC_SYSTEM]))) {
ret = pool_xml_elem_wrap(node, PEC_SYSTEM, PREC_INVALID,
PCEC_INVALID);
} else if (0 == (xmlStrcmp(node->name,
BAD_CAST element_class_tags[PEC_POOL]))) {
ret = pool_xml_elem_wrap(node, PEC_POOL, PREC_INVALID,
PCEC_INVALID);
} else if (0 == (xmlStrcmp(node->name,
BAD_CAST element_class_tags[PEC_RES_COMP]))) {
xmlChar *data;
pool_resource_elem_class_t res_class;
data = xmlGetProp(node, BAD_CAST c_type);
res_class = pool_resource_elem_class_from_string((char *)data);
xmlFree(data);
ret = pool_xml_elem_wrap(node, PEC_RES_COMP, res_class,
PCEC_INVALID);
} else if (0 == (xmlStrcmp(node->name,
BAD_CAST element_class_tags[PEC_RES_AGG]))) {
xmlChar *data;
pool_resource_elem_class_t res_class;
data = xmlGetProp(node, BAD_CAST c_type);
res_class = pool_resource_elem_class_from_string((char *)data);
xmlFree(data);
ret = pool_xml_elem_wrap(node, PEC_RES_AGG, res_class,
PCEC_INVALID);
} else if (0 == (xmlStrcmp(node->name,
BAD_CAST element_class_tags[PEC_COMP]))) {
xmlChar *data;
pool_component_elem_class_t comp_class;
data = xmlGetProp(node, BAD_CAST c_type);
comp_class = pool_component_elem_class_from_string(
(char *)data);
xmlFree(data);
ret = pool_xml_elem_wrap(node, PEC_COMP, PREC_INVALID,
comp_class);
}
/* Have to shadow all children and all siblings */
for (sib = node->children; sib != NULL; sib = sib->next) {
if ((ret = create_shadow(sib)) != PO_SUCCESS)
break;
}
return (ret);
}
/*
* XML Data access and navigation APIs
*/
/*
* Close the configuration. There are a few steps to closing a configuration:
* - Unlock the backing file (if there is one)
* - Close the file (if there is one)
* - Free the shadow memory }Done in pool_xml_free_doc
* - Free the document }
* - Free the data provider for this configuration
* - Free the configuration location specifier
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_close(pool_conf_t *conf)
{
pool_xml_connection_t *pxc = (pool_xml_connection_t *)conf->pc_prov;
int ret = PO_SUCCESS;
if (pxc->pxc_file != NULL) {
/* Close (and implicitly) unlock the file */
if (fclose(pxc->pxc_file) != 0) {
pool_seterror(POE_SYSTEM);
ret = PO_FAIL;
}
pxc->pxc_file = NULL;
}
/* Close the xml specific parts */
(void) pool_xml_free_doc(conf);
pool_xml_connection_free((pool_xml_connection_t *)conf->pc_prov);
return (ret);
}
/*
* Remove the configuration from the backing store. In XML terms delete
* the file backing the configuration. You need a copy of the location
* since the pool_conf_close function, frees the location.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_remove(pool_conf_t *conf)
{
if (pool_conf_location(conf) != NULL) {
/* First unlink the file, to prevent races on open */
if (unlink(pool_conf_location(conf)) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/* Now close the configuration */
(void) pool_conf_close(conf);
return (PO_SUCCESS);
}
return (PO_FAIL);
}
/*
* Validate the configuration. There are three levels of validation, loose,
* strict and runtime. In this, XML, implementation, loose is mapped to XML
* validation, strict implements additional application level validation
* checks, e.g. all pools must have unique names, runtime ensures that this
* configuration would instantiate on the current system.
*
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_validate(const pool_conf_t *conf, pool_valid_level_t level)
{
pool_xml_connection_t *pxc = (pool_xml_connection_t *)conf->pc_prov;
xmlValidCtxtPtr cvp;
if ((cvp = xmlNewValidCtxt()) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
cvp->error = pool_error_func;
cvp->warning = pool_error_func;
if (xmlValidateDocument(cvp, pxc->pxc_doc) == 0) {
xmlFreeValidCtxt(cvp);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
xmlFreeValidCtxt(cvp);
if (level >= POV_RUNTIME) {
/*
* Note: This is resource specific.
*/
return (((pool_validate_resource(conf, "pset", c_min_prop, 0) ==
PO_SUCCESS) &&
(pool_validate_resource(conf, "pset", c_max_prop, 0) ==
PO_SUCCESS)) ? PO_SUCCESS : PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Commit the configuration to the backing store. In XML terms this means
* write the changes to the backing file. Read the comments below for details
* on exactly how this operation is performed.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_commit(pool_conf_t *conf)
{
pool_xml_connection_t *prov = (pool_xml_connection_t *)conf->pc_prov;
xmlOutputBufferPtr buf;
/*
* Ensure that the configuration file has no contents
*/
if (fseek(prov->pxc_file, 0, SEEK_SET) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (ftruncate(fileno(prov->pxc_file), 0) == -1) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Create an XML output buffer and write out the contents of the
* configuration to the file.
*/
if ((buf = xmlOutputBufferCreateFile(prov->pxc_file, NULL)) == NULL) {
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if (xmlSaveFormatFileTo(buf, prov->pxc_doc, NULL, 1) == -1) {
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Export the configuration in the specified format to the specified location.
* The only format implemented now is the native format, which saves the
* active configuration to the supplied location.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_export(const pool_conf_t *conf, const char *location,
pool_export_format_t fmt)
{
int ret;
switch (fmt) {
case POX_NATIVE:
ret = xmlSaveFormatFile(location,
((pool_xml_connection_t *)conf->pc_prov)->pxc_doc,
1);
if (ret == -1) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
} else
return (PO_SUCCESS);
default:
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
}
/*
* Discard the configuration and restore the configuration to the values
* specified in the configuration location.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_rollback(pool_conf_t *conf)
{
pool_xml_connection_t *prov = (pool_xml_connection_t *)conf->pc_prov;
/* Rollback the file pointer ready for the reparse */
if (fseek(prov->pxc_file, 0, SEEK_SET) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/* Reparse the document */
/* In XML terms this means, discard and reparse the document */
(void) pool_xml_free_doc(conf);
if (pool_xml_parse_document(conf) == PO_FAIL)
return (PO_FAIL);
return (PO_SUCCESS);
}
/*
* Allocate a new pool_elem_t in the supplied configuration of the specified
* class.
* Returns element pointer/NULL
*/
static void
pool_xml_elem_init(pool_conf_t *conf, pool_xml_elem_t *elem,
pool_elem_class_t class, pool_resource_elem_class_t res_class,
pool_component_elem_class_t comp_class)
{
pool_elem_t *pe = TO_ELEM(elem);
pe->pe_conf = conf;
pe->pe_class = class;
pe->pe_resource_class = res_class;
pe->pe_component_class = comp_class;
/* Set up the function pointers for element manipulation */
pe->pe_get_prop = pool_xml_get_property;
pe->pe_put_prop = pool_xml_put_property;
pe->pe_rm_prop = pool_xml_rm_property;
pe->pe_get_props = pool_xml_get_properties;
pe->pe_remove = pool_xml_elem_remove;
pe->pe_get_container = pool_xml_get_container;
pe->pe_set_container = pool_xml_set_container;
/*
* Specific initialisation for different types of element
*/
if (class == PEC_POOL) {
pool_xml_pool_t *pp = (pool_xml_pool_t *)elem;
pp->pp_associate = pool_xml_pool_associate;
pp->pp_dissociate = pool_xml_pool_dissociate;
}
if (class == PEC_RES_COMP || class == PEC_RES_AGG) {
pool_xml_resource_t *pr = (pool_xml_resource_t *)elem;
pr->pr_is_system = pool_xml_resource_is_system;
pr->pr_can_associate = pool_xml_resource_can_associate;
}
}
/*
* "Wrap" a suplied XML node with a pool_elem_t sub-type of the supplied
* class.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_elem_wrap(xmlNodePtr node, pool_elem_class_t class,
pool_resource_elem_class_t res_class,
pool_component_elem_class_t comp_class)
{
pool_conf_t *conf = node->doc->_private;
pool_xml_elem_t *elem;
/* Need to do some messing about to support SubTypes */
switch (class) {
case PEC_SYSTEM:
if ((elem = malloc(sizeof (pool_xml_system_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(elem, 0, sizeof (pool_xml_system_t));
break;
case PEC_POOL:
if ((elem = malloc(sizeof (pool_xml_pool_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(elem, 0, sizeof (pool_xml_pool_t));
break;
case PEC_RES_COMP:
case PEC_RES_AGG:
if ((elem = malloc(sizeof (pool_xml_resource_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(elem, 0, sizeof (pool_xml_resource_t));
break;
case PEC_COMP:
if ((elem = malloc(sizeof (pool_xml_component_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(elem, 0, sizeof (pool_xml_component_t));
break;
}
pool_xml_elem_init(conf, elem, class, res_class, comp_class);
node->_private = elem;
elem->pxe_node = node;
return (PO_SUCCESS);
}
/*
* Associate a pool to the default resource for the supplied resource
* type.
*/
int
pool_assoc_default_resource_type(pool_t *pool, pool_resource_elem_class_t type)
{
pool_value_t *props[] = { NULL, NULL, NULL };
uint_t rl_size;
pool_resource_t **rsl;
pool_conf_t *conf = TO_ELEM(pool)->pe_conf;
char_buf_t *cb = NULL;
pool_value_t val0 = POOL_VALUE_INITIALIZER;
pool_value_t val1 = POOL_VALUE_INITIALIZER;
props[0] = &val0;
props[1] = &val1;
if (pool_value_set_string(props[0], pool_resource_type_string(type)) !=
PO_SUCCESS ||
pool_value_set_name(props[0], c_type) != PO_SUCCESS) {
return (PO_FAIL);
}
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
return (PO_FAIL);
}
if (set_char_buf(cb, "%s.default",
pool_resource_type_string(type)) !=
PO_SUCCESS) {
free_char_buf(cb);
return (PO_FAIL);
}
if (pool_value_set_name(props[1], cb->cb_buf) != PO_SUCCESS) {
free_char_buf(cb);
return (PO_FAIL);
}
pool_value_set_bool(props[1], PO_TRUE);
free_char_buf(cb);
if ((rsl = pool_query_resources(conf, &rl_size, props)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
/*
* One default resource set per type
*/
if (rl_size != 1) {
free(rsl);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
if (pool_associate(conf, pool, rsl[0]) < 0) {
free(rsl);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
free(rsl);
return (PO_SUCCESS);
}
/*
* Create an XML node in the supplied configuration with a pool_elem_t
* sub-type of the supplied class.
* Returns pool_elem_t pointer/NULL
*/
static pool_elem_t *
pool_xml_elem_create(pool_conf_t *conf, pool_elem_class_t class,
pool_resource_elem_class_t res_class,
pool_component_elem_class_t comp_class)
{
/* In XML terms, create an element of the appropriate class */
pool_xml_elem_t *elem;
pool_elem_t *parent;
pool_system_t *parent_system;
if (class == PEC_INVALID) {
pool_seterror(POE_BADPARAM);
return (NULL);
}
/* Now create the XML component and add to it's parent */
/*
* If we know the class of an element, we know it's parent.
* PEC_POOL, the parent must be the system node
* PEC_RES, treat as pool.
* PEC_COMP, we don't know the parent, leave this up to the
* create_comp function.
*/
/* Since we know the subtype we can create and populate the sub-type */
switch (class) {
case PEC_POOL:
if ((parent_system = pool_conf_system(conf)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if ((parent = pool_system_elem(parent_system)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if ((elem = malloc(sizeof (pool_xml_system_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_xml_system_t));
if ((elem->pxe_node = node_create_with_id(
((pool_xml_elem_t *)parent)->pxe_node,
BAD_CAST element_class_tags[class])) == NULL) {
pool_seterror(POE_DATASTORE);
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
break;
case PEC_RES_COMP:
case PEC_RES_AGG:
if ((parent_system = pool_conf_system(conf)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if ((parent = pool_system_elem(parent_system)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if ((elem = malloc(sizeof (pool_xml_resource_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_xml_resource_t));
if ((elem->pxe_node = node_create_with_id
(((pool_xml_elem_t *)parent)->pxe_node,
BAD_CAST element_class_tags[class])) == NULL) {
pool_seterror(POE_DATASTORE);
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
break;
case PEC_COMP:
if ((elem = malloc(sizeof (pool_xml_component_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_xml_component_t));
if ((elem->pxe_node = node_create(NULL,
BAD_CAST element_class_tags[class])) == NULL) {
pool_seterror(POE_DATASTORE);
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
break;
default:
pool_seterror(POE_BADPARAM);
return (NULL);
}
pool_xml_elem_init(conf, elem, class, res_class, comp_class);
elem->pxe_node->_private = elem;
if (class == PEC_RES_COMP || class == PEC_RES_AGG ||
class == PEC_COMP) {
/*
* Put the type and an invalid sys_id on the node.
*/
if (xmlSetProp(elem->pxe_node, BAD_CAST c_sys_prop,
BAD_CAST POOL_SYSID_BAD_STRING) == NULL) {
pool_seterror(POE_DATASTORE);
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
if (xmlSetProp(elem->pxe_node, BAD_CAST c_type,
BAD_CAST pool_elem_class_string(
(pool_elem_t *)elem)) == NULL) {
pool_seterror(POE_DATASTORE);
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
}
if (class == PEC_POOL) {
/*
* Note: This is resource specific.
*/
if (pool_assoc_default_resource_type(pool_elem_pool(
(pool_elem_t *)elem), PREC_PSET) == PO_FAIL) {
(void) pool_xml_elem_remove((pool_elem_t *)elem);
return (NULL);
}
}
return ((pool_elem_t *)elem);
}
/*
* Allocate a data provider for the supplied configuration and optionally
* discover resources.
* The data provider is the cross over point from the "abstract" configuration
* functions into the data representation specific manipulation routines.
* This function sets up all the required pointers to create an XML aware
* data provider.
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_xml_connection_alloc(pool_conf_t *conf, int oflags)
{
pool_xml_connection_t *prov;
xml_init();
if ((prov = malloc(sizeof (pool_xml_connection_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(prov, 0, sizeof (pool_xml_connection_t));
/*
* Initialise data members
*/
prov->pc_name = strdup("LIBXML 2.4.0");
prov->pc_store_type = XML_DATA_STORE;
prov->pc_oflags = oflags;
/*
* Initialise function pointers
*/
prov->pc_close = pool_xml_close;
prov->pc_validate = pool_xml_validate;
prov->pc_commit = pool_xml_commit;
prov->pc_export = pool_xml_export;
prov->pc_rollback = pool_xml_rollback;
prov->pc_exec_query = pool_xml_exec_query;
prov->pc_elem_create = pool_xml_elem_create;
prov->pc_remove = pool_xml_remove;
prov->pc_res_xfer = pool_xml_res_transfer;
prov->pc_res_xxfer = pool_xml_res_xtransfer;
/*
* End of common initialisation
*/
/*
* Associate the provider to it's configuration
*/
conf->pc_prov = (pool_connection_t *)prov;
/*
* At this point the configuration provider has been initialized,
* mark the configuration as valid so that the various routines
* which rely on a valid configuration will work correctly.
*/
conf->pc_state = POF_VALID;
if ((oflags & PO_CREAT) != 0) {
pool_conf_t *dyn;
if ((dyn = pool_conf_alloc()) == NULL)
return (PO_FAIL);
if (pool_conf_open(dyn, pool_dynamic_location(),
PO_RDONLY) != PO_SUCCESS) {
pool_conf_free(dyn);
return (PO_FAIL);
}
if (pool_conf_export(dyn, conf->pc_location,
POX_NATIVE) != PO_SUCCESS) {
(void) pool_conf_close(dyn);
pool_conf_free(dyn);
return (PO_FAIL);
}
(void) pool_conf_close(dyn);
pool_conf_free(dyn);
}
if (pool_xml_open_file(conf) == PO_FAIL) {
(void) pool_xml_close(conf);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Free the resources for an XML data provider.
*/
static void
pool_xml_connection_free(pool_xml_connection_t *prov)
{
free((void *)prov->pc_name);
free(prov);
}
/*
* Allocate a result set. The Result Set stores the result of an XPath
* query along with the parameters used to create the result set (for
* debugging purposes).
* Returns pool_xml_result_set_t pointer/NULL
*/
static pool_xml_result_set_t *
pool_xml_result_set_alloc(const pool_conf_t *conf)
{
pool_xml_result_set_t *rs;
if ((rs = malloc(sizeof (pool_xml_result_set_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(rs, 0, sizeof (pool_xml_result_set_t));
rs->prs_conf = conf;
rs->prs_index = -1;
rs->prs_active = PO_TRUE;
/* Fix up the result set accessor functions to the xml specfic ones */
rs->prs_next = pool_xml_rs_next;
rs->prs_prev = pool_xml_rs_prev;
rs->prs_first = pool_xml_rs_first;
rs->prs_last = pool_xml_rs_last;
rs->prs_get_index = pool_xml_rs_get_index;
rs->prs_set_index = pool_xml_rs_set_index;
rs->prs_close = pool_xml_rs_close;
rs->prs_count = pool_xml_rs_count;
return (rs);
}
/*
* Free a result set. Ensure that the resources are all released at this point.
*/
static void
pool_xml_result_set_free(pool_xml_result_set_t *rs)
{
if (rs->pxr_path != NULL)
xmlXPathFreeObject(rs->pxr_path);
if (rs->pxr_ctx != NULL)
xmlXPathFreeContext(rs->pxr_ctx);
free(rs);
}
/*
* Transfer size from one resource to another.
* Returns PO_SUCCESS/PO_FAIL
*/
/* ARGSUSED */
int
pool_xml_res_transfer(pool_resource_t *src, pool_resource_t *tgt, uint64_t size)
{
return (PO_SUCCESS);
}
/*
* Transfer components rl from one resource to another.
* Returns PO_SUCCESS/PO_FAIL
*/
/* ARGSUSED */
int
pool_xml_res_xtransfer(pool_resource_t *src, pool_resource_t *tgt,
pool_component_t **rl) {
int i;
/*
* Walk the Result Set and move the resource components
*/
for (i = 0; rl[i] != NULL; i++) {
if (pool_set_container(TO_ELEM(tgt), TO_ELEM(rl[i])) ==
PO_FAIL) {
return (PO_FAIL);
}
}
return (PO_SUCCESS);
}
/*
* Return the next element in a result set.
* Returns pool_elem_t pointer/NULL
*/
static pool_elem_t *
pool_xml_rs_next(pool_result_set_t *set)
{
pool_elem_t *next;
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
/* Update the context node */
if (xset->prs_index == xset->pxr_path->nodesetval->nodeNr - 1)
return (NULL);
next =
xset->pxr_path->nodesetval->nodeTab[++xset->prs_index]->_private;
return (next);
}
/*
* Return the previous element in a result set.
* Returns pool_elem_t pointer/NULL
*/
static pool_elem_t *
pool_xml_rs_prev(pool_result_set_t *set)
{
pool_elem_t *prev;
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
/* Update the context node */
if (xset->prs_index < 0)
return (NULL);
prev =
xset->pxr_path->nodesetval->nodeTab[xset->prs_index--]->_private;
return (prev);
}
/*
* Sets the current index in a result set.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_rs_set_index(pool_result_set_t *set, int index)
{
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
if (index < 0 || index >= xset->pxr_path->nodesetval->nodeNr) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
xset->prs_index = index;
return (PO_SUCCESS);
}
/*
* Return the current index in a result set.
* Returns current index
*/
static int
pool_xml_rs_get_index(pool_result_set_t *set)
{
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
return (xset->prs_index);
}
/*
* Return the first element in a result set.
* Returns pool_elem_t pointer/NULL
*/
static pool_elem_t *
pool_xml_rs_first(pool_result_set_t *set)
{
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
/* Update the context node */
return (xset->pxr_path->nodesetval->nodeTab[0]->_private);
}
/*
* Return the last element in a result set.
* Returns pool_elem_t pointer/NULL
*/
static pool_elem_t *
pool_xml_rs_last(pool_result_set_t *set)
{
/* Since I know this is an XML result set */
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
/* Update the context node */
return (xset->pxr_path->nodesetval->
nodeTab[xset->pxr_path->nodesetval->nodeNr-1]->_private);
}
/*
* Return the number of results in a result set.
* Returns result count
*/
static int
pool_xml_rs_count(pool_result_set_t *set)
{
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
return (xset->pxr_path->nodesetval->nodeNr);
}
/*
* Close a result set. Remove this result set from the list of results and
* free the resources
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_rs_close(pool_result_set_t *set)
{
pool_xml_result_set_t *xset = (pool_xml_result_set_t *)set;
pool_xml_result_set_free(xset);
return (PO_SUCCESS);
}
/*
* Set the container for a node.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_set_container(pool_elem_t *pp, pool_elem_t *pc)
{
pool_xml_elem_t *pxp;
pool_xml_elem_t *pxc;
xmlNodePtr parent;
pxp = (pool_xml_elem_t *)pp;
pxc = (pool_xml_elem_t *)pc;
parent = pxc->pxe_node->parent;
xmlUnlinkNode(pxc->pxe_node);
if (xmlAddChild(pxp->pxe_node, pxc->pxe_node) == NULL) {
/* Try to move back */
(void) xmlAddChild(parent, pxc->pxe_node);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
pc->pe_conf = pp->pe_conf;
return (PO_SUCCESS);
}
/*
* Get the container for a node.
* Returns Container/NULL
*/
static pool_elem_t *
pool_xml_get_container(const pool_elem_t *pc)
{
pool_xml_elem_t *pxc = (pool_xml_elem_t *)pc;
return ((pool_elem_t *)pxc->pxe_node->parent->_private);
}
/*
* Note: This function is resource specific, needs extending for other
* resource types.
*/
int
pool_xml_resource_is_system(const pool_resource_t *pr)
{
switch (pool_resource_elem_class(TO_ELEM(pr))) {
case PREC_PSET:
return (PSID_IS_SYSSET(
elem_get_sysid(TO_ELEM(pr))));
default:
return (PO_FALSE);
}
}
/*
* Note: This function is resource specific, needs extending for other
* resource types.
*/
int
pool_xml_resource_can_associate(const pool_resource_t *pr)
{
switch (pool_resource_elem_class(TO_ELEM(pr))) {
case PREC_PSET:
return (PO_TRUE);
default:
return (PO_FALSE);
}
}
/*
* Note: This function is resource specific. It must be extended to support
* multiple resource types.
*/
int
pool_xml_pool_associate(pool_t *pool, const pool_resource_t *pr)
{
pool_value_t val = POOL_VALUE_INITIALIZER;
if (pool_xml_get_property(TO_ELEM(pr),
"pset.ref_id", &val) != POC_STRING)
return (PO_FAIL);
if (pool_xml_put_property(TO_ELEM(pool), "pool.res", &val) !=
PO_SUCCESS)
return (PO_FAIL);
return (PO_SUCCESS);
}
/*
* pool_xml_pool_dissociate() simply finds the default resource for
* the type of resource being dissociated and then calls
* pool_xml_pool_associate() to associate to the default resource.
*/
int
pool_xml_pool_dissociate(pool_t *pool, const pool_resource_t *pr)
{
const pool_resource_t *default_res;
if ((default_res = get_default_resource(pr)) == NULL)
return (PO_FAIL);
if (default_res == pr)
return (PO_SUCCESS);
return (pool_xml_pool_associate(pool, default_res));
}
/*
* pool_xml_open_file() opens a file for a configuration. This establishes
* the locks required to ensure data integrity when manipulating a
* configuration.
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_xml_open_file(pool_conf_t *conf)
{
struct flock lock;
struct stat s;
pool_xml_connection_t *prov = (pool_xml_connection_t *)conf->pc_prov;
/*
* Always close the pxc_file in case there was a previously failed open
*/
if (prov->pxc_file != NULL) {
(void) fclose(prov->pxc_file);
prov->pxc_file = NULL;
}
/*
* Check that the DTD required for this operation is present.
* If it isn't fail
*/
if (dtd_exists(dtd_location) == PO_FALSE) {
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if ((prov->pc_oflags & PO_RDWR) != 0)
prov->pxc_file = fopen(conf->pc_location, "r+F");
else /* Assume opening PO_RDONLY */
prov->pxc_file = fopen(conf->pc_location, "rF");
if (prov->pxc_file == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Setup the lock for the file
*/
lock.l_type = (prov->pc_oflags & PO_RDWR) ? F_WRLCK : F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if (fcntl(fileno(prov->pxc_file), F_SETLKW, &lock) == -1) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Check to see if the document was removed whilst waiting for
* the lock. If it was return an error.
*/
if (stat(conf->pc_location, &s) == -1) {
(void) fclose(prov->pxc_file);
prov->pxc_file = NULL;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/* Parse the document */
if (pool_xml_parse_document(conf) != PO_SUCCESS)
return (PO_FAIL);
return (PO_SUCCESS);
}
/*
* Try to work out if an element contains an attribute of the supplied name.
* Search the internal subset first and then the external subset.
* Return PO_TRUE if there is an attribute of that name declared for that
* element.
*/
int
pool_is_xml_attr(xmlDocPtr doc, const char *elem, const char *attr)
{
xmlDtdPtr internal = xmlGetIntSubset(doc);
xmlDtdPtr external = doc->extSubset;
if (xmlGetDtdAttrDesc(internal, BAD_CAST elem, BAD_CAST attr) == NULL)
if (xmlGetDtdAttrDesc(external,
BAD_CAST elem, BAD_CAST attr) == NULL)
return (PO_FALSE);
return (PO_TRUE);
}
/*
* Execute the specified query using XPath. This complex function relies on
* a couple of helpers to build up an XPath query, pool_build_xpath_buf in
* particular.
* conf - the pool configuration being manipulated
* src - the root of the search, if NULL that means whole document
* src_attr - if supplied means an IDREF(S) search on this attribute
* classes - target classes
* props - target properties
* Returns pool_result_set_t pointer/NULL
*/
pool_result_set_t *
pool_xml_exec_query(const pool_conf_t *conf, const pool_elem_t *src,
const char *src_attr, pool_elem_class_t classes, pool_value_t **props)
{
char *buf = NULL;
char_buf_t *cb = NULL;
pool_xml_result_set_t *rs;
pool_xml_elem_t *pxe = (pool_xml_elem_t *)src;
pool_xml_connection_t *prov = (pool_xml_connection_t *)conf->pc_prov;
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL)
return (NULL);
/*
* Prior to building up the complex XPath query, check to see if
* src_attr is an IDREF(S). If it is use the IDREF(S) information
* to generate the query rather than the other data
*/
if (src_attr != NULL) {
char *tok;
char *lasts;
char *or = "";
xmlChar *id;
/*
* Check the arguments for consistency
*/
if (pool_is_xml_attr(prov->pxc_doc,
element_class_tags[src->pe_class], src_attr) != PO_TRUE) {
free_char_buf(cb);
pool_seterror(POE_BADPARAM);
return (NULL);
}
if ((id = xmlGetProp(pxe->pxe_node, BAD_CAST src_attr))
== NULL) {
free_char_buf(cb);
pool_seterror(POE_DATASTORE);
return (NULL);
}
for (tok = strtok_r((char *)id, " ", &lasts);
tok != NULL; tok = strtok_r(NULL, " ", &lasts)) {
(void) append_char_buf(cb, "%s//*[@ref_id=\"%s\"]",
or, tok);
or = " | ";
if ((classes & PEC_QRY_SYSTEM) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_SYSTEM,
props, cb, PO_TRUE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_POOL) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_POOL,
props, cb, PO_TRUE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_RES_COMP) != 0) {
if (pool_build_xpath_buf(prov, src,
PEC_RES_COMP, props, cb, PO_TRUE)
== PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
} else if ((classes & PEC_QRY_RES_AGG) != 0) {
if (pool_build_xpath_buf(prov, src,
PEC_RES_AGG, props, cb, PO_TRUE)
== PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
}
xmlFree(id);
} else {
/*
* Build up an XPath query using the supplied parameters.
* The basic logic is to:
* - Identify which classes are the targets of the query
* - For each class work out if the props are attributes or not
* - Build up a piece of XPath for each class
* - Combine the results into one large XPath query.
* - Execute the query.
*/
if ((classes & PEC_QRY_SYSTEM) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_SYSTEM, props,
cb, PO_FALSE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_POOL) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_POOL, props,
cb, PO_FALSE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_RES_COMP) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_RES_COMP, props,
cb, PO_FALSE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_RES_AGG) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_RES_AGG, props,
cb, PO_FALSE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
if ((classes & PEC_QRY_COMP) != 0) {
if (pool_build_xpath_buf(prov, src, PEC_COMP, props,
cb, PO_FALSE) == PO_FAIL) {
free_char_buf(cb);
return (NULL);
}
}
}
buf = strdup(cb->cb_buf);
free_char_buf(cb);
/*
* Have a buffer at this point, that we can use
*/
if ((rs = pool_xml_result_set_alloc(conf)) == NULL) {
free(buf);
return (NULL);
}
/*
* Set up the XPath Query
*/
if ((rs->pxr_ctx = xmlXPathNewContext(
((pool_xml_connection_t *)conf->pc_prov)->pxc_doc)) == NULL) {
free(buf);
(void) pool_xml_rs_close((pool_result_set_t *)rs);
pool_seterror(POE_DATASTORE);
return (NULL);
}
if (src == NULL)
rs->pxr_ctx->node = xmlDocGetRootElement
(((pool_xml_connection_t *)conf->pc_prov)->pxc_doc);
else
rs->pxr_ctx->node = pxe->pxe_node;
/*
* Select
*/
rs->pxr_path = xmlXPathEval(BAD_CAST buf, rs->pxr_ctx);
free(buf);
/*
* Generate the result set and wrap the results as pool_elem_t
*/
if (rs->pxr_path->nodesetval->nodeNr == 0)
pool_seterror(POE_INVALID_SEARCH);
return ((pool_result_set_t *)rs);
}
/*
* Build an XPath query buffer. This is complex and a little fragile, but
* I'm trying to accomplish something complex with as little code as possible.
* I wait the implementation of XMLQuery with baited breath...
* Returns PO_SUCCESS/PO_FAIL
*/
static int
pool_build_xpath_buf(pool_xml_connection_t *prov, const pool_elem_t *src,
pool_elem_class_t class, pool_value_t *props[], char_buf_t *cb, int is_ref)
{
int i;
const char *ATTR_FMTS[] = {
"[ @%s=\"%llu\" ]", /* POC_UINT */
"[ @%s=\"%lld\" ]", /* POC_INT */
"[ @%s=\"%f\" ]", /* POC_DOUBLE */
"[ @%s=\"%s\" ]", /* POC_BOOL */
"[ @%s=\"%s\" ]", /* POC_STRING */
};
const char *PROP_FMTS[] = {
"[ property[@name=\"%s\"][text()=\"%llu\"] ]", /* POC_UINT */
"[ property[@name=\"%s\"][text()=\"%lld\"] ]", /* POC_INT */
"[ property[@name=\"%s\"][text()=\"%f\"] ]", /* POC_DOUBLE */
"[ property[@name=\"%s\"][text()=\"%s\"] ]", /* POC_BOOL */
"[ property[@name=\"%s\"][text()=\"%s\"] ]" /* POC_STRING */
};
const char **fmts;
int nprop;
const char *last_prop_name = NULL;
char *type_prefix = NULL;
int has_type = PO_FALSE;
if (is_ref == PO_FALSE) {
if (cb->cb_buf != NULL && strlen(cb->cb_buf) > 0)
(void) append_char_buf(cb, " |");
if (src != NULL)
(void) append_char_buf(cb, " ./");
else
(void) append_char_buf(cb, "//");
(void) append_char_buf(cb, element_class_tags[class]);
}
if (props == NULL || props[0] == NULL)
return (PO_SUCCESS);
for (nprop = 0; props[nprop] != NULL; nprop++)
/* Count properties */;
/*
* Sort the attributes and properties by name.
*/
qsort(props, nprop, sizeof (pool_value_t *), prop_sort);
for (i = 0; i < nprop; i++) {
int is_attr = 0;
const char *prefix;
const char *prop_name;
uint64_t uval;
int64_t ival;
double dval;
uchar_t bval;
const char *sval;
pool_value_class_t pvc;
prop_name = pool_value_get_name(props[i]);
if ((prefix = is_a_known_prefix(class, prop_name)) != NULL) {
const char *attr_name;
/*
* Possibly an attribute. Strip off the prefix.
*/
if (strcmp(prop_name, c_type) == 0) {
has_type = PO_TRUE;
attr_name = prop_name;
} else
attr_name = prop_name + strlen(prefix) + 1;
if (pool_is_xml_attr(prov->pxc_doc,
element_class_tags[class], attr_name)) {
is_attr = 1;
prop_name = attr_name;
if (class == PEC_RES_COMP ||
class == PEC_RES_AGG ||
class == PEC_COMP) {
if (type_prefix != NULL)
free(type_prefix);
type_prefix = strdup(prefix);
}
}
}
if (is_attr) {
fmts = ATTR_FMTS;
} else {
fmts = PROP_FMTS;
}
/*
* Add attributes/properties to the search buffer
*/
switch ((pvc = pool_value_get_type(props[i]))) {
case POC_UINT:
(void) pool_value_get_uint64(props[i], &uval);
if (append_char_buf(cb, fmts[pvc], prop_name, uval)
== PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
break;
case POC_INT:
(void) pool_value_get_int64(props[i], &ival);
if (append_char_buf(cb, fmts[pvc], prop_name, ival)
== PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
break;
case POC_DOUBLE:
(void) pool_value_get_double(props[i], &dval);
if (append_char_buf(cb, fmts[pvc], prop_name, dval)
== PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
break;
case POC_BOOL:
(void) pool_value_get_bool(props[i], &bval);
if (append_char_buf(cb, fmts[pvc], prop_name,
bval ? "true" : "false") == PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
break;
case POC_STRING:
(void) pool_value_get_string(props[i], &sval);
if (append_char_buf(cb, fmts[pvc], prop_name, sval)
== PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
break;
default:
free(type_prefix);
pool_seterror(POE_INVALID_SEARCH);
return (PO_FAIL);
}
if (last_prop_name != NULL) {
const char *suffix1, *suffix2;
/*
* Extra fiddling for namespaces
*/
suffix1 = strrchr(prop_name, '.');
suffix2 = strrchr(last_prop_name, '.');
if (suffix1 != NULL || suffix2 != NULL) {
if (suffix1 == NULL)
suffix1 = prop_name;
else
suffix1++;
if (suffix2 == NULL)
suffix2 = last_prop_name;
else
suffix2++;
} else {
suffix1 = prop_name;
suffix2 = last_prop_name;
}
if (strcmp(suffix1, suffix2) == 0) {
char *where = strrchr(cb->cb_buf, '[');
if (is_attr != PO_TRUE) {
/* repeat */
while (*--where != '[')
;
while (*--where != '[')
;
}
*(where - 1) = 'o';
*where = 'r';
}
}
last_prop_name = prop_name;
}
if (has_type == PO_FALSE) {
if (type_prefix) {
if (append_char_buf(cb, ATTR_FMTS[POC_STRING],
c_type, type_prefix) == PO_FAIL) {
free(type_prefix);
return (PO_FAIL);
}
}
}
free(type_prefix);
return (PO_SUCCESS);
}
/*
* Utility routine for use by quicksort. Assumes that the supplied data
* are pool values and compares the names of the two pool values.
* Returns an integer greater than, equal to, or less than 0.
*/
static int
prop_sort(const void *a, const void *b)
{
pool_value_t **prop_a = (pool_value_t **)a;
pool_value_t **prop_b = (pool_value_t **)b;
const char *str_a;
const char *str_b;
const char *suffix1, *suffix2;
str_a = pool_value_get_name(*prop_a);
str_b = pool_value_get_name(*prop_b);
/*
* Extra fiddling for namespaces
*/
suffix1 = strrchr(str_a, '.');
suffix2 = strrchr(str_b, '.');
if (suffix1 != NULL || suffix2 != NULL) {
if (suffix1 == NULL)
suffix1 = str_a;
else
suffix1++;
if (suffix2 == NULL)
suffix2 = str_b;
else
suffix2++;
} else {
suffix1 = str_a;
suffix2 = str_b;
}
return (strcmp(suffix1, suffix2));
}
/*
* Order the elements by (ref_id)
*/
/*
* Returns PO_TRUE/PO_FALSE to indicate whether the supplied path exists on the
* system. It is assumed that the supplied path is in URL format and represents
* a file and so file:// is stripped from the start of the search.
*/
static int
dtd_exists(const char *path)
{
struct stat buf;
if (strstr(path, "file://") != path)
return (PO_FALSE);
if (path[7] == 0)
return (PO_FALSE);
if (stat(&path[7], &buf) == 0)
return (PO_TRUE);
return (PO_FALSE);
}
/*
* Build the dtype structures to accelerate data type lookup operations. The
* purpose is to avoid expensive XML manipulations on data which will not
* change over the life of a library invocation. It is designed to be invoked
* once from the library init function.
*/
static void
build_dtype_accelerator(void)
{
xmlDtdPtr dtd;
const xmlChar *elem_list[ELEM_TYPE_COUNT] = {
BAD_CAST "res_comp",
BAD_CAST "res_agg",
BAD_CAST "comp",
BAD_CAST "pool",
BAD_CAST "property",
BAD_CAST "system" };
int i;
if (_libpool_xml_initialised == PO_TRUE)
return;
/* Load up the d-type data for each element */
/*
* Store data type information in nested lists
* Top level list contains attribute declaration pointers which
* can be used to match with supplied nodes.
* Second level list contains attribute type information for each
* element declaration
*/
/*
* Unfortunately, there's no easy way to get a list of all DTD
* element descriptions as there is no libxml API to do this (they
* are stored in a hash, which I guess is why). Explicitly seek
* for descriptions for elements that are known to hold an a-dtype
* attribute and build accelerators for those elements.
* If the DTD changes, the library may have to change as well now,
* since this code makes explicit assumptions about which elements
* contain a-dtype information.
*/
if ((dtd = xmlParseDTD(BAD_CAST "-//Sun Microsystems Inc//DTD Resource"
" Management All//EN", BAD_CAST dtd_location)) == NULL)
return;
for (i = 0; i < ELEM_TYPE_COUNT; i++) {
xmlElementPtr elem;
xmlAttributePtr attr;
if ((elem = xmlGetDtdElementDesc(dtd, elem_list[i])) == NULL)
return;
elem_tbl[i].ett_elem = xmlStrdup(elem->name);
/* Walk the list of attributes looking for a-dtype */
for (attr = elem->attributes; attr != NULL;
attr = attr->nexth) {
if (strcmp((const char *)attr->name, c_a_dtype) == 0) {
/*
* Allocate a dtype_tbl_t
*/
elem_tbl[i].ett_dtype =
build_dtype_tbl(attr->defaultValue);
/* This could have returned NULL */
}
}
}
xmlFreeDtd(dtd);
}
/*
* build_dtype_tbl() parses the supplied data and returns an array (max size
* of 10, increase if required) of dtype_tbl_t structures holding data type
* information for an element. The supplied data is assumed to be in "a-dtype"
* format. The dtype_tbl_t array is NULL terminated, which is why space for
* 11 members is allocated.
*/
static dtype_tbl_t
(*build_dtype_tbl(const xmlChar *rawdata))[]
{
char *tok;
char *lasts;
dtype_tbl_t (*tbl)[];
int j = 0;
xmlChar *data;
const int max_attr = 11; /* Not more than 10 types per element */
/*
* Parse the supplied data, assumed to be in a-dtype format, and
* generate a lookup table which is indexed by the name and contains
* the data type
*/
if (rawdata == NULL)
return (NULL);
if ((data = xmlStrdup(rawdata)) == NULL)
return (NULL);
if ((tbl = calloc(max_attr, sizeof (dtype_tbl_t))) == NULL) {
xmlFree(data);
return (NULL);
}
for (tok = strtok_r((char *)data, " ", &lasts); tok != NULL;
tok = strtok_r(NULL, " ", &lasts)) {
int i;
(*tbl)[j].dt_name = xmlStrdup(BAD_CAST tok);
if ((tok = strtok_r(NULL, " ", &lasts)) == NULL) {
int k = j;
for (j = 0; j < k; j++)
free((*tbl)[j].dt_name);
pool_seterror(POE_DATASTORE);
xmlFree(data);
free(tbl);
return (NULL);
}
for (i = 0; i < (sizeof (data_type_tags) /
sizeof (data_type_tags[0])); i++) {
if (strcmp(tok, data_type_tags[i]) == 0)
(*tbl)[j++].dt_type = i;
}
if (j == max_attr) { /* too many attributes, bail out */
for (j = 0; j < max_attr; j++)
free((*tbl)[j].dt_name);
free(tbl);
xmlFree(data);
return (NULL);
}
}
(*tbl)[j].dt_name = NULL; /* Terminate the table */
xmlFree(data);
return (tbl);
}
/*
* get_fast_dtype() finds the data type for a supplied attribute name on a
* supplied node. This is called get_fast_dtype() because it uses the cached
* data type information created at library initialisation.
*/
static int
get_fast_dtype(xmlNodePtr node, xmlChar *name)
{
int i;
xmlElementPtr elem;
if ((elem = xmlGetDtdElementDesc(node->doc->extSubset, node->name))
== NULL) {
pool_seterror(POE_BADPARAM);
return (POC_INVAL);
}
for (i = 0; i < ELEM_TYPE_COUNT; i++) {
if (xmlStrcmp(elem_tbl[i].ett_elem, elem->name) == 0) {
dtype_tbl_t (*tbl)[] = elem_tbl[i].ett_dtype;
int j = 0;
if (tbl == NULL)
break;
for (j = 0; (*tbl)[j].dt_name != NULL; j++)
if (xmlStrcmp(name, (*tbl)[j].dt_name) == 0)
return ((*tbl)[j].dt_type); /* found */
break; /* if we didn't find it in the elem, break */
}
}
/* If we can't find it, say it's a string */
return (POC_STRING);
}
/*
* pool_xml_parse_document() parses the file associated with a supplied
* configuration to regenerate the runtime representation. The supplied
* configuration must reference an already opened file and this is used
* to generate the XML representation via the configuration provider's
* pxc_doc member.
* size must be >=4 in order for "content encoding detection" to work.
*/
static int
pool_xml_parse_document(pool_conf_t *conf)
{
int res;
char chars[PAGE_READ_SIZE];
struct stat f_stat;
xmlParserCtxtPtr ctxt;
size_t size;
pool_xml_connection_t *prov = (pool_xml_connection_t *)conf->pc_prov;
xmlNodePtr root;
pool_resource_t **rsl;
uint_t nelem;
int i;
if (fstat(fileno(prov->pxc_file), &f_stat) == -1) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (f_stat.st_size == 0) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
} else
size = f_stat.st_size < 4 ? 4 : PAGE_READ_SIZE;
res = fread(chars, 1, size, prov->pxc_file);
if (res >= 4) {
xmlValidCtxtPtr cvp;
if ((ctxt = xmlCreatePushParserCtxt(NULL, NULL,
chars, res, conf->pc_location)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
while ((res = fread(chars, 1, size, prov->pxc_file)) > 0) {
if (xmlParseChunk(ctxt, chars, res, 0) != 0) {
xmlFreeParserCtxt(ctxt);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
}
if (xmlParseChunk(ctxt, chars, 0, 1) != 0) {
xmlFreeParserCtxt(ctxt);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
if ((cvp = xmlNewValidCtxt()) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
cvp->error = pool_error_func;
cvp->warning = pool_error_func;
if (xmlValidateDocument(cvp, ctxt->myDoc) == 0) {
xmlFreeValidCtxt(cvp);
xmlFreeParserCtxt(ctxt);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
prov->pxc_doc = ctxt->myDoc;
xmlFreeValidCtxt(cvp);
xmlFreeParserCtxt(ctxt);
}
if (prov->pxc_doc == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
prov->pxc_doc->_private = conf;
/* Get the root element */
if ((root = xmlDocGetRootElement(prov->pxc_doc)) == NULL) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
/*
* Ensure that the parsed tree has been contained within
* our shadow tree.
*/
if (create_shadow(root) != PO_SUCCESS) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
if (pool_xml_validate(conf, POV_STRICT) != PO_SUCCESS) {
return (PO_FAIL);
}
/*
* For backwards compatibility with S9, make sure that all
* resources have a size and that it is correct.
*/
if ((rsl = pool_query_resources(conf, &nelem, NULL)) != NULL) {
pool_value_t val = POOL_VALUE_INITIALIZER;
for (i = 0; i < nelem; i++) {
if (pool_get_ns_property(TO_ELEM(rsl[i]), c_size_prop,
&val) != POC_UINT) {
pool_component_t **cs;
uint_t size;
if ((cs = pool_query_resource_components(conf,
rsl[i], &size, NULL)) != NULL) {
free(cs);
pool_value_set_uint64(&val, size);
} else
pool_value_set_uint64(&val, 0);
if (pool_put_any_ns_property(TO_ELEM(rsl[i]),
c_size_prop, &val) != PO_SUCCESS) {
free(rsl);
return (PO_FAIL);
}
}
}
free(rsl);
}
return (PO_SUCCESS);
}