XML Interface

Utilities for managing XML documents. More...

Modules
	XSLT Interface
	Utilities for managing XML documents.

Files
file	libxml2.c
	XML Interface.

Data Structures
struct	xml_attr
	XML attribute name value pair. More...
struct	xml_node
	Reference to a XML Node. More...
struct	xml_node_iter
	Iterator to traverse nodes in a xpath. More...
struct	xml_search
	XML xpath search result. More...

Typedefs
typedef struct xml_node	xml_node
	Forward decleration of structure. More...
typedef struct xml_search	xml_search
	Forward decleration of structure. More...
typedef struct xml_doc	xml_doc
	Forward decleration of structure. More...

Functions
void	xml_free_buffer (void *data)
	Reference destructor for xml_buffer. More...
struct xml_doc *	xml_loaddoc (const char *docfile, int validate)
	Load a XML file into XML document and return reference. More...
struct xml_doc *	xml_loadbuf (const uint8_t *buffer, uint32_t len, int validate)
	Load a buffer into XML document returning refereence. More...
struct xml_node *	xml_getrootnode (struct xml_doc *xmldoc)
	Return reference to the root node. More...
struct xml_node *	xml_getfirstnode (struct xml_search *xpsearch, void **iter)
	Return reference to the first node optionally creating a iterator. More...
struct xml_node *	xml_getnextnode (void *iter)
	Return the next node. More...
struct bucket_list *	xml_getnodes (struct xml_search *xpsearch)
	Return reference to bucket list containing nodes. More...
struct xml_search *	xml_xpath (struct xml_doc *xmldata, const char *xpath, const char *attrkey)
	Return a reference to a xpath search result. More...
int	xml_nodecount (struct xml_search *xsearch)
	Return the number of nodes in the search path. More...
struct xml_node *	xml_getnode (struct xml_search *xsearch, const char *key)
	Return a node in the search matching key. More...
const char *	xml_getattr (struct xml_node *xnode, const char *attr)
	Return value of attribute. More...
const char *	xml_getrootname (struct xml_doc *xmldoc)
	Return the name of the root node. More...
void	xml_modify (struct xml_doc *xmldoc, struct xml_node *xnode, const char *value)
	Modify a XML node. More...
void	xml_setattr (struct xml_doc *xmldoc, struct xml_node *xnode, const char *name, const char *value)
	Modify a XML node attribute. More...
void	xml_createpath (struct xml_doc *xmldoc, const char *xpath)
	Create a path in XML document. More...
void	xml_appendnode (struct xml_doc *xmldoc, const char *xpath, struct xml_node *child)
	Append a node to a path. More...
struct xml_node *	xml_addnode (struct xml_doc *xmldoc, const char *xpath, const char *name, const char *value, const char *attrkey, const char *keyval)
	Append a node to a path. More...
void	xml_unlink (struct xml_node *xnode)
	Unlink a node from the document. More...
void	xml_delete (struct xml_node *xnode)
	Delete a node from document it is not unrefd and should be. More...
char *	xml_getbuffer (void *buffer)
	Return the buffer of a xml_buffer structure. More...
void *	xml_doctobuffer (struct xml_doc *xmldoc)
	Return a dump of a XML document. More...
void	xml_init ()
	Initialise/Reference the XML library. More...
void	xml_close ()
	Unreference the XML library. More...
void	xml_savefile (struct xml_doc *xmldoc, const char *file, int format, int compress)
	Save XML document to a file. More...

Detailed Description

Utilities for managing XML documents.

Typedef Documentation

typedef struct xml_doc xml_doc

Forward decleration of structure.

Definition at line 631 of file dtsapp.h.

typedef struct xml_node xml_node

Forward decleration of structure.

Definition at line 625 of file dtsapp.h.

typedef struct xml_search xml_search

Forward decleration of structure.

Definition at line 628 of file dtsapp.h.

Function Documentation

struct xml_node* xml_addnode	(	struct xml_doc *	xmldoc,
		const char *	xpath,
		const char *	name,
		const char *	value,
		const char *	attrkey,
		const char *	keyval
	)

Append a node to a path.

Parameters

xmldoc	Reference to XML document.
xpath	Path to add the node too.
name	Node name.
value	Node value.
attrkey	Attribute to create on node.
keyval	Attribute value of attrkey.

Returns

reference to new node.

Definition at line 651 of file libxml2.c.

References objlock(), objref(), objunlock(), and objunref().

Referenced by xml_createpath().

                                                                             {
    struct xml_node *newnode;
    xmlNodePtr parent;
    xmlNodePtr child;
    xmlChar *encval;

    if (!objref(xmldoc)) {
        return NULL;
    }

    objlock(xmldoc);
    if (!(parent = xml_getparent(xmldoc, xpath))) {
        objunlock(xmldoc);
        objunref(xmldoc);
        return NULL;
    }

    encval = xmlEncodeSpecialChars(xmldoc->doc, (const xmlChar *)value);
    child = xmlNewDocNode(xmldoc->doc, NULL, (const xmlChar *)name, encval);
    xmlFree(encval);
    xmlAddChild(parent,child);

    if (attrkey && keyval) {
        encval = xmlEncodeSpecialChars(xmldoc->doc, (const xmlChar *)keyval);
        xmlSetProp(child, (const xmlChar *)attrkey, (const xmlChar *)encval);
        xmlFree(encval);
    }
    objunlock(xmldoc);

    if (!(newnode = xml_nodetohash(xmldoc, child, attrkey))) {
        objunref(xmldoc);
        return NULL;
    }

    objunref(xmldoc);

    return newnode;
}

void xml_appendnode	(	struct xml_doc *	xmldoc,
		const char *	xpath,
		struct xml_node *	child
	)

Append a node to a path.

Note

The child will most likely be a node unlinked and moved.

Parameters

xmldoc	Reference to XML document.
xpath	Path to add the node too.
child	XML node to append to path.

Definition at line 625 of file libxml2.c.

References xml_node::nodeptr, objlock(), objref(), objunlock(), and objunref().

                                                                                               {
    xmlNodePtr parent;

    if (!objref(xmldoc)) {
        return;
    }

    objlock(xmldoc);
    if (!(parent = xml_getparent(xmldoc, xpath))) {
        objunlock(xmldoc);
        objunref(xmldoc);
    }

    xmlAddChild(parent,child->nodeptr);
    objunlock(xmldoc);
    objunref(xmldoc);
}

void xml_close

(

)

Unreference the XML library.

Ideally this should be done after a call to xml_init at shutdown.

Definition at line 758 of file libxml2.c.

References objunref().

                        {
    if (xml_has_init_parser) {
        objunref(xml_has_init_parser);
    }
}

void xml_createpath	(	struct xml_doc *	xmldoc,
		const char *	xpath
	)

Create a path in XML document.

Note

xpath is not a full xpath just a path [no filters].

Parameters

xmldoc	Reference to XML document.
xpath	Path to create.

Definition at line 507 of file libxml2.c.

References xml_node::name, objlock(), objref(), objunlock(), objunref(), and xml_addnode().

                                                                      {
    struct xml_node *nn;
    xmlXPathObjectPtr xpathObj;
    char *lpath, *tok, *save, *cpath, *dup;
    const char *root = (char *)xmldoc->root->name;
    int len;


    if (!objref(xmldoc)) {
        return;
    }

    if (!(dup = strdup(xpath))) {
        objunref(xmldoc);
        return;
    }

    len = strlen(xpath)+1;
    if (!(cpath = malloc(len))) {
        free(dup);
        objunref(xmldoc);
        return;
    }
    if (!(lpath = malloc(len))) {
        free(dup);
        free(cpath);
        objunref(xmldoc);
        return;
    }

    cpath[0] = '\0';
    lpath[0] = '\0';

#ifndef __WIN32__
        for (tok = strtok_r(dup, "/", &save); tok ; tok = strtok_r(NULL, "/", &save)) {
#else
        for (tok = strtok_s(dup, "/", &save); tok ; tok = strtok_s(NULL, "/", &save)) {
#endif
        strcat(cpath,"/");
        strcat(cpath, tok);
        if (!strcmp(tok, root)) {
            strcat(lpath,"/");
            strcat(lpath, tok);
            continue;
        }

        objlock(xmldoc);
        if (!(xpathObj = xmlXPathEvalExpression((const xmlChar *)cpath, xmldoc->xpathCtx))) {
            objunlock(xmldoc);
            free(lpath);
            free(cpath);
            free(dup);
            objunref(xmldoc);
            return;
        }
        objunlock(xmldoc);

        if (xmlXPathNodeSetIsEmpty(xpathObj->nodesetval)) {
            nn = xml_addnode(xmldoc, lpath, tok, NULL, NULL, NULL);
            objunref(nn);
        }

        xmlXPathFreeObject(xpathObj);
        strcat(lpath,"/");
        strcat(lpath, tok);
    }

    free(dup);
    free(lpath);
    free(cpath);
    objunref(xmldoc);
}

void xml_delete

(

struct xml_node *

xnode

)

Delete a node from document it is not unrefd and should be.

Parameters

xnode

Reference to node to delete this must be unreferenced after calling this function.

Definition at line 701 of file libxml2.c.

References xml_node::nodeptr, objlock(), and objunlock().

                                               {
    objlock(xnode);
    xmlUnlinkNode(xnode->nodeptr);
    xmlFreeNode(xnode->nodeptr);
    xnode->nodeptr = NULL;
    objunlock(xnode);
}

void* xml_doctobuffer

(

struct xml_doc *

xmldoc

)

Return a dump of a XML document.

The result can be acessed using xml_getbuffer()

Parameters

xmldoc

Reference to a XML document.

Returns

Reference to a xml_buffer structure.

Definition at line 726 of file libxml2.c.

References objalloc(), objlock(), objunlock(), and xml_free_buffer().

                                                     {
    struct xml_buffer *xmlbuf;

    if (!(xmlbuf = objalloc(sizeof(*xmlbuf),xml_free_buffer))) {
        return NULL;
    }

    objlock(xmldoc);
    xmlDocDumpFormatMemory(xmldoc->doc, &xmlbuf->buffer, &xmlbuf->size, 1);
    objunlock(xmldoc);
    return xmlbuf;
}

void xml_free_buffer

(

void *

data

)

Reference destructor for xml_buffer.

Warning

do not call this directly.

Definition at line 46 of file libxml2.c.

Referenced by xml_doctobuffer(), and xslt_apply_buffer().

                                 {
    struct xml_buffer *xb = data;
    xmlFree(xb->buffer);
}

const char* xml_getattr	(	struct xml_node *	xnode,
		const char *	attr
	)

Return value of attribute.

Parameters

xnode	XML node reference.
attr	Attribute to search for.

Returns

Value of the attribute valid while reference to node is held.

Definition at line 440 of file libxml2.c.

References xml_node::attrs, bucket_list_find_key(), objunref(), and xml_attr::value.

                                                                         {
    struct xml_attr *ainfo;

    if (!xnode) {
        return NULL;
    }

    if ((ainfo = bucket_list_find_key(xnode->attrs, attr))) {
        objunref(ainfo);
        return ainfo->value;
    } else {
        return NULL;
    }
}

char* xml_getbuffer

(

void *

buffer

)

Return the buffer of a xml_buffer structure.

Note

only valid while reference is held to the xml_buffer struct.

Parameters

buffer

Reference to a xml_buffer struct.

Definition at line 712 of file libxml2.c.

                                         {
    struct xml_buffer *xb = buffer;

    if (!xb) {
        return NULL;
    }
    return (char *)xb->buffer;
}

struct xml_node* xml_getfirstnode	(	struct xml_search *	xpsearch,
		void **	iter
	)

Return reference to the first node optionally creating a iterator.

Setting the optional iterator and using it on future calls to xml_getnextnode its possible to iterate through the search path.

Todo:

Thread safety when XML doc changes.

Note

using xml_getnodes() returns a bucket list of nodes this is prefered.

Warning

This is not thread safe.

Parameters

xpsearch	XML xpath search to find first node.
iter	Optional iterator created and returned (must be unreferenced)

Returns

Reference to first node in the path.

Definition at line 295 of file libxml2.c.

References xml_node_iter::cnt, xml_node_iter::curpos, objalloc(), objlock(), objref(), objunlock(), objunref(), xml_nodecount(), and xml_node_iter::xsearch.

                                                                                   {
    struct xml_node_iter *newiter;
    struct xml_node *xn;

    if (!objref(xpsearch)) {
        return NULL;
    }

    if (iter) {
        newiter = objalloc(sizeof(*newiter), free_iter);
        objlock(xpsearch);
        newiter->cnt = xml_nodecount(xpsearch);
        objunlock(xpsearch);
        newiter->curpos = 0;
        newiter->xsearch = xpsearch;
        objref(newiter->xsearch);
        *iter = newiter;
    }

    xn = xml_gethash(xpsearch, 0, NULL);
    objunref(xpsearch);
    return xn;
}

struct xml_node* xml_getnextnode

(

void *

iter

)

Return the next node.

Parameters

iter	Iterator set in call to from xml_getfirstnode.

Returns

Reference to next node.

Definition at line 322 of file libxml2.c.

References xml_node_iter::cnt, xml_node_iter::curpos, objlock(), objref(), objunlock(), objunref(), and xml_node_iter::xsearch.

                                                    {
    struct xml_node_iter *xi = iter;
    struct xml_node *xn;

    if (!objref(xi->xsearch)) {
        return NULL;
    }

    objlock(xi);
    xi->curpos ++;
    if (xi->curpos >= xi->cnt) {
        objunlock(xi);
        objunref(xi->xsearch);
        return NULL;
    }
    xn = xml_gethash(xi->xsearch, xi->curpos, NULL);
    objunlock(xi);
    objunref(xi->xsearch);

    return xn;
}

struct xml_node* xml_getnode	(	struct xml_search *	xsearch,
		const char *	key
	)

Return a node in the search matching key.

The key is matched against the index attribute supplied or the value of the node.

Parameters

xsearch	Reference to xpath search.
key	Value to use to find node matched aginst the index attribute/value.

Returns

Reference to XML node.

Definition at line 429 of file libxml2.c.

References bucket_list_find_key(), and xml_search::nodes.

                                                                                 {
    if (!xsearch) {
        return NULL;
    }
    return bucket_list_find_key(xsearch->nodes, key);
}

struct bucket_list* xml_getnodes

(

struct xml_search *

xpsearch

)

Return reference to bucket list containing nodes.

Note

use of this is prefered to xml_getfirstnode() / xml_getnextnode() if search order is not a issue.

Parameters

xpsearch

Reference to xpath search result returned by xml_xpath.

Returns

Reference to bucket list containing nodes.

Definition at line 349 of file libxml2.c.

References xml_search::nodes, and objref().

                                                                     {
    return (xpsearch && objref(xpsearch->nodes)) ? xpsearch->nodes : NULL;
}

const char* xml_getrootname

(

struct xml_doc *

xmldoc

)

Return the name of the root node.

Note

do not free or unref this.

Parameters

xmldoc

XML Document.

Definition at line 458 of file libxml2.c.

                                                           {
    if (xmldoc) {
        return (const char *)xmldoc->root->name;
    }
    return NULL;
}

struct xml_node* xml_getrootnode

(

struct xml_doc *

xmldoc

)

Return reference to the root node.

Parameters

xmldoc

XML Document to find root in.

Definition at line 276 of file libxml2.c.

References objlock(), and objunlock().

                                                                {
    struct xml_node *rn;

    objlock(xmldoc);
    rn = xml_nodetohash(xmldoc, xmldoc->root, NULL);
    objunlock(xmldoc);
    return rn;
}

void xml_init

(

)

Initialise/Reference the XML library.

Ideally this should be done on application startup but will be started and stoped as needed.

Definition at line 742 of file libxml2.c.

References objalloc(), and objref().

Referenced by xml_loadbuf(), and xml_loaddoc().

                       {
    if (!xml_has_init_parser) {
        xml_has_init_parser = objalloc(0, free_parser);
        xmlInitParser();
        LIBXML_TEST_VERSION
        xmlKeepBlanksDefault(0);
        xmlLoadExtDtdDefaultValue = 1;
        xmlSubstituteEntitiesDefault(1);
    } else {
        objref(xml_has_init_parser);
    }
}

struct xml_doc* xml_loadbuf	(	const uint8_t *	buffer,
		uint32_t	len,
		int	validate
	)

Load a buffer into XML document returning refereence.

Parameters

buffer	Buffer containing the XML.
len	Size of the buffer.
validate	Set to non zero value to fail if validation fails.

Returns

XML Document or NULL on failure

Definition at line 168 of file libxml2.c.

References objalloc(), objunref(), and xml_init().

Referenced by curl_buf2xml().

                                                                                      {
    struct xml_doc *xmldata;
    int flags;

    xml_init();

    if (!(xmldata = objalloc(sizeof(*xmldata), free_xmldata))) {
        return NULL;
    }

    if (validate) {
        flags = XML_PARSE_DTDLOAD | XML_PARSE_DTDVALID;
    } else {
        flags = XML_PARSE_DTDVALID;
    }

    if (!(xmldata->doc = xmlReadMemory((const char *)buffer, len, NULL, NULL, flags))) {
        objunref(xmldata);
        return NULL;
    }
    return xml_setup_parse(xmldata, 0);
}

struct xml_doc* xml_loaddoc	(	const char *	docfile,
		int	validate
	)

Load a XML file into XML document and return reference.

Parameters

docfile	Pathname to XML file.
validate	Set to non zero value to fail if validation fails.

Returns

XML Document or NULL on failure

Definition at line 146 of file libxml2.c.

References objalloc(), objunref(), and xml_init().

                                                                      {
    struct xml_doc *xmldata;

    xml_init();

    if (!(xmldata = objalloc(sizeof(*xmldata), free_xmldata))) {
        return NULL;
    }

    if (!(xmldata->doc = xmlParseFile(docfile))) {
        objunref(xmldata);
        return NULL;
    }

    return xml_setup_parse(xmldata, validate);
}

void xml_modify	(	struct xml_doc *	xmldoc,
		struct xml_node *	xnode,
		const char *	value
	)

Modify a XML node.

Parameters

xmldoc	XML Document node belongs to
xnode	XML Node to modify.
value	Value to set.

Definition at line 469 of file libxml2.c.

References ALLOC_CONST, xml_node::nodeptr, objlock(), objunlock(), and xml_node::value.

                                                                                          {
    xmlChar *encval;
    xmlNodePtr node;

    objlock(xmldoc);
    node = xnode->nodeptr;
    encval = xmlEncodeSpecialChars(xmldoc->doc, (const xmlChar *)value);
    xmlNodeSetContent(node, encval);
    xmlFree(encval);
    encval = xmlNodeListGetString(xmldoc->doc, node->xmlChildrenNode, 1);
    objunlock(xmldoc);

    if (xnode->value) {
        free((void*)xnode->value);
    }
    ALLOC_CONST(xnode->value, (const char *)encval);
    xmlFree(encval);
}

int xml_nodecount

(

struct xml_search *

xsearch

)

Return the number of nodes in the search path.

Parameters

xsearch

Reference to XML xpath search (xml_xpath())

Returns

Number of of nodes.

Definition at line 413 of file libxml2.c.

References xml_search::xpathObj.

Referenced by xml_getfirstnode().

                                                     {
    xmlNodeSetPtr nodeset;

    if (xsearch && xsearch->xpathObj && ((nodeset = xsearch->xpathObj->nodesetval))) {
        return nodeset->nodeNr;
    } else {
        return 0;
    }
}

void xml_savefile	(	struct xml_doc *	xmldoc,
		const char *	file,
		int	format,
		int	compress
	)

Save XML document to a file.

Parameters

xmldoc	Reference to XML document to save.
file	Filename to write the XML document too.
format	Formating flag from libxml2.
compress	Compression level 0[none]-9.

Definition at line 769 of file libxml2.c.

References objlock(), and objunlock().

                                                                                             {
    objlock(xmldoc);
    xmlSetDocCompressMode(xmldoc->doc, compress);
    xmlSaveFormatFile(file, xmldoc->doc, format);
    xmlSetDocCompressMode(xmldoc->doc, 0);
    objunlock(xmldoc);
}

void xml_setattr	(	struct xml_doc *	xmldoc,
		struct xml_node *	xnode,
		const char *	name,
		const char *	value
	)

Modify a XML node attribute.

Parameters

xmldoc	XML Document node belongs to
xnode	XML Node to modify.
name	Attribute to modify.
value	Value to set.

Definition at line 493 of file libxml2.c.

References xml_node::nodeptr, objlock(), and objunlock().

                                                                                                             {
    xmlChar *encval;

    objlock(xmldoc);
    encval = xmlEncodeSpecialChars(xmldoc->doc, (const xmlChar *)value);
    xmlSetProp(xnode->nodeptr, (const xmlChar *)name, (const xmlChar *)encval);
    objunlock(xmldoc);
    xmlFree(encval);
}

void xml_unlink

(

struct xml_node *

xnode

)

Unlink a node from the document.

Parameters

xnode

Reference of node to unlink.

Definition at line 693 of file libxml2.c.

References xml_node::nodeptr, objlock(), and objunlock().

                                               {
    objlock(xnode);
    xmlUnlinkNode(xnode->nodeptr);
    objunlock(xnode);
}

struct xml_search* xml_xpath	(	struct xml_doc *	xmldata,
		const char *	xpath,
		const char *	attrkey
	)

Return a reference to a xpath search result.

Parameters

xmldata	XML Document to search.
xpath	Xpath search to apply.
attrkey	Attribute to index by.

Returns

Reference to XML search result.

Definition at line 381 of file libxml2.c.

References xml_search::nodes, objalloc(), objlock(), objref(), objunlock(), objunref(), xml_search::xmldoc, and xml_search::xpathObj.

                                                                                                     {
    struct xml_search *xpsearch;

    if (!objref(xmldata) || !(xpsearch = objalloc(sizeof(*xpsearch), free_xmlsearch))) {
        return NULL;
    }

    objlock(xmldata);
    xpsearch->xmldoc = xmldata;
    if (!(xpsearch->xpathObj = xmlXPathEvalExpression((const xmlChar *)xpath, xmldata->xpathCtx))) {
        objunlock(xmldata);
        objunref(xpsearch);
        return NULL;
    }

    if (xmlXPathNodeSetIsEmpty(xpsearch->xpathObj->nodesetval)) {
        objunlock(xmldata);
        objunref(xpsearch);
        return NULL;
    }
    objunlock(xmldata);

    if (!(xpsearch->nodes = xml_setnodes(xpsearch, attrkey))) {
        objunref(xpsearch);
        return NULL;
    }
    return xpsearch;
}