src/lib/wsman-libxml2-binding.c - third_party/openwsman - Git at Google

 /*******************************************************************************
  * Copyright (C) 2004-2006 Intel Corp. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  - Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  *
  *  - Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  *
  *  - Neither the name of Intel Corp. nor the names of its
  *    contributors may be used to endorse or promote products derived from this
  *    software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *******************************************************************************/

 /**
  * @author Anas Nashif
  */
 #ifdef HAVE_CONFIG_H
 #include <wsman_config.h>
 #endif

 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>

 #include <assert.h>

 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/xmlstring.h>

 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>


 #include "u/libu.h"
 #include "wsman-xml-api.h"
 #include "wsman-soap.h"
 #include "wsman-xml.h"
 #include "wsman-xml-binding.h"


 static void destroy_attr_private_data(void *data)
 {
 	if (data)
 		xmlFree(data);
 }


 static void destroy_node_private_data(void *_data)
 {
 	iWsNode *data = (iWsNode *) _data;
 	if (data) {
 		// ??? TBD data->nsQNameList;
 		if (data->valText)
 			xmlFree(data->valText);
 		u_free(data);
 	}
 }

 static void destroy_tree_private_data(xmlNode * node)
 {
 	while (node) {
 		xmlAttrPtr attr = node->properties;

 		if (node->_private) {
 			destroy_node_private_data(node->_private);
 			node->_private = NULL;
 		}

 		while (attr) {
 			if (attr->_private) {
 				destroy_attr_private_data(attr->_private);
 				attr->_private = NULL;
 			}
 			attr = attr->next;
 		}
 		destroy_tree_private_data(node->children);
 		node = node->next;
 	}
 }

 static void
 myXmlErrorReporting (void *ctx, const char* msg, ...)
 {
 	va_list args;
 	char *string;
 	va_start(args, msg);
 	string = u_strdup_vprintf (msg, args);
 	warning (string);
 	va_end(args);

 	u_free(string);
 }

 void xml_parser_initialize()
 {
 	xmlSetGenericErrorFunc(NULL, myXmlErrorReporting);
 }

 void xml_parser_destroy()
 {
 }

 int xml_parser_utf8_strlen(char *buf)
 {
 	return xmlUTF8Strlen(BAD_CAST buf);
 }

 void xml_parser_doc_to_memory(WsXmlDocH doc, char **buf,
 		int *ptrSize, const char *encoding)
 {
 	if (doc && buf && ptrSize)
 		xmlDocDumpMemoryEnc(doc->parserDoc,
 				(xmlChar **) buf, ptrSize,
 				(!encoding) ? "UTF-8" : encoding);
 }

 void xml_parser_free_memory(void *ptr)
 {
 	if (ptr)
 		xmlFree(ptr);
 }


 int xml_parser_create_doc_by_import(WsXmlDocH wsDoc, WsXmlNodeH node)
 {
 	xmlDocPtr doc;
 	xmlNodePtr rootNode;

 	if ((doc = xmlNewDoc(BAD_CAST "1.0")) == NULL) {
 		if (doc)
 			xmlFreeDoc(doc);
 		return 0;
 	} else {
 		doc->_private = wsDoc;
 		wsDoc->parserDoc = doc;
 		rootNode = xmlDocCopyNode((xmlNodePtr) node, doc, 1);
 		xmlDocSetRootElement(doc, rootNode);
 		return 1;
 	}
 }

 int xml_parser_create_doc(WsXmlDocH wsDoc, const char *rootName)
 {
 	int retVal = 0;
 	xmlDocPtr doc;
 	xmlNodePtr rootNode;

 	if ((doc = xmlNewDoc(BAD_CAST "1.0")) == NULL ||
 			(rootNode = xmlNewNode(NULL, BAD_CAST rootName)) == NULL) {
 		if (doc)
 			xmlFreeDoc(doc);
 	} else {
 		doc->_private = wsDoc;
 		wsDoc->parserDoc = doc;
 		xmlDocSetRootElement(doc, rootNode);
 		retVal = 1;
 	}

 	return retVal;
 }


 void xml_parser_destroy_doc(WsXmlDocH wsDoc)
 {
 	xmlDocPtr xmlDoc = (xmlDocPtr) wsDoc->parserDoc;
 	if (xmlDoc != NULL) {
 		destroy_tree_private_data(xmlDocGetRootElement(xmlDoc));
 		xmlFreeDoc(xmlDoc);
 	}
 }


 WsXmlDocH xml_parser_get_doc(WsXmlNodeH node)
 {
 	xmlDocPtr xmlDoc = ((xmlDocPtr) node)->doc;
 	return (WsXmlDocH) (!xmlDoc ? NULL : xmlDoc->_private);
 }


 WsXmlNodeH xml_parser_get_root(WsXmlDocH doc)
 {
 	if (doc->parserDoc != NULL)
 		return (WsXmlNodeH) xmlDocGetRootElement((xmlDocPtr) doc->
 				parserDoc);
 	return NULL;
 }

 WsXmlDocH
 xml_parser_file_to_doc( const char *filename,
 		const char *encoding, unsigned long options)
 {
 	xmlDocPtr xmlDoc;
 	WsXmlDocH Doc = NULL;

 	xmlDoc = xmlReadFile(filename, encoding,
 			XML_PARSE_NONET | XML_PARSE_NSCLEAN);
 	if (xmlDoc == NULL) {
 		return NULL;
 	}
 	Doc = (WsXmlDocH) u_zalloc(sizeof(*Doc));
 	if (Doc == NULL) {
 		xmlFreeDoc(xmlDoc);
 		return NULL;
 	}
 	xmlDoc->_private = Doc;
 	Doc->parserDoc = xmlDoc;

 	return Doc;

 }

 WsXmlDocH
 xml_parser_memory_to_doc( const char *buf, size_t size,
 		const char *encoding, unsigned long options)
 {
 	WsXmlDocH Doc = NULL;
 	xmlDocPtr xmlDoc;
 	if (!buf || !size ) {
 		return NULL;
 	}
 	xmlDoc = xmlReadMemory(buf, (int) size, NULL, encoding,
 			XML_PARSE_NONET | XML_PARSE_NSCLEAN);
 	if (xmlDoc == NULL) {
 		return NULL;
 	}
 	Doc = (WsXmlDocH) u_zalloc(sizeof(*Doc));
 	if (Doc == NULL) {
 		xmlFreeDoc(xmlDoc);
 		return NULL;
 	}

 	xmlDoc->_private = Doc;
 	Doc->parserDoc = xmlDoc;

 	return Doc;
 }


 char *xml_parser_node_query(WsXmlNodeH node, int what)
 {
 	char *ptr = NULL;
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	iWsNode *wsNode = (iWsNode *) xmlNode->_private;

 	switch (what) {
 	case XML_TEXT_VALUE:
 		if (wsNode == NULL)
 			xmlNode->_private = wsNode =
 				u_zalloc(sizeof(iWsNode));

 		if (wsNode != NULL) {
 			if (wsNode->valText == NULL) {
 				wsNode->valText =
 					(char *) xmlNodeGetContent(xmlNode);
 			}
 			ptr = wsNode->valText;
 		}
 		break;
 	case XML_LOCAL_NAME:
 		ptr = (char *) xmlNode->name;
 		break;
 	case XML_NS_URI:
 		if (xmlNode->ns != NULL)
 			ptr = (char *) xmlNode->ns->href;
 		break;
 	case XML_NS_PREFIX:
 		if (xmlNode->ns != NULL)
 			ptr = (char *) xmlNode->ns->prefix;
 		break;
 	default:
 		break;
 	}

 	return ptr;
 }


 int xml_parser_node_set(WsXmlNodeH node, int what, const char *str)
 {
 	int retVal = -1;
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	iWsNode *wsNode = (iWsNode *) xmlNode->_private;
 	xmlNsPtr xmlNs;

 	switch (what) {
 	case XML_TEXT_VALUE:
 		if (wsNode == NULL)
 			xmlNode->_private = wsNode =
 				u_zalloc(sizeof(iWsNode));

 		if (wsNode != NULL) {
 			if (wsNode->valText != NULL) {
 				xmlFree(wsNode->valText);
 				wsNode->valText = NULL;
 			}
 			xmlNodeSetContent(xmlNode, BAD_CAST str);
 			retVal = 0;
 		}
 		break;

 	case XML_LOCAL_NAME:
 		xmlNodeSetName(xmlNode, BAD_CAST str);
 		retVal = 0;
 		break;

 	case XML_NS_URI:
 		if ((xmlNs = (xmlNsPtr) xml_parser_ns_find(node, str, NULL, 1,
 						1)) != NULL) {
 			xmlNode->ns = xmlNs;
 			retVal = 0;
 		} else
 			retVal = 1;
 		break;
 	default:
 		retVal = 1;
 		break;
 	}

 	return retVal;
 }


 WsXmlNodeH xml_parser_node_get(WsXmlNodeH node, int which)
 {
 	xmlNodePtr xmlNode = NULL;
 	xmlNodePtr base = (xmlNodePtr) node;

 	switch (which) {
 	case XML_ELEMENT_PARENT:
 		xmlNode = base->parent;
 		break;
 	case XML_ELEMENT_NEXT:
 		if ((xmlNode = base->next) != NULL) {
 			do {
 				if (xmlNode->type == XML_ELEMENT_NODE)
 					break;
 			}
 			while ((xmlNode = xmlNode->next) != NULL);
 		}
 		break;
 	case XML_ELEMENT_PREV:
 		if ((xmlNode = base->prev) != NULL) {
 			do {
 				if (xmlNode->type == XML_ELEMENT_NODE)
 					break;
 			}
 			while ((xmlNode = xmlNode->prev) != NULL);
 		}
 		break;
 	case XML_LAST_CHILD:
 	default:
 		if (which >= 0 || which == XML_LAST_CHILD) {
 			int count = 0;
 			xmlNode = base->children;

 			while (xmlNode) {
 				if (xmlNode->type == XML_ELEMENT_NODE) {
 					if (which == XML_LAST_CHILD &&
 							xmlNode->next == NULL)
 						break;

 					if (count == which)
 						break;

 					count++;
 				}
 				xmlNode = xmlNode->next;
 			}
 		} else {
 			assert(which >= 0);
 		}
 		break;
 	}
 	return (WsXmlNodeH) xmlNode;
 }

 /* check if namespace is defined (at document root)
  * and evtl. (bAddAtRootIfNotFound!=0) add it to the root node
  */

 WsXmlNsH
 xml_parser_ns_find(WsXmlNodeH node,
 		const char *uri,
 		const char *prefix,
 		int bWalkUpTree, int bAddAtRootIfNotFound)
 {
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	xmlNsPtr xmlNs = NULL;

 	while (xmlNode != NULL) {
 		xmlNs = xmlNode->nsDef;
 		while (xmlNs != NULL) {
 			if (uri) {
 				if (!strcmp((char *) xmlNs->href, uri))
 					break;
 			} else if (prefix == NULL) {
 				if (xmlNs->prefix == NULL)
 					break;
 			} else
 				if (xmlNs->prefix &&
 						!strcmp((char *) xmlNs->prefix, prefix)) {
 					break;
 				}
 			xmlNs = xmlNs->next;
 		}
 		if (xmlNs != NULL || !bWalkUpTree)
 			break;
 		xmlNode = xmlNode->parent;
 	}

 	if (xmlNs == NULL && bAddAtRootIfNotFound) {
 		xmlNodePtr xmlRoot =
 			xmlDocGetRootElement(((xmlDocPtr) node)->doc);
 		char buf[12];

 		if (prefix == NULL) {
 			ws_xml_make_default_prefix((WsXmlNodeH) xmlRoot,
 					uri, buf, sizeof(buf));
 			prefix = buf;
 		}
 		xmlNs =
 			(xmlNsPtr) xml_parser_ns_add((WsXmlNodeH) xmlRoot, uri,
 					prefix);
 	}
 	return (WsXmlNsH) xmlNs;
 }

 char *xml_parser_ns_query(WsXmlNsH ns, int what)
 {
 	xmlNsPtr xmlNs = (xmlNsPtr) ns;
 	char *ptr = NULL;

 	switch (what) {
 	case XML_NS_URI:
 		ptr = (char *) xmlNs->href;
 		break;
 	case XML_NS_PREFIX:
 		ptr = (char *) xmlNs->prefix;
 		break;
 	default:
 		assert(what == XML_NS_URI);
 		break;
 	}
 	return ptr;
 }


 WsXmlNsH
 xml_parser_ns_add(WsXmlNodeH node, const char *uri, const char *prefix)
 {
 	xmlNsPtr xmlNs = NULL;
 	if (node && uri) {
 		if ((xmlNs = (xmlNsPtr) xml_parser_ns_find(node, uri, NULL, 0, 0)) != NULL) {
                         /* namespace is known */
 			if (xmlNs->prefix != NULL) {
 				xmlFree((char *) xmlNs->prefix);
 				xmlNs->prefix = NULL;
 			}
 			if (prefix != NULL) {
 				xmlNs->prefix = xmlStrdup(BAD_CAST prefix);
 			}
 		} else {
                         /* create new namespace entry */
 			xmlNs =	xmlNewNs((xmlNodePtr) node, BAD_CAST uri, BAD_CAST prefix);
 			/* since the 'xml:' name is supposed to be predefined, the above
                          * function will return NULL when prefix == xml && uri == XML_XML_NAMESPACE.
                          * Compensate for this here.
                          */
 			if (xmlNs == NULL && strcmp(prefix,"xml") == 0
                             && strcmp(uri, (const char *)XML_XML_NAMESPACE) == 0) {
 				xmlNs = (xmlNsPtr) u_zalloc(sizeof(*xmlNs));
 				if (xmlNs == NULL) {
 					error("Couldn't create a new Namespace structure");
 					return(NULL);
 				}
 				xmlNs->type = XML_LOCAL_NAMESPACE;
 				xmlNs->href = xmlStrdup((const xmlChar *)uri);
 				xmlNs->prefix = xmlStrdup((const xmlChar *)prefix);
 			}
 		}
 	}
 	return (WsXmlNsH) xmlNs;
 }


 int xml_parser_ns_remove(WsXmlNodeH node, const char *nsUri)
 {
 	int retVal = -1;

 	if (node && nsUri) {
 		xmlNodePtr xmlNode = (xmlNodePtr) node;
 		xmlNsPtr xmlNs = xmlNode->nsDef;
 		xmlNsPtr prevNs = NULL;

 		while (xmlNs != NULL) {
 			if ((xmlStrEqual(xmlNs->href, BAD_CAST nsUri))) {
 				break;
 			}
 			prevNs = xmlNs;
 			xmlNs = xmlNs->next;
 		}

 		if (xmlNs != NULL) {
 			retVal = 0;
 			if (prevNs == NULL)
 				xmlNode->nsDef = xmlNs->next;
 			else
 				prevNs->next = xmlNs->next;
 			xmlFreeNs(xmlNs);
 		} else
 			retVal = 1;
 	}
 	return retVal;
 }


 WsXmlNsH xml_parser_ns_get(WsXmlNodeH node, int which)
 {
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	xmlNsPtr xmlNs = NULL;

 	if (which >= 0) {
 		int count = 0;
 		xmlNs = xmlNode->nsDef;
 		while (xmlNs != NULL) {
 			if (which == count)
 				break;
 			count++;
 			xmlNs = xmlNs->next;
 		}
 	} else {
 		assert(which >= 0);
 	}
 	return (WsXmlNsH) xmlNs;
 }


 static
 int get_ns_count_at_node(xmlNodePtr xmlNode)
 {
 	int count = 0;
 	xmlNsPtr xmlNs = xmlNode->nsDef;

 	while (xmlNs != NULL) {
 		count++;
 		xmlNs = xmlNs->next;
 	}
 	return count;
 }


 int xml_parser_get_count(WsXmlNodeH node, int what, int bWalkUpTree)
 {
 	int count = 0;
 	xmlNodePtr xmlNode;
 	xmlAttrPtr xmlAttr;

 	switch (what) {
 	case XML_COUNT_NODE:
 		xmlNode = ((xmlNodePtr) node)->children;
 		while (xmlNode) {
 			if (xmlNode->type == XML_ELEMENT_NODE)
 				count++;
 			xmlNode = xmlNode->next;
 		}
 		break;
 	case XML_COUNT_ATTR:
 		xmlAttr = ((xmlNodePtr) node)->properties;
 		while (xmlAttr) {
 			count++;
 			xmlAttr = xmlAttr->next;
 		}
 		break;
 	case XML_COUNT_NS:
 		xmlNode = (xmlNodePtr) node;
 		while (xmlNode != NULL) {
 			count += get_ns_count_at_node(xmlNode);
 			if (!bWalkUpTree)
 				break;
 			xmlNode = xmlNode->parent;
 		}
 		break;
 	default:
 		assert(what == XML_COUNT_NODE || what == XML_COUNT_ATTR ||
 				what == XML_COUNT_NS);
 		break;
 	}

 	return count;
 }

 static xmlNodePtr
 make_new_xml_node(xmlNodePtr base,
 		const char *uri, const char *name, const char *value, int xmlescape)
 {
 	xmlNodePtr newNode = NULL;
 	xmlNsPtr ns = NULL;
 	if (uri == NULL ||
 			(ns =
 			 (xmlNsPtr) xml_parser_ns_find((WsXmlNodeH) base, uri, NULL, 1,
 				 1)) != NULL) {
 		if ((newNode = xmlNewNode(ns, BAD_CAST name)) != NULL) {
 			if (value != NULL){
 				if (xmlescape == 1)
 					xmlNodeAddContent(newNode, BAD_CAST value);
 				else
 					xmlNodeSetContent(newNode, BAD_CAST value);
 			}
 			newNode->_private = u_zalloc(sizeof(iWsNode));
 		}
 	}
 	return newNode;
 }


 WsXmlNodeH
 xml_parser_node_add(WsXmlNodeH base,
 		int where,
 		const char *nsUri,
 		const char *localName, const char *value, int xmlescape)
 {
 	xmlNodePtr xmlBase = (xmlNodePtr) base;
 	xmlNodePtr newNode =
 		make_new_xml_node((where != XML_ELEMENT_NEXT &&
 					where != XML_ELEMENT_PREV)
 				? xmlBase : xmlBase->parent, nsUri,
 				localName, value, xmlescape);
 	if (newNode) {
 		switch (where) {
 		case XML_ELEMENT_NEXT:
 			xmlAddNextSibling((xmlNodePtr) base, newNode);
 			break;
 		case XML_ELEMENT_PREV:
 			xmlAddPrevSibling((xmlNodePtr) base, newNode);
 			break;
 		case XML_LAST_CHILD:
 		default:
 			xmlAddChild((xmlNodePtr) base, newNode);
 			break;
 		}
 	}
 	return (WsXmlNodeH) newNode;

 }

 int xml_parser_node_remove(WsXmlNodeH node)
 {
 	destroy_node_private_data(((xmlNodePtr) node)->_private);
 	xmlUnlinkNode((xmlNodePtr) node);
 	xmlFreeNode((xmlNodePtr) node);
 	return 0;
 }


 WsXmlAttrH
 xml_parser_attr_add(WsXmlNodeH node,
 		const char *uri, const char *name, const char *value)
 {
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	xmlNsPtr xmlNs =
 		(xmlNsPtr) xml_parser_ns_find(node, uri, NULL, 1, 1);
 	xmlAttrPtr xmlAttr =
 		(xmlAttrPtr) ws_xml_find_node_attr(node, uri, name);

 	if (xmlAttr != NULL)
 		ws_xml_remove_node_attr((WsXmlAttrH) xmlAttr);

 	if (xmlNs == NULL)
 		xmlAttr =
 			xmlNewProp(xmlNode, BAD_CAST name, BAD_CAST value);
 	else
 		xmlAttr =
 			xmlNewNsProp(xmlNode, xmlNs, BAD_CAST name,
 					BAD_CAST value);

 	if (xmlAttr != NULL) {
 		if (xmlNs == NULL)
 			xmlAttr->_private =
 				xmlGetProp(xmlNode, BAD_CAST name);
 		else
 			xmlAttr->_private =
 				xmlGetNsProp(xmlNode, BAD_CAST name,
 						xmlNs->href);
 	}

 	return (WsXmlAttrH) xmlAttr;
 }


 int xml_parser_attr_remove(WsXmlAttrH attr)
 {
 	xmlAttrPtr xmlAttr = (xmlAttrPtr) attr;
 	xmlNodePtr xmlNode = (xmlNodePtr) xmlAttr->parent;
 	xmlAttrPtr xmlAttrPrev =
 		(xmlNode->properties == xmlAttr) ? NULL : xmlNode->properties;

 	while (xmlAttrPrev != NULL && xmlAttrPrev->next != xmlAttr) {
 		xmlAttrPrev = xmlAttrPrev->next;
 	}
 	if (xmlAttrPrev != NULL)
 		xmlAttrPrev->next = xmlAttr->next;
 	else
 		xmlNode->properties = xmlAttr->next;

 	xmlNode->parent = NULL;
 	xmlNode->next = NULL;

 	destroy_attr_private_data((xmlAttrPtr) attr);
 	xmlFreeProp((xmlAttrPtr) attr);

 	return 0;
 }

 char *xml_parser_attr_query(WsXmlAttrH attr, int what)
 {
 	char *ptr = NULL;
 	xmlAttrPtr xmlAttr = (xmlAttrPtr) attr;
 	switch (what) {
 	case XML_LOCAL_NAME:
 		ptr = (char *) xmlAttr->name;
 		break;
 	case XML_NS_URI:
 		if (xmlAttr->ns != NULL)
 			ptr = (char *) xmlAttr->ns->href;
 		break;
 	case XML_NS_PREFIX:
 		if (xmlAttr->ns != NULL)
 			ptr = (char *) xmlAttr->ns->prefix;
 		break;
 	case XML_TEXT_VALUE:
 		if (xmlAttr->_private == NULL) {
 			if (xmlAttr->ns == NULL)
 				xmlAttr->_private =
 					xmlGetProp(xmlAttr->parent,
 							xmlAttr->name);
 			else
 				xmlAttr->_private =
 					xmlGetNsProp(xmlAttr->parent,
 							xmlAttr->name,
 							xmlAttr->ns->href);
 		}
 		ptr = (char *) xmlAttr->_private;
 		break;
 	default:
 		assert(what == XML_LOCAL_NAME);
 		break;
 	}
 	return ptr;
 }


 WsXmlAttrH xml_parser_attr_get(WsXmlNodeH node, int which)
 {
 	xmlNodePtr xmlNode = (xmlNodePtr) node;
 	xmlAttrPtr xmlAttr = NULL;

 	switch (which) {
 	case XML_LAST_CHILD:
 	default:
 		if (which >= 0 || which == XML_LAST_CHILD) {
 			int count = 0;
 			xmlAttr = xmlNode->properties;

 			while (xmlAttr) {
 				if (which == XML_LAST_CHILD &&
 						xmlAttr->next == NULL)
 					break;

 				if (which == count)
 					break;

 				count++;

 				xmlAttr = xmlAttr->next;
 			}
 		} else {
 			assert(which >= 0 || which == XML_LAST_CHILD);
 		}
 		break;
 	}

 	return (WsXmlAttrH) xmlAttr;
 }


 void xml_parser_element_dump(FILE * f, WsXmlDocH doc, WsXmlNodeH node)
 {

 	xmlNodePtr n = (xmlNodePtr) node;
 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
 	xmlElemDump(f, d, n);
 }

 void xml_parser_doc_dump(FILE * f, WsXmlDocH doc)
 {

 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
 	xmlDocFormatDump(f, d, 1);
 	return;
 }

 void xml_parser_doc_dump_memory(WsXmlDocH doc, char **buf, int *ptrSize)
 {

 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
 	xmlDocDumpFormatMemory(d, (xmlChar **) buf, ptrSize, 1);
 	return;
 }

 void xml_parser_doc_dump_memory_enc(WsXmlDocH doc, char **buf, int *ptrSize, const char *encoding)
 {

 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
         xmlDocDumpFormatMemoryEnc(d, (xmlChar **) buf, ptrSize, encoding?encoding:"UTF-8", 1);
 	return;
 }

 static void
 register_namespaces(xmlXPathContextPtr ctxt, WsXmlDocH doc,
 		WsXmlNodeH node)
 {
 	xmlNsPtr *nsList, *cur;
 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;


 	nsList = xmlGetNsList(d, (xmlNodePtr) node);
 	if (nsList == NULL) {
 		return;
 	}
 	for (cur = nsList; *cur != NULL; cur++) {
 		if (xmlXPathRegisterNs(ctxt, (*cur)->prefix, (*cur)->href)
 				!= 0) {
 			return;
 		}
 	}
 	xmlFree(nsList);
 }


 int xml_parser_check_xpath(WsXmlDocH doc, const char *expression)
 {
 	xmlXPathObject *obj;
 	xmlNodeSetPtr nodeset;
 	xmlXPathContextPtr ctxt;
 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
 	int retval = 0;

 	ctxt = xmlXPathNewContext(d);
 	if (ctxt == NULL) {
 		error("failed while creating xpath context");
 		return 0;
 	}
 	register_namespaces(ctxt, doc, xml_parser_get_root(doc));
 	obj = xmlXPathEvalExpression(BAD_CAST expression, ctxt);
 	if (obj) {
 		nodeset = obj->nodesetval;
 		if (nodeset && nodeset->nodeNr > 0) {
 			int size = nodeset->nodeNr;
 			int i;
 			xmlNodePtr cur;
 			for(i = 0; i < size; ++i) {
 				if(nodeset->nodeTab[i]->type == XML_ELEMENT_NODE) {
 					cur = nodeset->nodeTab[i];
 					if(cur->ns) {
 						fprintf(stdout, "= element node \"%s:%s\"\n",
 								cur->ns->href, cur->name);
 					} else {
 						fprintf(stdout, "= element node \"%s\"\n",
 								cur->name);
 					}
 				}
 			}

 			retval = 1;
 		}
 		xmlXPathFreeObject(obj);
 	}
 	xmlXPathFreeContext(ctxt);

 	return retval;
 }


 char *xml_parser_get_xpath_value(WsXmlDocH doc, const char *expression)
 {
 	//int i;
 	char *result = NULL;
 	xmlXPathObject *obj;
 	xmlNodeSetPtr nodeset;
 	xmlXPathContextPtr ctxt;
 	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
 	WsXmlNodeH body;

 	ctxt = xmlXPathNewContext(d);
 	if (ctxt == NULL) {
 		error("failed while creating xpath context");
 		return NULL;
 	}
 	body = ws_xml_get_soap_body(doc);
 	register_namespaces(ctxt, doc, xml_parser_get_root(doc));
 	if (ws_xml_get_child(body, 0, NULL, NULL)) {
 		register_namespaces(ctxt, doc,
 				ws_xml_get_child(body, 0, NULL, NULL));
 	}

 	obj = xmlXPathEvalExpression(BAD_CAST expression, ctxt);
 	if (obj) {
 		nodeset = obj->nodesetval;
 		if (nodeset && nodeset->nodeNr > 0)
 			result = (char *) xmlNodeListGetString(d,
 					nodeset->
 					nodeTab[0]->
 					xmlChildrenNode,
 					1);

 		xmlXPathFreeObject(obj);
 	}
 	xmlXPathFreeContext(ctxt);

 	return result;
 }


 void xml_parser_unlink_node(WsXmlNodeH node)
 {
 	xmlUnlinkNode((xmlNodePtr) node);
 	xmlFreeNode((xmlNodePtr) node);
 	return;
 }

 void xml_parser_node_set_lang(WsXmlNodeH node,  const char *lang)
 {
 	xmlNodeSetLang((xmlNodePtr) node, BAD_CAST lang);
 }


 void xml_parser_set_ns(WsXmlNodeH r, WsXmlNsH ns, const char *prefix)
 {
 	xmlSetNs((xmlNodePtr) r, (xmlNsPtr) ns);
 }

 void xml_parser_copy_node(WsXmlNodeH src, WsXmlNodeH dst)
 {
 	if (src && dst) {
 		xmlNodePtr x = xmlDocCopyNode((xmlNodePtr) src,
 				   ((xmlDocPtr) src)->doc, 1);
 		if (x)
 			xmlAddChild((xmlNodePtr) dst, x);
 	}
 }
	/*******************************************************************************
	* Copyright (C) 2004-2006 Intel Corp. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* - Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* - Neither the name of Intel Corp. nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*******************************************************************************/

	/**
	* @author Anas Nashif
	*/
	#ifdef HAVE_CONFIG_H
	#include <wsman_config.h>
	#endif

	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <ctype.h>

	#include <assert.h>

	#include <libxml/xmlmemory.h>
	#include <libxml/parser.h>
	#include <libxml/xmlstring.h>

	#include <libxml/xpath.h>
	#include <libxml/xpathInternals.h>


	#include "u/libu.h"
	#include "wsman-xml-api.h"
	#include "wsman-soap.h"
	#include "wsman-xml.h"
	#include "wsman-xml-binding.h"


	static void destroy_attr_private_data(void *data)
	{
	if (data)
	xmlFree(data);
	}


	static void destroy_node_private_data(void *_data)
	{
	iWsNode data = (iWsNode ) _data;
	if (data) {
	// ??? TBD data->nsQNameList;
	if (data->valText)
	xmlFree(data->valText);
	u_free(data);
	}
	}

	static void destroy_tree_private_data(xmlNode * node)
	{
	while (node) {
	xmlAttrPtr attr = node->properties;

	if (node->_private) {
	destroy_node_private_data(node->_private);
	node->_private = NULL;
	}

	while (attr) {
	if (attr->_private) {
	destroy_attr_private_data(attr->_private);
	attr->_private = NULL;
	}
	attr = attr->next;
	}
	destroy_tree_private_data(node->children);
	node = node->next;
	}
	}

	static void
	myXmlErrorReporting (void ctx, const char msg, ...)
	{
	va_list args;
	char *string;
	va_start(args, msg);
	string = u_strdup_vprintf (msg, args);
	warning (string);
	va_end(args);

	u_free(string);
	}

	void xml_parser_initialize()
	{
	xmlSetGenericErrorFunc(NULL, myXmlErrorReporting);
	}

	void xml_parser_destroy()
	{
	}

	int xml_parser_utf8_strlen(char *buf)
	{
	return xmlUTF8Strlen(BAD_CAST buf);
	}

	void xml_parser_doc_to_memory(WsXmlDocH doc, char **buf,
	int ptrSize, const char encoding)
	{
	if (doc && buf && ptrSize)
	xmlDocDumpMemoryEnc(doc->parserDoc,
	(xmlChar **) buf, ptrSize,
	(!encoding) ? "UTF-8" : encoding);
	}

	void xml_parser_free_memory(void *ptr)
	{
	if (ptr)
	xmlFree(ptr);
	}



	int xml_parser_create_doc_by_import(WsXmlDocH wsDoc, WsXmlNodeH node)
	{
	xmlDocPtr doc;
	xmlNodePtr rootNode;

	if ((doc = xmlNewDoc(BAD_CAST "1.0")) == NULL) {
	if (doc)
	xmlFreeDoc(doc);
	return 0;
	} else {
	doc->_private = wsDoc;
	wsDoc->parserDoc = doc;
	rootNode = xmlDocCopyNode((xmlNodePtr) node, doc, 1);
	xmlDocSetRootElement(doc, rootNode);
	return 1;
	}
	}

	int xml_parser_create_doc(WsXmlDocH wsDoc, const char *rootName)
	{
	int retVal = 0;
	xmlDocPtr doc;
	xmlNodePtr rootNode;

	if ((doc = xmlNewDoc(BAD_CAST "1.0")) == NULL \|\|
	(rootNode = xmlNewNode(NULL, BAD_CAST rootName)) == NULL) {
	if (doc)
	xmlFreeDoc(doc);
	} else {
	doc->_private = wsDoc;
	wsDoc->parserDoc = doc;
	xmlDocSetRootElement(doc, rootNode);
	retVal = 1;
	}

	return retVal;
	}



	void xml_parser_destroy_doc(WsXmlDocH wsDoc)
	{
	xmlDocPtr xmlDoc = (xmlDocPtr) wsDoc->parserDoc;
	if (xmlDoc != NULL) {
	destroy_tree_private_data(xmlDocGetRootElement(xmlDoc));
	xmlFreeDoc(xmlDoc);
	}
	}


	WsXmlDocH xml_parser_get_doc(WsXmlNodeH node)
	{
	xmlDocPtr xmlDoc = ((xmlDocPtr) node)->doc;
	return (WsXmlDocH) (!xmlDoc ? NULL : xmlDoc->_private);
	}


	WsXmlNodeH xml_parser_get_root(WsXmlDocH doc)
	{
	if (doc->parserDoc != NULL)
	return (WsXmlNodeH) xmlDocGetRootElement((xmlDocPtr) doc->
	parserDoc);
	return NULL;
	}

	WsXmlDocH
	xml_parser_file_to_doc( const char *filename,
	const char *encoding, unsigned long options)
	{
	xmlDocPtr xmlDoc;
	WsXmlDocH Doc = NULL;

	xmlDoc = xmlReadFile(filename, encoding,
	XML_PARSE_NONET \| XML_PARSE_NSCLEAN);
	if (xmlDoc == NULL) {
	return NULL;
	}
	Doc = (WsXmlDocH) u_zalloc(sizeof(*Doc));
	if (Doc == NULL) {
	xmlFreeDoc(xmlDoc);
	return NULL;
	}
	xmlDoc->_private = Doc;
	Doc->parserDoc = xmlDoc;

	return Doc;

	}

	WsXmlDocH
	xml_parser_memory_to_doc( const char *buf, size_t size,
	const char *encoding, unsigned long options)
	{
	WsXmlDocH Doc = NULL;
	xmlDocPtr xmlDoc;
	if (!buf \|\| !size ) {
	return NULL;
	}
	xmlDoc = xmlReadMemory(buf, (int) size, NULL, encoding,
	XML_PARSE_NONET \| XML_PARSE_NSCLEAN);
	if (xmlDoc == NULL) {
	return NULL;
	}
	Doc = (WsXmlDocH) u_zalloc(sizeof(*Doc));
	if (Doc == NULL) {
	xmlFreeDoc(xmlDoc);
	return NULL;
	}

	xmlDoc->_private = Doc;
	Doc->parserDoc = xmlDoc;

	return Doc;
	}


	char *xml_parser_node_query(WsXmlNodeH node, int what)
	{
	char *ptr = NULL;
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	iWsNode wsNode = (iWsNode ) xmlNode->_private;

	switch (what) {
	case XML_TEXT_VALUE:
	if (wsNode == NULL)
	xmlNode->_private = wsNode =
	u_zalloc(sizeof(iWsNode));

	if (wsNode != NULL) {
	if (wsNode->valText == NULL) {
	wsNode->valText =
	(char *) xmlNodeGetContent(xmlNode);
	}
	ptr = wsNode->valText;
	}
	break;
	case XML_LOCAL_NAME:
	ptr = (char *) xmlNode->name;
	break;
	case XML_NS_URI:
	if (xmlNode->ns != NULL)
	ptr = (char *) xmlNode->ns->href;
	break;
	case XML_NS_PREFIX:
	if (xmlNode->ns != NULL)
	ptr = (char *) xmlNode->ns->prefix;
	break;
	default:
	break;
	}

	return ptr;
	}


	int xml_parser_node_set(WsXmlNodeH node, int what, const char *str)
	{
	int retVal = -1;
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	iWsNode wsNode = (iWsNode ) xmlNode->_private;
	xmlNsPtr xmlNs;

	switch (what) {
	case XML_TEXT_VALUE:
	if (wsNode == NULL)
	xmlNode->_private = wsNode =
	u_zalloc(sizeof(iWsNode));

	if (wsNode != NULL) {
	if (wsNode->valText != NULL) {
	xmlFree(wsNode->valText);
	wsNode->valText = NULL;
	}
	xmlNodeSetContent(xmlNode, BAD_CAST str);
	retVal = 0;
	}
	break;

	case XML_LOCAL_NAME:
	xmlNodeSetName(xmlNode, BAD_CAST str);
	retVal = 0;
	break;

	case XML_NS_URI:
	if ((xmlNs = (xmlNsPtr) xml_parser_ns_find(node, str, NULL, 1,
	1)) != NULL) {
	xmlNode->ns = xmlNs;
	retVal = 0;
	} else
	retVal = 1;
	break;
	default:
	retVal = 1;
	break;
	}

	return retVal;
	}



	WsXmlNodeH xml_parser_node_get(WsXmlNodeH node, int which)
	{
	xmlNodePtr xmlNode = NULL;
	xmlNodePtr base = (xmlNodePtr) node;

	switch (which) {
	case XML_ELEMENT_PARENT:
	xmlNode = base->parent;
	break;
	case XML_ELEMENT_NEXT:
	if ((xmlNode = base->next) != NULL) {
	do {
	if (xmlNode->type == XML_ELEMENT_NODE)
	break;
	}
	while ((xmlNode = xmlNode->next) != NULL);
	}
	break;
	case XML_ELEMENT_PREV:
	if ((xmlNode = base->prev) != NULL) {
	do {
	if (xmlNode->type == XML_ELEMENT_NODE)
	break;
	}
	while ((xmlNode = xmlNode->prev) != NULL);
	}
	break;
	case XML_LAST_CHILD:
	default:
	if (which >= 0 \|\| which == XML_LAST_CHILD) {
	int count = 0;
	xmlNode = base->children;

	while (xmlNode) {
	if (xmlNode->type == XML_ELEMENT_NODE) {
	if (which == XML_LAST_CHILD &&
	xmlNode->next == NULL)
	break;

	if (count == which)
	break;

	count++;
	}
	xmlNode = xmlNode->next;
	}
	} else {
	assert(which >= 0);
	}
	break;
	}
	return (WsXmlNodeH) xmlNode;
	}

	/* check if namespace is defined (at document root)
	* and evtl. (bAddAtRootIfNotFound!=0) add it to the root node
	*/

	WsXmlNsH
	xml_parser_ns_find(WsXmlNodeH node,
	const char *uri,
	const char *prefix,
	int bWalkUpTree, int bAddAtRootIfNotFound)
	{
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	xmlNsPtr xmlNs = NULL;

	while (xmlNode != NULL) {
	xmlNs = xmlNode->nsDef;
	while (xmlNs != NULL) {
	if (uri) {
	if (!strcmp((char *) xmlNs->href, uri))
	break;
	} else if (prefix == NULL) {
	if (xmlNs->prefix == NULL)
	break;
	} else
	if (xmlNs->prefix &&
	!strcmp((char *) xmlNs->prefix, prefix)) {
	break;
	}
	xmlNs = xmlNs->next;
	}
	if (xmlNs != NULL \|\| !bWalkUpTree)
	break;
	xmlNode = xmlNode->parent;
	}

	if (xmlNs == NULL && bAddAtRootIfNotFound) {
	xmlNodePtr xmlRoot =
	xmlDocGetRootElement(((xmlDocPtr) node)->doc);
	char buf[12];

	if (prefix == NULL) {
	ws_xml_make_default_prefix((WsXmlNodeH) xmlRoot,
	uri, buf, sizeof(buf));
	prefix = buf;
	}
	xmlNs =
	(xmlNsPtr) xml_parser_ns_add((WsXmlNodeH) xmlRoot, uri,
	prefix);
	}
	return (WsXmlNsH) xmlNs;
	}

	char *xml_parser_ns_query(WsXmlNsH ns, int what)
	{
	xmlNsPtr xmlNs = (xmlNsPtr) ns;
	char *ptr = NULL;

	switch (what) {
	case XML_NS_URI:
	ptr = (char *) xmlNs->href;
	break;
	case XML_NS_PREFIX:
	ptr = (char *) xmlNs->prefix;
	break;
	default:
	assert(what == XML_NS_URI);
	break;
	}
	return ptr;
	}


	WsXmlNsH
	xml_parser_ns_add(WsXmlNodeH node, const char uri, const char prefix)
	{
	xmlNsPtr xmlNs = NULL;
	if (node && uri) {
	if ((xmlNs = (xmlNsPtr) xml_parser_ns_find(node, uri, NULL, 0, 0)) != NULL) {
	/* namespace is known */
	if (xmlNs->prefix != NULL) {
	xmlFree((char *) xmlNs->prefix);
	xmlNs->prefix = NULL;
	}
	if (prefix != NULL) {
	xmlNs->prefix = xmlStrdup(BAD_CAST prefix);
	}
	} else {
	/* create new namespace entry */
	xmlNs = xmlNewNs((xmlNodePtr) node, BAD_CAST uri, BAD_CAST prefix);
	/* since the 'xml:' name is supposed to be predefined, the above
	* function will return NULL when prefix == xml && uri == XML_XML_NAMESPACE.
	* Compensate for this here.
	*/
	if (xmlNs == NULL && strcmp(prefix,"xml") == 0
	&& strcmp(uri, (const char *)XML_XML_NAMESPACE) == 0) {
	xmlNs = (xmlNsPtr) u_zalloc(sizeof(*xmlNs));
	if (xmlNs == NULL) {
	error("Couldn't create a new Namespace structure");
	return(NULL);
	}
	xmlNs->type = XML_LOCAL_NAMESPACE;
	xmlNs->href = xmlStrdup((const xmlChar *)uri);
	xmlNs->prefix = xmlStrdup((const xmlChar *)prefix);
	}
	}
	}
	return (WsXmlNsH) xmlNs;
	}


	int xml_parser_ns_remove(WsXmlNodeH node, const char *nsUri)
	{
	int retVal = -1;

	if (node && nsUri) {
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	xmlNsPtr xmlNs = xmlNode->nsDef;
	xmlNsPtr prevNs = NULL;

	while (xmlNs != NULL) {
	if ((xmlStrEqual(xmlNs->href, BAD_CAST nsUri))) {
	break;
	}
	prevNs = xmlNs;
	xmlNs = xmlNs->next;
	}

	if (xmlNs != NULL) {
	retVal = 0;
	if (prevNs == NULL)
	xmlNode->nsDef = xmlNs->next;
	else
	prevNs->next = xmlNs->next;
	xmlFreeNs(xmlNs);
	} else
	retVal = 1;
	}
	return retVal;
	}



	WsXmlNsH xml_parser_ns_get(WsXmlNodeH node, int which)
	{
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	xmlNsPtr xmlNs = NULL;

	if (which >= 0) {
	int count = 0;
	xmlNs = xmlNode->nsDef;
	while (xmlNs != NULL) {
	if (which == count)
	break;
	count++;
	xmlNs = xmlNs->next;
	}
	} else {
	assert(which >= 0);
	}
	return (WsXmlNsH) xmlNs;
	}


	static
	int get_ns_count_at_node(xmlNodePtr xmlNode)
	{
	int count = 0;
	xmlNsPtr xmlNs = xmlNode->nsDef;

	while (xmlNs != NULL) {
	count++;
	xmlNs = xmlNs->next;
	}
	return count;
	}


	int xml_parser_get_count(WsXmlNodeH node, int what, int bWalkUpTree)
	{
	int count = 0;
	xmlNodePtr xmlNode;
	xmlAttrPtr xmlAttr;

	switch (what) {
	case XML_COUNT_NODE:
	xmlNode = ((xmlNodePtr) node)->children;
	while (xmlNode) {
	if (xmlNode->type == XML_ELEMENT_NODE)
	count++;
	xmlNode = xmlNode->next;
	}
	break;
	case XML_COUNT_ATTR:
	xmlAttr = ((xmlNodePtr) node)->properties;
	while (xmlAttr) {
	count++;
	xmlAttr = xmlAttr->next;
	}
	break;
	case XML_COUNT_NS:
	xmlNode = (xmlNodePtr) node;
	while (xmlNode != NULL) {
	count += get_ns_count_at_node(xmlNode);
	if (!bWalkUpTree)
	break;
	xmlNode = xmlNode->parent;
	}
	break;
	default:
	assert(what == XML_COUNT_NODE \|\| what == XML_COUNT_ATTR \|\|
	what == XML_COUNT_NS);
	break;
	}

	return count;
	}

	static xmlNodePtr
	make_new_xml_node(xmlNodePtr base,
	const char uri, const char name, const char *value, int xmlescape)
	{
	xmlNodePtr newNode = NULL;
	xmlNsPtr ns = NULL;
	if (uri == NULL \|\|
	(ns =
	(xmlNsPtr) xml_parser_ns_find((WsXmlNodeH) base, uri, NULL, 1,
	1)) != NULL) {
	if ((newNode = xmlNewNode(ns, BAD_CAST name)) != NULL) {
	if (value != NULL){
	if (xmlescape == 1)
	xmlNodeAddContent(newNode, BAD_CAST value);
	else
	xmlNodeSetContent(newNode, BAD_CAST value);
	}
	newNode->_private = u_zalloc(sizeof(iWsNode));
	}
	}
	return newNode;
	}






	WsXmlNodeH
	xml_parser_node_add(WsXmlNodeH base,
	int where,
	const char *nsUri,
	const char localName, const char value, int xmlescape)
	{
	xmlNodePtr xmlBase = (xmlNodePtr) base;
	xmlNodePtr newNode =
	make_new_xml_node((where != XML_ELEMENT_NEXT &&
	where != XML_ELEMENT_PREV)
	? xmlBase : xmlBase->parent, nsUri,
	localName, value, xmlescape);
	if (newNode) {
	switch (where) {
	case XML_ELEMENT_NEXT:
	xmlAddNextSibling((xmlNodePtr) base, newNode);
	break;
	case XML_ELEMENT_PREV:
	xmlAddPrevSibling((xmlNodePtr) base, newNode);
	break;
	case XML_LAST_CHILD:
	default:
	xmlAddChild((xmlNodePtr) base, newNode);
	break;
	}
	}
	return (WsXmlNodeH) newNode;

	}

	int xml_parser_node_remove(WsXmlNodeH node)
	{
	destroy_node_private_data(((xmlNodePtr) node)->_private);
	xmlUnlinkNode((xmlNodePtr) node);
	xmlFreeNode((xmlNodePtr) node);
	return 0;
	}


	WsXmlAttrH
	xml_parser_attr_add(WsXmlNodeH node,
	const char uri, const char name, const char *value)
	{
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	xmlNsPtr xmlNs =
	(xmlNsPtr) xml_parser_ns_find(node, uri, NULL, 1, 1);
	xmlAttrPtr xmlAttr =
	(xmlAttrPtr) ws_xml_find_node_attr(node, uri, name);

	if (xmlAttr != NULL)
	ws_xml_remove_node_attr((WsXmlAttrH) xmlAttr);

	if (xmlNs == NULL)
	xmlAttr =
	xmlNewProp(xmlNode, BAD_CAST name, BAD_CAST value);
	else
	xmlAttr =
	xmlNewNsProp(xmlNode, xmlNs, BAD_CAST name,
	BAD_CAST value);

	if (xmlAttr != NULL) {
	if (xmlNs == NULL)
	xmlAttr->_private =
	xmlGetProp(xmlNode, BAD_CAST name);
	else
	xmlAttr->_private =
	xmlGetNsProp(xmlNode, BAD_CAST name,
	xmlNs->href);
	}

	return (WsXmlAttrH) xmlAttr;
	}



	int xml_parser_attr_remove(WsXmlAttrH attr)
	{
	xmlAttrPtr xmlAttr = (xmlAttrPtr) attr;
	xmlNodePtr xmlNode = (xmlNodePtr) xmlAttr->parent;
	xmlAttrPtr xmlAttrPrev =
	(xmlNode->properties == xmlAttr) ? NULL : xmlNode->properties;

	while (xmlAttrPrev != NULL && xmlAttrPrev->next != xmlAttr) {
	xmlAttrPrev = xmlAttrPrev->next;
	}
	if (xmlAttrPrev != NULL)
	xmlAttrPrev->next = xmlAttr->next;
	else
	xmlNode->properties = xmlAttr->next;

	xmlNode->parent = NULL;
	xmlNode->next = NULL;

	destroy_attr_private_data((xmlAttrPtr) attr);
	xmlFreeProp((xmlAttrPtr) attr);

	return 0;
	}

	char *xml_parser_attr_query(WsXmlAttrH attr, int what)
	{
	char *ptr = NULL;
	xmlAttrPtr xmlAttr = (xmlAttrPtr) attr;
	switch (what) {
	case XML_LOCAL_NAME:
	ptr = (char *) xmlAttr->name;
	break;
	case XML_NS_URI:
	if (xmlAttr->ns != NULL)
	ptr = (char *) xmlAttr->ns->href;
	break;
	case XML_NS_PREFIX:
	if (xmlAttr->ns != NULL)
	ptr = (char *) xmlAttr->ns->prefix;
	break;
	case XML_TEXT_VALUE:
	if (xmlAttr->_private == NULL) {
	if (xmlAttr->ns == NULL)
	xmlAttr->_private =
	xmlGetProp(xmlAttr->parent,
	xmlAttr->name);
	else
	xmlAttr->_private =
	xmlGetNsProp(xmlAttr->parent,
	xmlAttr->name,
	xmlAttr->ns->href);
	}
	ptr = (char *) xmlAttr->_private;
	break;
	default:
	assert(what == XML_LOCAL_NAME);
	break;
	}
	return ptr;
	}



	WsXmlAttrH xml_parser_attr_get(WsXmlNodeH node, int which)
	{
	xmlNodePtr xmlNode = (xmlNodePtr) node;
	xmlAttrPtr xmlAttr = NULL;

	switch (which) {
	case XML_LAST_CHILD:
	default:
	if (which >= 0 \|\| which == XML_LAST_CHILD) {
	int count = 0;
	xmlAttr = xmlNode->properties;

	while (xmlAttr) {
	if (which == XML_LAST_CHILD &&
	xmlAttr->next == NULL)
	break;

	if (which == count)
	break;

	count++;

	xmlAttr = xmlAttr->next;
	}
	} else {
	assert(which >= 0 \|\| which == XML_LAST_CHILD);
	}
	break;
	}

	return (WsXmlAttrH) xmlAttr;
	}



	void xml_parser_element_dump(FILE * f, WsXmlDocH doc, WsXmlNodeH node)
	{

	xmlNodePtr n = (xmlNodePtr) node;
	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	xmlElemDump(f, d, n);
	}

	void xml_parser_doc_dump(FILE * f, WsXmlDocH doc)
	{

	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	xmlDocFormatDump(f, d, 1);
	return;
	}

	void xml_parser_doc_dump_memory(WsXmlDocH doc, char *buf, int ptrSize)
	{

	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	xmlDocDumpFormatMemory(d, (xmlChar **) buf, ptrSize, 1);
	return;
	}

	void xml_parser_doc_dump_memory_enc(WsXmlDocH doc, char *buf, int ptrSize, const char *encoding)
	{

	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	xmlDocDumpFormatMemoryEnc(d, (xmlChar **) buf, ptrSize, encoding?encoding:"UTF-8", 1);
	return;
	}

	static void
	register_namespaces(xmlXPathContextPtr ctxt, WsXmlDocH doc,
	WsXmlNodeH node)
	{
	xmlNsPtr nsList, cur;
	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;


	nsList = xmlGetNsList(d, (xmlNodePtr) node);
	if (nsList == NULL) {
	return;
	}
	for (cur = nsList; *cur != NULL; cur++) {
	if (xmlXPathRegisterNs(ctxt, (cur)->prefix, (cur)->href)
	!= 0) {
	return;
	}
	}
	xmlFree(nsList);
	}


	int xml_parser_check_xpath(WsXmlDocH doc, const char *expression)
	{
	xmlXPathObject *obj;
	xmlNodeSetPtr nodeset;
	xmlXPathContextPtr ctxt;
	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	int retval = 0;

	ctxt = xmlXPathNewContext(d);
	if (ctxt == NULL) {
	error("failed while creating xpath context");
	return 0;
	}
	register_namespaces(ctxt, doc, xml_parser_get_root(doc));
	obj = xmlXPathEvalExpression(BAD_CAST expression, ctxt);
	if (obj) {
	nodeset = obj->nodesetval;
	if (nodeset && nodeset->nodeNr > 0) {
	int size = nodeset->nodeNr;
	int i;
	xmlNodePtr cur;
	for(i = 0; i < size; ++i) {
	if(nodeset->nodeTab[i]->type == XML_ELEMENT_NODE) {
	cur = nodeset->nodeTab[i];
	if(cur->ns) {
	fprintf(stdout, "= element node \"%s:%s\"\n",
	cur->ns->href, cur->name);
	} else {
	fprintf(stdout, "= element node \"%s\"\n",
	cur->name);
	}
	}
	}

	retval = 1;
	}
	xmlXPathFreeObject(obj);
	}
	xmlXPathFreeContext(ctxt);

	return retval;
	}



	char xml_parser_get_xpath_value(WsXmlDocH doc, const char expression)
	{
	//int i;
	char *result = NULL;
	xmlXPathObject *obj;
	xmlNodeSetPtr nodeset;
	xmlXPathContextPtr ctxt;
	xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
	WsXmlNodeH body;

	ctxt = xmlXPathNewContext(d);
	if (ctxt == NULL) {
	error("failed while creating xpath context");
	return NULL;
	}
	body = ws_xml_get_soap_body(doc);
	register_namespaces(ctxt, doc, xml_parser_get_root(doc));
	if (ws_xml_get_child(body, 0, NULL, NULL)) {
	register_namespaces(ctxt, doc,
	ws_xml_get_child(body, 0, NULL, NULL));
	}

	obj = xmlXPathEvalExpression(BAD_CAST expression, ctxt);
	if (obj) {
	nodeset = obj->nodesetval;
	if (nodeset && nodeset->nodeNr > 0)
	result = (char *) xmlNodeListGetString(d,
	nodeset->
	nodeTab[0]->
	xmlChildrenNode,
	1);

	xmlXPathFreeObject(obj);
	}
	xmlXPathFreeContext(ctxt);

	return result;
	}



	void xml_parser_unlink_node(WsXmlNodeH node)
	{
	xmlUnlinkNode((xmlNodePtr) node);
	xmlFreeNode((xmlNodePtr) node);
	return;
	}

	void xml_parser_node_set_lang(WsXmlNodeH node, const char *lang)
	{
	xmlNodeSetLang((xmlNodePtr) node, BAD_CAST lang);
	}


	void xml_parser_set_ns(WsXmlNodeH r, WsXmlNsH ns, const char *prefix)
	{
	xmlSetNs((xmlNodePtr) r, (xmlNsPtr) ns);
	}

	void xml_parser_copy_node(WsXmlNodeH src, WsXmlNodeH dst)
	{
	if (src && dst) {
	xmlNodePtr x = xmlDocCopyNode((xmlNodePtr) src,
	((xmlDocPtr) src)->doc, 1);
	if (x)
	xmlAddChild((xmlNodePtr) dst, x);
	}
	}