/** 

 * XML Security Library (http://www.aleksey.com/xmlsec).

 *

 * Common XML Doc utility functions

 *

 * This is free software; see Copyright file in the source

 * distribution for preciese wording.

 * 

 * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#include "xmlsec_globals.h"

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <libxml2_tree.h>

#include <libxml2_valid.h>

#include <libxml2_xpath.h>

#include <libxml2_xpathinternals.h>

#include <libxml2_globals.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_parser.h"

#include "xmlsec_private.h"

#include "xmlsec_base64.h"

#include "xmlsec_errors.h"

#include "xmlsec_templates.h"

/**

 * xmlSecFindChild:

 * @parent: 		the pointer to XML node.

 * @name: 		the name.

 * @ns: 		the namespace href (may be NULL).

 *

 * Searches a direct child of the @parent node having given name and 

 * namespace href.

 * 

 * Returns the pointer to the found node or NULL if an error occurs or 

 * node is not found.

 */

EXPORT_C

xmlNodePtr

xmlSecFindChild(const xmlNodePtr parent, const xmlChar *name, const xmlChar *ns) {

    xmlNodePtr cur;

    xmlSecAssert2(parent != NULL, NULL);

    xmlSecAssert2(name != NULL, NULL);

    cur = parent->children;

    while(cur != NULL) {

        if(cur->type == XML_ELEMENT_NODE) {

	    if(xmlSecCheckNodeName(cur, name, ns)) {

		return(cur);

	    }

	}

	cur = cur->next;

    }

    return(NULL);

}

/**

 * xmlSecFindParent:

 * @cur: 		the pointer to an XML node.

 * @name: 		the name.

 * @ns: 		the namespace href (may be NULL).

 *

 * Searches the ancestors axis of the @cur node for a node having given name 

 * and namespace href.

 * 

 * Returns the pointer to the found node or NULL if an error occurs or 

 * node is not found.

 */

EXPORT_C

xmlNodePtr

xmlSecFindParent(const xmlNodePtr cur, const xmlChar *name, const xmlChar *ns) {

    xmlSecAssert2(cur != NULL, NULL);

    xmlSecAssert2(name != NULL, NULL);        

    if(xmlSecCheckNodeName(cur, name, ns)) {

	return(cur);

    } else if(cur->parent != NULL) {

	return(xmlSecFindParent(cur->parent, name, ns));

    }

    return(NULL);

}

/**

 * xmlSecFindNode:

 * @parent: 		the pointer to XML node.

 * @name: 		the name.

 * @ns: 		the namespace href (may be NULL).

 *

 * Searches all children of the @parent node having given name and 

 * namespace href.

 * 

 * Returns the pointer to the found node or NULL if an error occurs or 

 * node is not found.

 */

EXPORT_C

xmlNodePtr		

xmlSecFindNode(const xmlNodePtr parent, const xmlChar *name, const xmlChar *ns) {

    xmlNodePtr cur;

    xmlNodePtr ret;

    xmlSecAssert2(name != NULL, NULL); 

    cur = parent;

    while(cur != NULL) {

        if((cur->type == XML_ELEMENT_NODE) && xmlSecCheckNodeName(cur, name, ns)) {

	    return(cur);

	}

	if(cur->children != NULL) {

	    ret = xmlSecFindNode(cur->children, name, ns);

	    if(ret != NULL) {

	        return(ret);	    

	    }

	}

	cur = cur->next;

    }

    return(NULL);

}

/**

 * xmlSecGetNodeNsHref:

 * @cur:		the pointer to node.

 *

 * Get's node's namespace href.

 *

 * Returns node's namespace href.

 */

EXPORT_C

const xmlChar* 

xmlSecGetNodeNsHref(const xmlNodePtr cur) {

    xmlNsPtr ns;

    xmlSecAssert2(cur != NULL, NULL);

    /* do we have a namespace in the node? */

    if(cur->ns != NULL) {

	return(cur->ns->href);

    }

    /* search for default namespace */

    ns = xmlSearchNs(cur->doc, cur, NULL);

    if(ns != NULL) {

	return(ns->href);

    }

    return(NULL);

}

/** 

 * xmlSecCheckNodeName:

 * @cur: 		the pointer to an XML node.

 * @name: 		the name,

 * @ns: 		the namespace href.

 *

 * Checks that the node has a given name and a given namespace href.

 *

 * Returns 1 if the node matches or 0 otherwise.

 */

EXPORT_C

int

xmlSecCheckNodeName(const xmlNodePtr cur, const xmlChar *name, const xmlChar *ns) {

    xmlSecAssert2(cur != NULL, 0);

    return(xmlStrEqual(cur->name, name) && 

	   xmlStrEqual(xmlSecGetNodeNsHref(cur), ns));

}

/**

 * xmlSecAddChild:

 * @parent: 		the pointer to an XML node.

 * @name: 		the new node name.

 * @ns: 		the new node namespace.

 *

 * Adds a child to the node @parent with given @name and namespace @ns.

 *

 * Returns pointer to the new node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr		

xmlSecAddChild(xmlNodePtr parent, const xmlChar *name, const xmlChar *ns) {

    xmlNodePtr cur;

    xmlNodePtr text;

    xmlSecAssert2(parent != NULL, NULL);

    xmlSecAssert2(name != NULL, NULL);        

    if(xmlGetNewLineFlag() && parent->children == NULL) {

	text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlNewText",

			XMLSEC_ERRORS_R_XML_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(NULL);

	}

	xmlAddChild(parent, text);

    }

    cur = xmlNewChild(parent, NULL, name, NULL);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlNewChild",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);

    }

    /* namespaces support */

    if(ns != NULL) {

	xmlNsPtr nsPtr;

	nsPtr = xmlSearchNsByHref(cur->doc, cur, ns);

	if((nsPtr == NULL) || !xmlStrEqual(nsPtr->href, ns)) {

	    nsPtr = xmlNewNs(cur, ns, NULL);

	}

	xmlSetNs(cur, nsPtr);

    }

    if(xmlGetNewLineFlag())

        {

        text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

    	xmlSecError(XMLSEC_ERRORS_HERE,

    		    NULL,

    		    "xmlNewText",

    		    XMLSEC_ERRORS_R_XML_FAILED,

    		    XMLSEC_ERRORS_NO_MESSAGE);

    	return(NULL);

        }

        xmlAddChild(parent, text);

        }

    return(cur);

}

/**

 * xmlSecAddChildNode:

 * @parent: 		the pointer to an XML node.

 * @child: 		the new node.

 *

 * Adds @child node to the @parent node.

 *

 * Returns pointer to the new node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr		

xmlSecAddChildNode(xmlNodePtr parent, xmlNodePtr child) {

    xmlNodePtr text;

    xmlSecAssert2(parent != NULL, NULL);

    xmlSecAssert2(child != NULL, NULL);        

    if(xmlGetNewLineFlag() && parent->children == NULL) {

	text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlNewText",

			XMLSEC_ERRORS_R_XML_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(NULL);

	}

	xmlAddChild(parent, text);

    }

    xmlAddChild(parent, child);

    if(xmlGetNewLineFlag())

        {

        text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

    	xmlSecError(XMLSEC_ERRORS_HERE,

    		    NULL,

    		    "xmlNewText",

    		    XMLSEC_ERRORS_R_XML_FAILED,

    		    XMLSEC_ERRORS_NO_MESSAGE);

    	return(NULL);

        }

        xmlAddChild(parent, text);

        }

    return(child);

}

/**

 * xmlSecAddNextSibling

 * @node: 		the pointer to an XML node.

 * @name: 		the new node name.

 * @ns: 		the new node namespace.

 *

 * Adds next sibling to the node @node with given @name and namespace @ns.

 *

 * Returns pointer to the new node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecAddNextSibling(xmlNodePtr node, const xmlChar *name, const xmlChar *ns) {

    xmlNodePtr cur;

    xmlNodePtr text;

    xmlSecAssert2(node != NULL, NULL);

    xmlSecAssert2(name != NULL, NULL);    

    cur = xmlNewNode(NULL, name);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlNewNode",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);

    }

    xmlAddNextSibling(node, cur);

    /* namespaces support */

    if(ns != NULL) {

	xmlNsPtr nsPtr;

	nsPtr = xmlSearchNsByHref(cur->doc, cur, ns);

	if((nsPtr == NULL) || !xmlStrEqual(nsPtr->href, ns)) {

	    nsPtr = xmlNewNs(cur, ns, NULL);

	}

	xmlSetNs(cur, nsPtr);

    }

    if(xmlGetNewLineFlag())

        {

        text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

    	xmlSecError(XMLSEC_ERRORS_HERE,

    		    NULL,

    		    "xmlNewText",

    		    XMLSEC_ERRORS_R_XML_FAILED,

    		    XMLSEC_ERRORS_NO_MESSAGE);

    	return(NULL);

        }

        xmlAddNextSibling(node, text);

        } 

    return(cur);

}

/**

 * xmlSecAddPrevSibling

 * @node: 		the pointer to an XML node.

 * @name: 		the new node name.

 * @ns: 		the new node namespace.

 *

 * Adds prev sibling to the node @node with given @name and namespace @ns.

 *

 * Returns pointer to the new node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecAddPrevSibling(xmlNodePtr node, const xmlChar *name, const xmlChar *ns) {

    xmlNodePtr cur;

    xmlNodePtr text;

    xmlSecAssert2(node != NULL, NULL);

    xmlSecAssert2(name != NULL, NULL);    

    cur = xmlNewNode(NULL, name);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlNewNode",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);

    }

    xmlAddPrevSibling(node, cur);

    /* namespaces support */

    if(ns != NULL) {

	xmlNsPtr nsPtr;

	nsPtr = xmlSearchNsByHref(cur->doc, cur, ns);

	if((nsPtr == NULL) || !xmlStrEqual(nsPtr->href, ns)) {

	    nsPtr = xmlNewNs(cur, ns, NULL);

	    if (nsPtr == NULL)

	        return(NULL);

	}

	xmlSetNs(cur, nsPtr);

    }

    if(xmlGetNewLineFlag())

        {

        text = xmlNewText(xmlSecStringCR); 

        if(text == NULL) {	

    	xmlSecError(XMLSEC_ERRORS_HERE,

    		    NULL,

    		    "xmlNewText",

    		    XMLSEC_ERRORS_R_XML_FAILED,

    		    XMLSEC_ERRORS_NO_MESSAGE);

    	return(NULL);

        }

        xmlAddPrevSibling(node, text);

        }

    return(cur);

}

/**

 * xmlSecGetNextElementNode:

 * @cur: 		the pointer to an XML node.

 *

 * Seraches for the next element node.

 *

 * Returns the pointer to next element node or NULL if it is not found.

 */

EXPORT_C

xmlNodePtr

xmlSecGetNextElementNode(xmlNodePtr cur) {

    while((cur != NULL) && (cur->type != XML_ELEMENT_NODE)) {

	cur = cur->next;

    }

    return(cur);

}

/**

 * xmlSecReplaceNode:

 * @node: 		the current node.

 * @newNode: 		the new node.

 * 

 * Swaps the @node and @newNode in the XML tree.

 *

 * Returns 0 on success or a negative value if an error occurs.

 */

EXPORT_C

int

xmlSecReplaceNode(xmlNodePtr node, xmlNodePtr newNode) {

    xmlNodePtr oldNode;

    int restoreRoot = 0;

    xmlSecAssert2(node != NULL, -1);

    xmlSecAssert2(newNode != NULL, -1);    

    /* fix documents children if necessary first */

    if((node->doc != NULL) && (node->doc->children == node)) {

	node->doc->children = node->next;

	restoreRoot = 1;

    }

    if((newNode->doc != NULL) && (newNode->doc->children == newNode)) {

	newNode->doc->children = newNode->next;

    }

    oldNode = xmlReplaceNode(node, newNode);

    if(oldNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

                    "xmlReplaceNode",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    if(restoreRoot != 0) {

	xmlDocSetRootElement(oldNode->doc, newNode);

    }

    xmlFreeNode(oldNode);

    return(0);

}

/**

 * xmlSecReplaceContent

 * @node: 		the current node.

 * @newNode: 		the new node.

 * 

 * Swaps the content of @node and @newNode.

 *

 * Returns 0 on success or a negative value if an error occurs.

 */

EXPORT_C

int

xmlSecReplaceContent(xmlNodePtr node, xmlNodePtr newNode) {

    xmlSecAssert2(node != NULL, -1);

    xmlSecAssert2(newNode != NULL, -1);  

    xmlUnlinkNode(newNode);

    xmlSetTreeDoc(newNode, node->doc);

    xmlNodeSetContent(node, NULL);

    xmlAddChild(node, newNode);

    xmlSetTreeDoc(newNode, node->doc);

    return(0);

}

/**

 * xmlSecReplaceNodeBuffer:

 * @node: 		the current node.

 * @buffer: 		the XML data.

 * @size: 		the XML data size.

 * 

 * Swaps the @node and the parsed XML data from the @buffer in the XML tree.

 *

 * Returns 0 on success or a negative value if an error occurs.

 */

EXPORT_C

int

xmlSecReplaceNodeBuffer(xmlNodePtr node, 

			const xmlSecByte *buffer, xmlSecSize size) {

    xmlNodePtr results = NULL;

    xmlNodePtr next = NULL;

    xmlNodePtr tmp = NULL; // MK added

    xmlSecAssert2(node != NULL, -1);

    xmlSecAssert2(node->parent != NULL, -1);

    /* parse buffer in the context of node's parent */

    if(xmlParseInNodeContext(node->parent, (const char*)buffer, size, XML_PARSE_NODICT, &results) != XML_ERR_OK) {

        xmlSecError(XMLSEC_ERRORS_HERE,

                    NULL,

                    "xmlParseInNodeContext",

                    XMLSEC_ERRORS_R_XML_FAILED,

                    "Failed to parse content");

        return(-1);         

    }

    if(results == NULL && node->parent->type == XML_DOCUMENT_NODE)