/** 

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

 *

 * The Transforms Element (http://www.w3.org/TR/xmldsig-core/#sec-Transforms)

 * 

 * The optional Transforms element contains an ordered list of Transform 

 * elements; these describe how the signer obtained the data object that 

 * was digested.

 *

 * Schema Definition:

 * 

 *  <element name="Transforms" type="ds:TransformsType"/>

 *  <complexType name="TransformsType">

 *    <sequence>

 *      <element ref="ds:Transform" maxOccurs="unbounded"/> 

 *    </sequence>

 *   </complexType>

 *

 *  <element name="Transform" type="ds:TransformType"/>

 *  <complexType name="TransformType" mixed="true">

 *    <choice minOccurs="0" maxOccurs="unbounded"> 

 *      <any namespace="##other" processContents="lax"/>

 *      <!-- (1,1) elements from (0,unbounded) namespaces -->

 *      <element name="XPath" type="string"/> 

 *    </choice>

 *    <attribute name="Algorithm" type="anyURI" use="required"/> 

 *  </complexType>

 *    

 * DTD:

 *    

 *  <!ELEMENT Transforms (Transform+)>

 *  <!ELEMENT Transform (#PCDATA|XPath %Transform.ANY;)* >

 *  <!ATTLIST Transform Algorithm    CDATA    #REQUIRED >

 *  <!ELEMENT XPath (#PCDATA) >

 * 

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

#include <string.h>

#include <libxml2_tree.h>

#include <libxml2_xpath.h>

#include <libxml2_xpointer.h>

#include <libxml2_globals.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_buffer.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_keysdata.h"

#include "xmlsec_keys.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_transforms.h"

#include "xmlsec_base64.h"

#include "xmlsec_io.h"

#include "xmlsec_membuf.h"

#include "xmlsec_parser.h"

#include "xmlsec_errors.h"

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

 *

 * Global xmlSecTransformIds list functions

 *

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

static xmlSecPtrList xmlSecAllTransformIds;

/** 

 * xmlSecTransformIdsGet:

 *

 * Gets global registered transform klasses list.

 * 

 * Returns the pointer to list of all registered transform klasses.

 */

EXPORT_C

xmlSecPtrListPtr

xmlSecTransformIdsGet(void) {

    return(&xmlSecAllTransformIds);

}

/** 

 * xmlSecTransformIdsInit:

 *

 * Initializes the transform klasses. This function is called from the 

 * #xmlSecInit function and the application should not call it directly.

 *

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

 */

EXPORT_C

int 

xmlSecTransformIdsInit(void) {

    int ret;       

    ret = xmlSecPtrListInitialize(xmlSecTransformIdsGet(), xmlSecTransformIdListId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListPtrInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecTransformIdListId");

        return(-1);

    }

    ret = xmlSecTransformIdsRegisterDefault();

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegisterDefault",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        return(-1);

    }

    return(0);

}

/**

 * xmlSecTransformIdsShutdown:

 * 

 * Shuts down the keys data klasses. This function is called from the 

 * #xmlSecShutdown function and the application should not call it directly.

 */

EXPORT_C

void

xmlSecTransformIdsShutdown(void) {

    xmlSecPtrListFinalize(xmlSecTransformIdsGet());

}

/** 

 * xmlSecTransformIdsRegister:

 * @id:			the transform klass.

 *

 * Registers @id in the global list of transform klasses.

 *

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

 */

EXPORT_C

int 

xmlSecTransformIdsRegister(xmlSecTransformId id) {

    int ret;

    xmlSecAssert2(id != xmlSecTransformIdUnknown, -1);

    ret = xmlSecPtrListAdd(xmlSecTransformIdsGet(), (xmlSecPtr)id);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListAdd",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "transform=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)));

        return(-1);

    }

    return(0);    

}

/**

 * xmlSecTransformIdsRegisterDefault:

 *

 * Registers default (implemented by XML Security Library)

 * transform klasses: XPath transform, Base64 transform, ...

 *

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

 */

EXPORT_C

int 

xmlSecTransformIdsRegisterDefault(void) {

    if(xmlSecTransformIdsRegister(xmlSecTransformBase64Id) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformBase64Id)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformEnvelopedId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformEnvelopedId)));

	return(-1);

    }

    /* c14n methods */

    if(xmlSecTransformIdsRegister(xmlSecTransformInclC14NId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformInclC14NId)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformInclC14NWithCommentsId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformInclC14NWithCommentsId)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformExclC14NId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformExclC14NId)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformExclC14NWithCommentsId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformExclC14NWithCommentsId)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformXPathId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXPathId)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformXPath2Id) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXPath2Id)));

	return(-1);

    }

    if(xmlSecTransformIdsRegister(xmlSecTransformXPointerId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXPointerId)));

	return(-1);

    }

#ifndef XMLSEC_NO_XSLT

    if(xmlSecTransformIdsRegister(xmlSecTransformXsltId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformIdsRegister",	    

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s",

		    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXsltId)));

	return(-1);

    }

#endif /* XMLSEC_NO_XSLT */    

    return(0);

}

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

 *

 * utils

 *

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

/**

 * xmlSecTransformUriTypeCheck:

 * @type:		the expected URI type.

 * @uri:		the uri for checking.

 *

 * Checks if @uri matches expected type @type.

 *

 * Returns 1 if @uri matches @type, 0 if not or a negative value

 * if an error occurs.

 */

EXPORT_C

int 

xmlSecTransformUriTypeCheck(xmlSecTransformUriType type, const xmlChar* uri) {

    xmlSecTransformUriType uriType = 0;

    if((uri == NULL) || (xmlStrlen(uri) == 0)) {

	uriType = xmlSecTransformUriTypeEmpty;

    } else if(uri[0] == '#') {

	uriType = xmlSecTransformUriTypeSameDocument;

    } else if(xmlStrncmp(uri, BAD_CAST "file://", 7) == 0) {

	uriType = xmlSecTransformUriTypeLocal;

    } else {

	uriType = xmlSecTransformUriTypeRemote;

    }    

    return(((uriType & type) != 0) ? 1 : 0);

}

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

 *

 * xmlSecTransformCtx

 *

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

/**

 * xmlSecTransformCtxCreate:

 *

 * Creates transforms chain processing context.

 * The caller is responsible for destroying returend object by calling 

 * #xmlSecTransformCtxDestroy function.

 *

 * Returns pointer to newly allocated context object or NULL if an error

 * occurs.

 */

EXPORT_C

xmlSecTransformCtxPtr 

xmlSecTransformCtxCreate(void) {

    xmlSecTransformCtxPtr ctx;

    int ret;

    /* Allocate a new xmlSecTransform and fill the fields. */

    ctx = (xmlSecTransformCtxPtr)xmlMalloc(sizeof(xmlSecTransformCtx));

    if(ctx == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "size=%d", sizeof(xmlSecTransformCtx)); 

	return(NULL);

    }

    ret = xmlSecTransformCtxInitialize(ctx);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecTransformCtxDestroy(ctx);

	return(NULL);

    }

    return(ctx);

}

/**

 * xmlSecTransformCtxDestroy:

 * @ctx:		the pointer to transforms chain processing context.

 *

 * Destroy context object created with #xmlSecTransformCtxCreate function.

 */

EXPORT_C

void

xmlSecTransformCtxDestroy(xmlSecTransformCtxPtr ctx) {

    xmlSecAssert(ctx != NULL);

    xmlSecTransformCtxFinalize(ctx);

    xmlFree(ctx);

}

/**

 * xmlSecTransformCtxInitialize:

 * @ctx:		the pointer to transforms chain processing context.

 *

 * Initializes transforms chain processing context.

 * The caller is responsible for cleaing up returend object by calling 

 * #xmlSecTransformCtxFinalize function.

 *

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

 */

EXPORT_C

int 

xmlSecTransformCtxInitialize(xmlSecTransformCtxPtr ctx) {

    int ret;

    xmlSecAssert2(ctx != NULL, -1);

    memset(ctx, 0, sizeof(xmlSecTransformCtx));

    ret = xmlSecPtrListInitialize(&(ctx->enabledTransforms), xmlSecTransformIdListId);

    if(ret < 0) { 

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    ctx->enabledUris = xmlSecTransformUriTypeAny;

    return(0);

}

/**

 * xmlSecTransformCtxFinalize:

 * @ctx:		the pointer to transforms chain processing context.

 *

 * Cleans up @ctx object initialized with #xmlSecTransformCtxInitialize function.

 */

EXPORT_C

void 

xmlSecTransformCtxFinalize(xmlSecTransformCtxPtr ctx) {

    xmlSecAssert(ctx != NULL);

    xmlSecTransformCtxReset(ctx);

    xmlSecPtrListFinalize(&(ctx->enabledTransforms));

    memset(ctx, 0, sizeof(xmlSecTransformCtx));

}

/**

 * xmlSecTransformCtxReset:

 * @ctx:		the pointer to transforms chain processing context.

 *

 * Resets transfroms context for new processing.

 */

EXPORT_C

void 

xmlSecTransformCtxReset(xmlSecTransformCtxPtr ctx) {

    xmlSecTransformPtr transform, tmp;    

    xmlSecAssert(ctx != NULL);

    ctx->result = NULL;

    ctx->status = xmlSecTransformStatusNone;

    /* destroy uri */

    if(ctx->uri != NULL) {

	xmlFree(ctx->uri);

	ctx->uri = NULL;

    }

    if(ctx->xptrExpr != NULL) {

	xmlFree(ctx->xptrExpr);

	ctx->xptrExpr = NULL;

    }

    /* destroy transforms chain */

    for(transform = ctx->first; transform != NULL; transform = tmp) {

	tmp = transform->next;

	xmlSecTransformDestroy(transform);

    }

    ctx->first = ctx->last = NULL;

}

/**

 * xmlSecTransformCtxCopyUserPref: 

 * @dst:		the pointer to destination transforms chain processing context.

 * @src:		the pointer to source transforms chain processing context.

 *

 * Copies user settings from @src context to @dst.

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int 

xmlSecTransformCtxCopyUserPref(xmlSecTransformCtxPtr dst, xmlSecTransformCtxPtr src) {

    int ret;

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    dst->userData 	 = src->userData;  

    dst->flags		 = src->flags;  

    dst->flags2		 = src->flags2;  

    dst->enabledUris	 = src->enabledUris;

    dst->preExecCallback = src->preExecCallback;

    ret = xmlSecPtrListCopy(&(dst->enabledTransforms), &(src->enabledTransforms));

    if(ret < 0) { 

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListCopy",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);

}

/**

 * xmlSecTransformCtxAppend: 

 * @ctx:		the pointer to transforms chain processing context.

 * @transform:		the pointer to new transform.

 *

 * Connects the @transform to the end of the chain of transforms in the @ctx 

 * (see #xmlSecTransformConnect function for details).

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int 

xmlSecTransformCtxAppend(xmlSecTransformCtxPtr ctx, xmlSecTransformPtr transform) {

    int ret;

    xmlSecAssert2(ctx != NULL, -1);    

    xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);

    xmlSecAssert2(xmlSecTransformIsValid(transform), -1);

    if(ctx->last != NULL) {

	ret = xmlSecTransformConnect(ctx->last, transform, ctx);

	if(ret < 0) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecTransformConnect",	    

		        XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"name=%s",

			xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));

	    return(-1);

	}

    } else {

	xmlSecAssert2(ctx->first == NULL, -1);

	ctx->first = transform;

    }

    ctx->last = transform;

    return(0);