/** 

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

 *

 * Creating signature and encryption templates.

 *

 * 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 <libxml2_tree.h>

#include <libxml2_globals.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_transforms.h"

#include "xmlsec_strings.h"

#include "xmlsec_base64.h"

#include "xmlsec_templates.h"

#include "xmlsec_errors.h"

//added for symbian port

#include <libxml2_parser.h>

static int useNewLine = 1;

static unsigned char* dsPref = NULL;

static xmlNodePtr 	xmlSecTmplAddReference		(xmlNodePtr parentNode, 

							 xmlSecTransformId digestMethodId,

							 const xmlChar *id, 

							 const xmlChar *uri, 

							 const xmlChar *type);

static int	 	xmlSecTmplPrepareEncData	(xmlNodePtr parentNode, 

							 xmlSecTransformId encMethodId);

static int 		xmlSecTmplNodeWriteNsList	(xmlNodePtr parentNode, 

							 const xmlChar** namespaces);

EXPORT_C

void xmlSetNewLineFlag(int aNewLine)

    {

    useNewLine = aNewLine;

    }

int xmlGetNewLineFlag()

    {

    return useNewLine;

    }

EXPORT_C

void xmlSetPrefix(unsigned char* aPref)

    {

    dsPref = aPref;

    }

unsigned char* xmlGetPrefix()

    {

    return dsPref;

    }

/**************************************************************************

 *

 * <dsig:Signature/> node

 *

 **************************************************************************/

/**

 * xmlSecTmplSignatureCreate:

 * @doc: 		the pointer to signature document or NULL; in the 

 *			second case, application must later call @xmlSetTreeDoc

 *			to ensure that all the children nodes have correct 

 *			pointer to XML document.

 * @c14nMethodId: 	the signature canonicalization method.

 * @signMethodId: 	the signature  method.

 * @id: 		the node id (may be NULL).

 *

 * Creates new <dsig:Signature/> node with the mandatory <dsig:SignedInfo/>, 

 * <dsig:CanonicalizationMethod/>, <dsig:SignatureMethod/> and 

 * <dsig:SignatureValue/> children and sub-children. 

 * The application is responsible for inserting the returned node

 * in the XML document. 

 *

 * Returns the pointer to newly created <dsig:Signature/> node or NULL if an 

 * error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecTmplSignatureCreate(xmlDocPtr doc, xmlSecTransformId c14nMethodId,

		      xmlSecTransformId signMethodId, const xmlChar *id) {

    xmlNodePtr signNode;

    xmlNodePtr signedInfoNode;

    xmlNodePtr cur;

    xmlNsPtr ns;

    xmlSecAssert2(c14nMethodId != NULL, NULL);

    xmlSecAssert2(c14nMethodId->href != NULL, NULL);

    xmlSecAssert2(signMethodId != NULL, NULL);

    xmlSecAssert2(signMethodId->href != NULL, NULL);

    /* create Signature node itself */

    signNode = xmlNewDocNode(doc, NULL, xmlSecNodeSignature, NULL);

    if(signNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlNewDocNode",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignature));

	return(NULL);	            

    }

    ns = xmlNewNs(signNode, xmlSecDSigNs, dsPref);

    if(ns == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlNewNs",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    "ns=%s",

		    xmlSecErrorsSafeString(xmlSecDSigNs));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    xmlSetNs(signNode, ns);

    if(id != NULL) {

	    xmlAttrPtr ptr = xmlSetProp(signNode, BAD_CAST "Id", id);

	    if ( !ptr && OOM_FLAG ) 

	        {

	        xmlFreeNode(signNode);

	        return(NULL);

	        }

    }

    /* add SignedInfo node */    

    signedInfoNode = xmlSecAddChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

    if(signedInfoNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    /* add SignatureValue node */    

    cur = xmlSecAddChild(signNode, xmlSecNodeSignatureValue, xmlSecDSigNs);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignatureValue));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    /* add CanonicaizationMethod node to SignedInfo */

    cur = xmlSecAddChild(signedInfoNode, xmlSecNodeCanonicalizationMethod, xmlSecDSigNs);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeCanonicalizationMethod));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    if(xmlSetNsProp(cur, ns, xmlSecAttrAlgorithm, c14nMethodId->href) == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSetProp",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    "name=%s,value=%s",

		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

		    xmlSecErrorsSafeString(c14nMethodId->href));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    /* add SignatureMethod node to SignedInfo */

    cur = xmlSecAddChild(signedInfoNode, xmlSecNodeSignatureMethod, xmlSecDSigNs);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignatureMethod));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    if(xmlSetNsProp(cur, ns, xmlSecAttrAlgorithm, signMethodId->href) == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSetProp",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    "name=%s,value=%s",

		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

		    xmlSecErrorsSafeString(signMethodId->href));

	xmlFreeNode(signNode);

	return(NULL);	        	

    }

    return(signNode);

}

/**

 * xmlSecTmplSignatureEnsureKeyInfo:

 * @signNode: 		the  pointer to <dsig:Signature/> node.

 * @id: 		the node id (may be NULL).

 *

 * Adds (if necessary) <dsig:KeyInfo/> node to the <dsig:Signature/> 

 * node @signNode. 

 *

 * Returns the pointer to newly created <dsig:KeyInfo/> node or NULL if an 

 * error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecTmplSignatureEnsureKeyInfo(xmlNodePtr signNode, const xmlChar *id) {

    xmlNodePtr res;

    int created = 0;

    xmlSecAssert2(signNode != NULL, NULL);

    res = xmlSecFindChild(signNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

    if(res == NULL) {

	xmlNodePtr signValueNode;

        signValueNode = xmlSecFindChild(signNode, xmlSecNodeSignatureValue, xmlSecDSigNs);

	if(signValueNode == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			xmlSecErrorsSafeString(xmlSecNodeSignatureValue),

		        XMLSEC_ERRORS_R_NODE_NOT_FOUND,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(NULL);	

	}

	res = xmlSecAddNextSibling(signValueNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

	if(res == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			"xmlSecAddNextSibling",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"node=%s",

			xmlSecErrorsSafeString(xmlSecNodeKeyInfo));

	    return(NULL);	        	

	}

	created = 1;

    }

    if(id != NULL) {

	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

        if (!ptr && OOM_FLAG) 

            {

            if (created) 

                {

                xmlUnlinkNode(res);

    	        xmlFreeNode(res);

                }

            return(NULL);

            }

    }

    return(res);        

}         

/**

 * xmlSecTmplSignatureAddReference:

 * @signNode: 		the pointer to <dsig:Signature/> node.

 * @digestMethodId:	the reference digest method.

 * @id: 		the node id (may be NULL).

 * @uri: 		the reference node uri (may be NULL).

 * @type: 		the reference node type (may be NULL).

 *

 * Adds <dsig:Reference/> node with given URI (@uri), Id (@id) and 

 * Type (@type) attributes and the required children <dsig:DigestMethod/> and

 * <dsig:DigestValue/> to the <dsig:SignedInfo/> child of @signNode. 

 *

 * Returns the pointer to newly created <dsig:Reference/> node or NULL 

 * if an error occurs.

 */

EXPORT_C

xmlNodePtr	

xmlSecTmplSignatureAddReference(xmlNodePtr signNode, xmlSecTransformId digestMethodId,

		    const xmlChar *id, const xmlChar *uri, const xmlChar *type) {

    xmlNodePtr signedInfoNode;

    xmlSecAssert2(signNode != NULL, NULL);

    xmlSecAssert2(digestMethodId != NULL, NULL);

    xmlSecAssert2(digestMethodId->href != NULL, NULL);

    signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

    if(signedInfoNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);	

    }

    return(xmlSecTmplAddReference(signedInfoNode, digestMethodId, id, uri, type));

}

static xmlNodePtr 

xmlSecTmplAddReference(xmlNodePtr parentNode, xmlSecTransformId digestMethodId,

		    const xmlChar *id, const xmlChar *uri, const xmlChar *type) {    

    xmlNodePtr res;

    xmlNodePtr cur;

    int error = 0;

    xmlSecAssert2(parentNode != NULL, NULL);

    xmlSecAssert2(digestMethodId != NULL, NULL);

    xmlSecAssert2(digestMethodId->href != NULL, NULL);

    /* add Reference node */

    res = xmlSecAddChild(parentNode, xmlSecNodeReference, xmlSecDSigNs);

    if(res == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeReference));

	return(NULL);

    }

    /* set Reference node attributes */

    if(id != NULL) {

	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrId, id);

    error = error || !ptr;

    }

    if(type != NULL) {

	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrType, type);

    error = error || !ptr;

    }

    if(uri != NULL) {

	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrURI, uri);

    error = error || !ptr;

    }

    if (error && OOM_FLAG) 

        {

 	    xmlUnlinkNode(res);

	    xmlFreeNode(res); 

	    return(NULL);      

        }

    /* add DigestMethod node and set algorithm */    

    cur = xmlSecAddChild(res, xmlSecNodeDigestMethod, xmlSecDSigNs);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeDigestMethod));

	xmlUnlinkNode(res);

	xmlFreeNode(res);

	return(NULL);	        	

    }

    if(xmlSetNsProp(cur, cur->ns, xmlSecAttrAlgorithm, digestMethodId->href) == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSetProp",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    "name=%s,value=%s",

		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

		    xmlSecErrorsSafeString(digestMethodId->href));

	xmlUnlinkNode(res);

	xmlFreeNode(res);

	return(NULL);	        	

    }

    /* add DigestValue node */    

    cur = xmlSecAddChild(res, xmlSecNodeDigestValue, xmlSecDSigNs);

    if(cur == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeDigestValue));

	xmlUnlinkNode(res);

	xmlFreeNode(res);

	return(NULL);	        	

    }

    return(res);    

}

/**

 * xmlSecTmplSignatureAddObject:

 * @signNode: 		the pointer to <dsig:Signature/> node.

 * @id: 		the node id (may be NULL).

 * @mimeType: 		the object mime type (may be NULL).

 * @encoding: 		the object encoding (may be NULL).

 *

 * Adds <dsig:Object/> node to the <dsig:Signature/> node @signNode. 

 *

 * Returns the pointer to newly created <dsig:Object/> node or NULL 

 * if an error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecTmplSignatureAddObject(xmlNodePtr signNode, const xmlChar *id, 

			 const xmlChar *mimeType, const xmlChar *encoding) {

    xmlNodePtr res;

    int error = 0;

    xmlSecAssert2(signNode != NULL, NULL);

    res = xmlSecAddChild(signNode, xmlSecNodeObject, xmlSecDSigNs);

    if(res == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecAddChild",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "node=%s",

		    xmlSecErrorsSafeString(xmlSecNodeObject));

	return(NULL);	        	

    }

    if(id != NULL) {

	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

    error = error || !ptr;

    }

    if(mimeType != NULL) {

	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrMimeType, mimeType);

    error = error || !ptr;

    }

    if(encoding != NULL) {

	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrEncoding, encoding);

    error = error || !ptr;

    }

    if (error && OOM_FLAG) 

        {

        xmlUnlinkNode(res);

	    xmlFreeNode(res);

	    return(NULL);

        }

    return(res);        

}

/** 

 * xmlSecTmplSignatureGetSignMethodNode:

 * @signNode:		the pointer to <dsig:Signature /> node.

 *

 * Gets pointer to <dsig:SignatureMethod/> child of <dsig:KeyInfo/> node.

 *

 * Returns pointer to <dsig:SignatureMethod /> node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr 

xmlSecTmplSignatureGetSignMethodNode(xmlNodePtr signNode) {

    xmlNodePtr signedInfoNode;

    xmlSecAssert2(signNode != NULL, NULL);

    signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

    if(signedInfoNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);	

    }

    return(xmlSecFindChild(signedInfoNode, xmlSecNodeSignatureMethod, xmlSecDSigNs));

}

/** 

 * xmlSecTmplSignatureGetC14NMethodNode:

 * @signNode:		the pointer to <dsig:Signature /> node.

 *

 * Gets pointer to <dsig:CanonicalizationMethod/> child of <dsig:KeyInfo/> node.

 *

 * Returns pointer to <dsig:CanonicalizationMethod /> node or NULL if an error occurs.

 */

EXPORT_C

xmlNodePtr 

xmlSecTmplSignatureGetC14NMethodNode(xmlNodePtr signNode) {

    xmlNodePtr signedInfoNode;

    xmlSecAssert2(signNode != NULL, NULL);

    signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

    if(signedInfoNode == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);	

    }

    return(xmlSecFindChild(signedInfoNode, xmlSecNodeCanonicalizationMethod, xmlSecDSigNs));

}

/**

 * xmlSecTmplReferenceAddTransform:

 * @referenceNode: 		the pointer to <dsig:Reference/> node.

 * @transformId: 		the transform method id.

 *

 * Adds <dsig:Transform/> node to the <dsig:Reference/> node @referenceNode.

 * 

 * Returns the pointer to newly created <dsig:Transform/> node or NULL if an 

 * error occurs.

 */

EXPORT_C

xmlNodePtr

xmlSecTmplReferenceAddTransform(xmlNodePtr referenceNode, xmlSecTransformId transformId) {

    xmlNodePtr transformsNode;

    xmlNodePtr res;

    xmlSecAssert2(referenceNode != NULL, NULL);

    xmlSecAssert2(transformId != NULL, NULL);

    xmlSecAssert2(transformId->href != NULL, NULL);

    /* do we need to create Transforms node first */