/**
* 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);
}
/**
* xmlSecTransformCtxPrepend:
* @ctx: the pointer to transforms chain processing context.
* @transform: the pointer to new transform.
*
* Connects the @transform to the beggining 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
xmlSecTransformCtxPrepend(xmlSecTransformCtxPtr ctx, xmlSecTransformPtr transform) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
if(ctx->first != NULL) {
ret = xmlSecTransformConnect(transform, ctx->first, 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->last == NULL, -1);
ctx->last = transform;
}
ctx->first = transform;
return(0);
}
/**
* xmlSecTransformCtxCreateAndAppend:
* @ctx: the pointer to transforms chain processing context.
* @id: the new transform klass.
*
* Creaeates new transform and connects it to the end of the chain of
* transforms in the @ctx (see #xmlSecTransformConnect function for details).
*
* Returns pointer to newly created transform or NULL if an error occurs.
*/
EXPORT_C
xmlSecTransformPtr
xmlSecTransformCtxCreateAndAppend(xmlSecTransformCtxPtr ctx, xmlSecTransformId id) {
xmlSecTransformPtr transform;
int ret;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, NULL);
xmlSecAssert2(id != xmlSecTransformIdUnknown, NULL);
transform = xmlSecTransformCreate(id);
if(!xmlSecTransformIsValid(transform))
{
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)));
xmlSecTransformDestroy(transform);
return(NULL);
}
ret = xmlSecTransformCtxAppend(ctx, transform);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxAppend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
xmlSecTransformDestroy(transform);
return(NULL);
}
return(transform);
}
/**
* xmlSecTransformCtxCreateAndPrepend:
* @ctx: the pointer to transforms chain processing context.
* @id: the new transform klass.
*
* Creaeates new transform and connects it to the end of the chain of
* transforms in the @ctx (see #xmlSecTransformConnect function for details).
*
* Returns pointer to newly created transform or NULL if an error occurs.
*/
EXPORT_C
xmlSecTransformPtr
xmlSecTransformCtxCreateAndPrepend(xmlSecTransformCtxPtr ctx, xmlSecTransformId id) {
xmlSecTransformPtr transform;
int ret;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, NULL);
xmlSecAssert2(id != xmlSecTransformIdUnknown, NULL);
transform = xmlSecTransformCreate(id);
if(!xmlSecTransformIsValid(transform))
{
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)));
xmlSecTransformDestroy(transform);
return(NULL);
}
ret = xmlSecTransformCtxPrepend(ctx, transform);
if(ret < 0)
{
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
xmlSecTransformDestroy(transform);
return(NULL);
}
return(transform);
}
/**
* xmlSecTransformCtxNodeRead:
* @ctx: the pointer to transforms chain processing context.
* @node: the pointer to transform's node.
* @usage: the transform's usage (signature, encryption, etc.).
*
* Reads the transform from the @node and appends it to the current chain
* of transforms in @ctx.
*
* Returns pointer to newly created transform or NULL if an error occurs.
*/
EXPORT_C
xmlSecTransformPtr
xmlSecTransformCtxNodeRead(xmlSecTransformCtxPtr ctx, xmlNodePtr node,
xmlSecTransformUsage usage) {
xmlSecTransformPtr transform;
int ret;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, NULL);
xmlSecAssert2(node != NULL, NULL);
transform = xmlSecTransformNodeRead(node, usage, ctx);
if(transform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(NULL);
}
ret = xmlSecTransformCtxAppend(ctx, transform);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxAppend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
xmlSecTransformDestroy(transform);
return(NULL);
}
return(transform);
}
/**
* xmlSecTransformCtxNodesListRead:
* @ctx: the pointer to transforms chain processing context.
* @node: the pointer to <dsig:Transform/> nodes parent node.
* @usage: the transform's usage (signature, encryption, etc.).
*
* Reads transforms from the <dsig:Transform/> children of the @node and
* appends them to the current transforms chain in @ctx object.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxNodesListRead(xmlSecTransformCtxPtr ctx, xmlNodePtr node, xmlSecTransformUsage usage) {
xmlSecTransformPtr transform;
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(node != NULL, -1);
cur = xmlSecGetNextElementNode(node->children);
while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeTransform, xmlSecDSigNs)) {
transform = xmlSecTransformNodeRead(cur, usage, ctx);
if(transform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)));
return(-1);
}
ret = xmlSecTransformCtxAppend(ctx, transform);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxAppend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)));
xmlSecTransformDestroy(transform);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* xmlSecTransformCtxSetUri:
* @ctx: the pointer to transforms chain processing context.
* @uri: the URI.
* @hereNode: the pointer to "here" node required by some
* XML transforms (may be NULL).
*
* Parses uri and adds xpointer transforms if required.
*
* The following examples demonstrate what the URI attribute identifies and
* how it is dereferenced
* (http://www.w3.org/TR/xmldsig-core/#sec-ReferenceProcessingModel):
*
* - URI="http://example.com/bar.xml"
* identifies the octets that represent the external resource
* 'http://example.com/bar.xml', that is probably an XML document given
* its file extension.
*
* - URI="http://example.com/bar.xml#chapter1"
* identifies the element with ID attribute value 'chapter1' of the
* external XML resource 'http://example.com/bar.xml', provided as an
* octet stream. Again, for the sake of interoperability, the element
* identified as 'chapter1' should be obtained using an XPath transform
* rather than a URI fragment (barename XPointer resolution in external
* resources is not REQUIRED in this specification).
*
* - URI=""
* identifies the node-set (minus any comment nodes) of the XML resource
* containing the signature
*
* - URI="#chapter1"
* identifies a node-set containing the element with ID attribute value
* 'chapter1' of the XML resource containing the signature. XML Signature
* (and its applications) modify this node-set to include the element plus
* all descendents including namespaces and attributes -- but not comments.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxSetUri(xmlSecTransformCtxPtr ctx, const xmlChar* uri, xmlNodePtr hereNode) {
xmlSecNodeSetType nodeSetType = xmlSecNodeSetTree;
const xmlChar* xptr;
xmlChar* buf = NULL;
int useVisa3DHack = 0;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->uri == NULL, -1);
xmlSecAssert2(ctx->xptrExpr == NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(hereNode != NULL, -1);
/* check uri */
if(xmlSecTransformUriTypeCheck(ctx->enabledUris, uri) != 1) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_INVALID_URI_TYPE,
"uri=%s",
xmlSecErrorsSafeString(uri));
return(-1);
}
/* is it an empty uri? */
if((uri == NULL) || (xmlStrlen(uri) == 0)) {
return(0);
}
/* do we have barename or full xpointer? */
xptr = xmlStrchr(uri, '#');
if(xptr == NULL){
ctx->uri = xmlStrdup(uri);
if(ctx->uri == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_STRDUP_FAILED,
"size=%d", xmlStrlen(uri));
return(-1);
}
/* we are done */
return(0);
} else if(xmlStrcmp(uri, BAD_CAST "#xpointer(/)") == 0) {
ctx->xptrExpr = xmlStrdup(uri);
if(ctx->xptrExpr == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_STRDUP_FAILED,
"size=%d", xmlStrlen(uri));
return(-1);
}
/* we are done */
return(0);
}
ctx->uri = xmlStrndup(uri, xptr - uri);
if(ctx->uri == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_STRDUP_FAILED,
"size=%d", xptr - uri);
return(-1);
}
ctx->xptrExpr = xmlStrdup(xptr);
if(ctx->xptrExpr == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_STRDUP_FAILED,
"size=%d", xmlStrlen(xptr));
return(-1);
}
/* do we have barename or full xpointer? */
xmlSecAssert2(xptr != NULL, -1);
if((xmlStrncmp(xptr, BAD_CAST "#xpointer(", 10) == 0) || (xmlStrncmp(xptr, BAD_CAST "#xmlns(", 7) == 0)) {
++xptr;
nodeSetType = xmlSecNodeSetTree;
} else if((ctx->flags & XMLSEC_TRANSFORMCTX_FLAGS_USE_VISA3D_HACK) != 0) {
++xptr;
nodeSetType = xmlSecNodeSetTreeWithoutComments;
useVisa3DHack = 1;
} else {
static const char tmpl[] = "xpointer(id(\'%s\'))";
xmlSecSize size;
/* we need to add "xpointer(id('..')) because otherwise we have
* problems with numeric ("111" and so on) and other "strange" ids */
size = xmlStrlen(BAD_CAST tmpl) + xmlStrlen(xptr) + 2;
buf = (xmlChar*)xmlMalloc(size * sizeof(xmlChar));
if(buf == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_MALLOC_FAILED,
"size=%d", size);
return(-1);
}
sprintf((char*)buf, tmpl, xptr + 1);
xptr = buf;
nodeSetType = xmlSecNodeSetTreeWithoutComments;
}
if(useVisa3DHack == 0) {
xmlSecTransformPtr transform;
/* we need to create XPonter transform to execute expr */
transform = xmlSecTransformCtxCreateAndPrepend(ctx, xmlSecTransformXPointerId);
if(!xmlSecTransformIsValid(transform)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxCreateAndPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXPointerId)));
xmlFree( buf ); //buf == xptr
return(-1);
}
ret = xmlSecTransformXPointerSetExpr(transform, xptr, nodeSetType, hereNode);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformXPointerSetExpr",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
if( buf != NULL) {
xmlFree( buf ); //buf == xptr
}
return(-1);
}
} else {
/* Visa3D protocol doesn't follow XML/XPointer/XMLDSig specs
* and allows something like "#12345" in the URI attribute.
*/
xmlSecTransformPtr transform;
transform = xmlSecTransformCtxCreateAndPrepend(ctx, xmlSecTransformVisa3DHackId);
if(!xmlSecTransformIsValid(transform)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxCreateAndPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformVisa3DHackId)));
return(-1);
}
ret = xmlSecTransformVisa3DHackSetID(transform, xptr);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformVisa3DHackSetID",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
if(buf != NULL) {
xmlFree(buf);
}
return(-1);
}
}
if(buf != NULL) {
xmlFree(buf);
}
return(0);
}
/**
* xmlSecTransformCtxPrepare:
* @ctx: the pointer to transforms chain processing context.
* @inputDataType: the expected input type.
*
* Prepares the transform context for processing data of @inputDataType.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxPrepare(xmlSecTransformCtxPtr ctx, xmlSecTransformDataType inputDataType) {
xmlSecTransformDataType firstType;
xmlSecTransformPtr transform;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->result == NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
/* add binary buffer to store result */
transform = xmlSecTransformCtxCreateAndAppend(ctx, xmlSecTransformMemBufId);
if(!xmlSecTransformIsValid(transform)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformMemBufId)));
return(-1);
}
ctx->result = xmlSecTransformMemBufGetBuffer(transform);
if(ctx->result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformMemBufGetBuffer",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformMemBufId)));
return(-1);
}
firstType = xmlSecTransformGetDataType(ctx->first, xmlSecTransformModePush, ctx);
if(((firstType & xmlSecTransformDataTypeBin) == 0) &&
((inputDataType & xmlSecTransformDataTypeBin) != 0)) {
/* need to add parser transform */
transform = xmlSecTransformCtxCreateAndPrepend(ctx, xmlSecTransformXmlParserId);
if(transform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxCreateAndPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformXmlParserId)));
return(-1);
}
} else if(((firstType & xmlSecTransformDataTypeXml) == 0) &&
((inputDataType & xmlSecTransformDataTypeXml) != 0)) {
/* need to add c14n transform */
transform = xmlSecTransformCtxCreateAndPrepend(ctx, xmlSecTransformInclC14NId);
if(transform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxCreateAndPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformInclC14NId)));
return(-1);
}
}
/* finally let application a chance to verify that it's ok to execte
* this transforms chain */
if(ctx->preExecCallback != NULL) {
ret = (ctx->preExecCallback)(ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"ctx->preExecCallback",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
ctx->status = xmlSecTransformStatusWorking;
return(0);
}
/**
* xmlSecTransformCtxBinaryExecute:
* @ctx: the pointer to transforms chain processing context.
* @data: the input binary data buffer.
* @dataSize: the input data size.
*
* Processes binary data using transforms chain in the @ctx.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxBinaryExecute(xmlSecTransformCtxPtr ctx,
const xmlSecByte* data, xmlSecSize dataSize) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->result == NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(data != NULL, -1);
xmlSecAssert2(dataSize > 0, -1);
/* we should not have uri stored in ctx */
xmlSecAssert2(ctx->uri == NULL, -1);
ret = xmlSecTransformCtxPrepare(ctx, xmlSecTransformDataTypeBin);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPrepare",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"type=bin");
return(-1);
}
ret = xmlSecTransformPushBin(ctx->first, data, dataSize, 1, ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPushBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"dataSize=%d", dataSize);
return(-1);
}
ctx->status = xmlSecTransformStatusFinished;
return(0);
}
/**
* xmlSecTransformCtxUriExecute:
* @ctx: the pointer to transforms chain processing context.
* @uri: the URI.
*
* Process binary data from the URI using transforms chain in @ctx.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxUriExecute(xmlSecTransformCtxPtr ctx, const xmlChar* uri) {
xmlSecTransformPtr uriTransform;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(uri != NULL, -1);
/* we should not execute transform for a different uri */
xmlSecAssert2((ctx->uri == NULL) || (uri == ctx->uri) || xmlStrEqual(uri, ctx->uri), -1);
uriTransform = xmlSecTransformCtxCreateAndPrepend(ctx, xmlSecTransformInputURIId);
if(uriTransform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxCreateAndPrepend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(xmlSecTransformInputURIId)));
return(-1);
}
ret = xmlSecTransformInputURIOpen(uriTransform, uri);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformInputURIOpen",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"uri=%s",
xmlSecErrorsSafeString(uri));
return(-1);
}
/* we do not need to do something special for this transform */
ret = xmlSecTransformCtxPrepare(ctx, xmlSecTransformDataTypeUnknown);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPrepare",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"type=bin");
return(-1);
}
/* Now we have a choice: we either can push from first transform or pop
* from last. Our C14N transforms prefers push, so push data!
*/
ret = xmlSecTransformPump(uriTransform, uriTransform->next, ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformPump",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"uri=%s",
xmlSecErrorsSafeString(uri));
return(-1);
}
ctx->status = xmlSecTransformStatusFinished;
return(0);
}
/**
* xmlSecTransformCtxXmlExecute:
* @ctx: the pointer to transforms chain processing context.
* @nodes: the input node set.
*
* Process @nodes using transforms in the transforms chain in @ctx.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxXmlExecute(xmlSecTransformCtxPtr ctx, xmlSecNodeSetPtr nodes) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->result == NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(nodes != NULL, -1);
xmlSecAssert2((ctx->uri == NULL) || (xmlStrlen(ctx->uri) == 0), -1);
ret = xmlSecTransformCtxPrepare(ctx, xmlSecTransformDataTypeXml);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxPrepare",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"type=xml");
return(-1);
}
/* it's better to do push than pop because all XML transform
* just don't care and c14n likes push more than pop */
ret = xmlSecTransformPushXml(ctx->first, nodes, ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformPushXml",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(ctx->first)));
return(-1);
}
ctx->status = xmlSecTransformStatusFinished;
return(0);
}
/**
* xmlSecTransformCtxExecute:
* @ctx: the pointer to transforms chain processing context.
* @doc: the pointer to input document.
*
* Executes transforms chain in @ctx.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformCtxExecute(xmlSecTransformCtxPtr ctx, xmlDocPtr doc) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->result == NULL, -1);
xmlSecAssert2(ctx->status == xmlSecTransformStatusNone, -1);
xmlSecAssert2(doc != NULL, -1);
if((ctx->uri == NULL) || (xmlStrlen(ctx->uri) == 0)) {
xmlSecNodeSetPtr nodes;
if((ctx->xptrExpr != NULL) && (xmlStrlen(ctx->xptrExpr) > 0)){
/* our xpointer transform takes care of providing correct nodes set */
nodes = xmlSecNodeSetCreate(doc, NULL, xmlSecNodeSetNormal);
if(nodes == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecNodeSetCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
} else {
/* we do not want to have comments for empty URI */
nodes = xmlSecNodeSetGetChildren(doc, NULL, 0, 0);
if(nodes == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecNodeSetGetChildren",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
ret = xmlSecTransformCtxXmlExecute(ctx, nodes);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxXmlExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecNodeSetDestroy(nodes);
return(-1);
}
xmlSecNodeSetDestroy(nodes);
} else {
ret = xmlSecTransformCtxUriExecute(ctx, ctx->uri);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCtxUriExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
return(0);
}
/**
* xmlSecTransformCtxDebugDump:
* @ctx: the pointer to transforms chain processing context.
* @output: the pointer to output FILE.
*
* Prints transforms context debug information to @output.
*/
EXPORT_C
void
xmlSecTransformCtxDebugDump(xmlSecTransformCtxPtr ctx, FILE* output) {
xmlSecTransformPtr transform;
xmlSecAssert(ctx != NULL);
xmlSecAssert(output != NULL);
fprintf(output, "== TRANSFORMS CTX (status=%d)\n", ctx->status);
fprintf(output, "== flags: 0x%08x\n", ctx->flags);
fprintf(output, "== flags2: 0x%08x\n", ctx->flags2);
if(xmlSecPtrListGetSize(&(ctx->enabledTransforms)) > 0) {
fprintf(output, "== enabled transforms: ");
xmlSecTransformIdListDebugDump(&(ctx->enabledTransforms), output);
} else {
fprintf(output, "== enabled transforms: all\n");
}
fprintf(output, "=== uri: %s\n",
(ctx->uri != NULL) ? ctx->uri : BAD_CAST "NULL");
fprintf(output, "=== uri xpointer expr: %s\n",
(ctx->xptrExpr != NULL) ? ctx->xptrExpr : BAD_CAST "NULL");
for(transform = ctx->first; transform != NULL; transform = transform->next) {
xmlSecTransformDebugDump(transform, output);
}
}
/**
* xmlSecTransformCtxDebugXmlDump:
* @ctx: the pointer to transforms chain processing context.
* @output: the pointer to output FILE.
*
* Prints transforms context debug information to @output in XML format.
*/
EXPORT_C
void
xmlSecTransformCtxDebugXmlDump(xmlSecTransformCtxPtr ctx, FILE* output) {
xmlSecTransformPtr transform;
xmlSecAssert(ctx != NULL);
xmlSecAssert(output != NULL);
fprintf(output, "<TransformCtx status=\"%d\">\n", ctx->status);
fprintf(output, "<Flags>%08x</Flags>\n", ctx->flags);
fprintf(output, "<Flags2>%08x</Flags2>\n", ctx->flags2);
if(xmlSecPtrListGetSize(&(ctx->enabledTransforms)) > 0) {
fprintf(output, "<EnabledTransforms>\n");
xmlSecTransformIdListDebugXmlDump(&(ctx->enabledTransforms), output);
fprintf(output, "</EnabledTransforms>\n");
} else {
fprintf(output, "<EnabledTransforms>all</EnabledTransforms>\n");
}
fprintf(output, "<Uri>%s</Uri>\n",
(ctx->uri != NULL) ? ctx->uri : BAD_CAST "NULL");
fprintf(output, "<UriXPointer>%s</UriXPointer>\n",
(ctx->xptrExpr != NULL) ? ctx->xptrExpr : BAD_CAST "NULL");
for(transform = ctx->first; transform != NULL; transform = transform->next) {
xmlSecTransformDebugXmlDump(transform, output);
}
fprintf(output, "</TransformCtx>\n");
}
/**************************************************************************
*
* xmlSecTransform
*
*************************************************************************/
/**
* xmlSecTransformCreate:
* @id: the transform id to create.
*
* Creates new transform of the @id klass. The caller is responsible for
* destroying returned tansform using #xmlSecTransformDestroy function.
*
* Returns pointer to newly created transform or NULL if an error occurs.
*/
EXPORT_C
xmlSecTransformPtr
xmlSecTransformCreate(xmlSecTransformId id) {
xmlSecTransformPtr transform;
int ret;
xmlSecAssert2(id != NULL, NULL);
xmlSecAssert2(id->klassSize >= sizeof(xmlSecTransformKlass), NULL);
xmlSecAssert2(id->objSize >= sizeof(xmlSecTransform), NULL);
xmlSecAssert2(id->name != NULL, NULL);
/* Allocate a new xmlSecTransform and fill the fields. */
transform = (xmlSecTransformPtr)xmlMalloc(id->objSize);
if(transform == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_MALLOC_FAILED,
"size=%d", id->objSize);
return(NULL);
}
memset(transform, 0, id->objSize);
transform->id = id;
if(id->initialize != NULL) {
ret = (id->initialize)(transform);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"id->initialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecTransformDestroy(transform);
return(NULL);
}
}
ret = xmlSecBufferInitialize(&(transform->inBuf), 0);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", 0);
xmlSecTransformDestroy(transform);
return(NULL);
}
ret = xmlSecBufferInitialize(&(transform->outBuf), 0);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", 0);
xmlSecTransformDestroy(transform);
return(NULL);
}
return(transform);
}
/**
* xmlSecTransformDestroy:
* @transform: the pointer to transform.
*
* Destroys transform created with #xmlSecTransformCreate function.
*/
EXPORT_C
void
xmlSecTransformDestroy(xmlSecTransformPtr transform) {
xmlSecAssert(xmlSecTransformIsValid(transform));
xmlSecAssert(transform->id->objSize > 0);
/* first need to remove ourselves from chain */
xmlSecTransformRemove(transform);
xmlSecBufferFinalize(&(transform->inBuf));
xmlSecBufferFinalize(&(transform->outBuf));
/* we never destroy input nodes, output nodes
* are destroyed if and only if they are different
* from input nodes
*/
if((transform->outNodes != NULL) && (transform->outNodes != transform->inNodes)) {
xmlSecNodeSetDestroy(transform->outNodes);
}
if(transform->id->finalize != NULL) {
(transform->id->finalize)(transform);
}
memset(transform, 0, transform->id->objSize);
xmlFree(transform);
}
/**
* xmlSecTransformNodeRead:
* @node: the pointer to the transform's node.
* @usage: the transform usage (signature, encryption, ...).
* @transformCtx: the transform's chaing processing context.
*
* Reads transform from the @node as follows:
*
* 1) reads "Algorithm" attribute;
*
* 2) checks the lists of known and allowed transforms;
*
* 3) calls transform's create method;
*
* 4) calls transform's read transform node method.
*
* Returns pointer to newly created transform or NULL if an error occurs.
*/
EXPORT_C
xmlSecTransformPtr
xmlSecTransformNodeRead(xmlNodePtr node, xmlSecTransformUsage usage, xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformPtr transform;
xmlSecTransformId id;
xmlChar *href;
int ret;
xmlSecAssert2(node != NULL, NULL);
xmlSecAssert2(transformCtx != NULL, NULL);
href = xmlGetProp(node, xmlSecAttrAlgorithm);
if(href == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecAttrAlgorithm),
XMLSEC_ERRORS_R_INVALID_NODE_ATTRIBUTE,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeGetName(node)));
return(NULL);
}
id = xmlSecTransformIdListFindByHref(xmlSecTransformIdsGet(), href, usage);
if(id == xmlSecTransformIdUnknown) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformIdsListFindByHref",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"href=%s",
xmlSecErrorsSafeString(href));
xmlFree(href);
return(NULL);
}
/* check with enabled transforms list */
if((xmlSecPtrListGetSize(&(transformCtx->enabledTransforms)) > 0) &&
(xmlSecTransformIdListFind(&(transformCtx->enabledTransforms), id) != 1)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)),
XMLSEC_ERRORS_R_TRANSFORM_DISABLED,
"href=%s",
xmlSecErrorsSafeString(href));
xmlFree(href);
return(NULL);
}
transform = xmlSecTransformCreate(id);
if(!xmlSecTransformIsValid(transform)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecTransformCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)));
xmlFree(href);
xmlSecTransformDestroy(transform);
return(NULL);
}
if(transform->id->readNode != NULL) {
ret = transform->id->readNode(transform, node, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"id->readNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)));
xmlSecTransformDestroy(transform);
xmlFree(href);
return(NULL);
}
}
/* finally remember the transform node */
transform->hereNode = node;
xmlFree(href);
return(transform);
}
/**
* xmlSecTransformPump:
* @left: the source pumping transform.
* @right: the destination pumping transform.
* @transformCtx: the transform's chaing processing context.
*
* Pops data from @left transform and pushes to @right transform until
* no more data is available.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformPump(xmlSecTransformPtr left, xmlSecTransformPtr right, xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformDataType leftType;
xmlSecTransformDataType rightType;
int ret;
xmlSecAssert2(xmlSecTransformIsValid(left), -1);
xmlSecAssert2(xmlSecTransformIsValid(right), -1);
xmlSecAssert2(transformCtx != NULL, -1);
leftType = xmlSecTransformGetDataType(left, xmlSecTransformModePop, transformCtx);
rightType = xmlSecTransformGetDataType(right, xmlSecTransformModePush, transformCtx);
if(((leftType & xmlSecTransformDataTypeXml) != 0) &&
((rightType & xmlSecTransformDataTypeXml) != 0)) {
xmlSecNodeSetPtr nodes = NULL;
ret = xmlSecTransformPopXml(left, &nodes, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(left)),
"xmlSecTransformPopXml",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecTransformPushXml(right, nodes, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(right)),
"xmlSecTransformPushXml",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
} else if(((leftType & xmlSecTransformDataTypeBin) != 0) &&
((rightType & xmlSecTransformDataTypeBin) != 0)) {
xmlSecByte buf[XMLSEC_TRANSFORM_BINARY_CHUNK];
xmlSecSize bufSize;
int final;
do {
ret = xmlSecTransformPopBin(left, buf, sizeof(buf), &bufSize, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(left)),
"xmlSecTransformPopBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
final = (bufSize == 0) ? 1 : 0;
ret = xmlSecTransformPushBin(right, buf, bufSize, final, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(right)),
"xmlSecTransformPushBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
} while(final == 0);
} else {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(left)),
xmlSecErrorsSafeString(xmlSecTransformGetName(right)),
XMLSEC_ERRORS_R_INVALID_TRANSFORM,
"transforms input/output data formats do not match");
}
return(0);
}
/**
* xmlSecTransformSetKey:
* @transform: the pointer to transform.
* @key: the pointer to key.
*
* Sets the transform's key.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformSetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(key != NULL, -1);
if(transform->id->setKey != NULL) {
return((transform->id->setKey)(transform, key));
}
return(0);
}
/**
* xmlSecTransformSetKeyReq:
* @transform: the pointer to transform.
* @keyReq: the pointer to keys requirements object.
*
* Sets the key requirements for @transform in the @keyReq.
*
* Returns 0 on success or a negative value otherwise.
*/
EXPORT_C
int
xmlSecTransformSetKeyReq(xmlSecTransformPtr transform, xmlSecKeyReqPtr keyReq) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(keyReq != NULL, -1);
keyReq->keyId = xmlSecKeyDataIdUnknown;
keyReq->keyType = xmlSecKeyDataTypeUnknown;
keyReq->keyUsage = xmlSecKeyUsageAny;
keyReq->keyBitsSize = 0;
if(transform->id->setKeyReq != NULL) {
return((transform->id->setKeyReq)(transform, keyReq));
}
return(0);
}
/**
* xmlSecTransformVerify:
* @transform: the pointer to transform.
* @data: the binary data for verification.
* @dataSize: the data size.
* @transformCtx: the transform's chaing processing context.
*
* Verifies the data with transform's processing results
* (for digest, HMAC and signature transforms). The verification
* result is stored in the #status member of #xmlSecTransform object.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformVerify(xmlSecTransformPtr transform, const xmlSecByte* data,
xmlSecSize dataSize, xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->verify != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->verify)(transform, data, dataSize, transformCtx));
}
/**
* xmlSecTransformVerifyNodeContent:
* @transform: the pointer to transform.
* @node: the pointer to node.
* @transformCtx: the transform's chaing processing context.
*
* Gets the @node content, base64 decodes it and calls #xmlSecTransformVerify
* function to verify binary results.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformVerifyNodeContent(xmlSecTransformPtr transform, xmlNodePtr node,
xmlSecTransformCtxPtr transformCtx) {
xmlSecBuffer buffer;
int ret;
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
ret = xmlSecBufferInitialize(&buffer, 0);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecBufferBase64NodeContentRead(&buffer, node);
if((ret < 0) || (xmlSecBufferGetData(&buffer) == NULL)) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferBase64NodeContentRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecBufferFinalize(&buffer);
return(-1);
}
ret = xmlSecTransformVerify(transform, xmlSecBufferGetData(&buffer),
xmlSecBufferGetSize(&buffer), transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformVerify",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecBufferFinalize(&buffer);
return(-1);
}
xmlSecBufferFinalize(&buffer);
return(0);
}
/**
* xmlSecTransformGetDataType:
* @transform: the pointer to transform.
* @mode: the data mode (push or pop).
* @transformCtx: the transform's chaing processing context.
*
* Gets transform input (@mode is "push") or output (@mode is "pop") data
* type (binary or XML).
*
* Returns the transform's data type for the @mode operation.
*/
EXPORT_C
xmlSecTransformDataType
xmlSecTransformGetDataType(xmlSecTransformPtr transform, xmlSecTransformMode mode,
xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), xmlSecTransformDataTypeUnknown);
xmlSecAssert2(transform->id->getDataType != NULL, xmlSecTransformDataTypeUnknown);
return((transform->id->getDataType)(transform, mode, transformCtx));
}
/**
* xmlSecTransformPushBin:
* @transform: the pointer to transform object.
* @data: the input binary data,
* @dataSize: the input data size.
* @final: the flag: if set to 1 then it's the last
* data chunk.
* @transformCtx: the pointer to transform context object.
*
* Process binary @data and pushes results to next transform.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformPushBin(xmlSecTransformPtr transform, const xmlSecByte* data,
xmlSecSize dataSize, int final, xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->pushBin != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->pushBin)(transform, data, dataSize, final, transformCtx));
}
/**
* xmlSecTransformPopBin:
* @transform: the pointer to transform object.
* @data: the buffer to store result data.
* @maxDataSize: the size of the buffer #data.
* @dataSize: the pointer to returned data size.
* @transformCtx: the pointer to transform context object.
*
* Pops data from previous transform in the chain, processes data and
* returns result in the @data buffer. The size of returned data is
* placed in the @dataSize.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformPopBin(xmlSecTransformPtr transform, xmlSecByte* data,
xmlSecSize maxDataSize, xmlSecSize* dataSize, xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->popBin != NULL, -1);
xmlSecAssert2(data != NULL, -1);
xmlSecAssert2(dataSize != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->popBin)(transform, data, maxDataSize, dataSize, transformCtx));
}
/**
* xmlSecTransformPushXml:
* @transform: the pointer to transform object.
* @nodes: the input nodes.
* @transformCtx: the pointer to transform context object.
*
* Processes @nodes and pushes result to the next transform in the chain.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformPushXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr nodes,
xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->pushXml != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->pushXml)(transform, nodes, transformCtx));
}
/**
* xmlSecTransformPopXml:
* @transform: the pointer to transform object.
* @nodes: the pointer to store popinter to result nodes.
* @transformCtx: the pointer to transform context object.
*
* Pops data from previous transform in the chain, processes the data and
* returns result in @nodes.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformPopXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr* nodes,
xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->popXml != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->popXml)(transform, nodes, transformCtx));
}
/**
* xmlSecTransformExecute:
* @transform: the pointer to transform.
* @last: the flag: if set to 1 then it's the last data chunk.
* @transformCtx: the transform's chaing processing context.
*
* Executes transform (used by default popBin/pushBin/popXml/pushXml methods).
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->id->execute != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
return((transform->id->execute)(transform, last, transformCtx));
}
/**
* xmlSecTransformDebugDump:
* @transform: the pointer to transform.
* @output: the pointer to output FILE.
*
* Prints transform's debug information to @output.
*/
EXPORT_C
void
xmlSecTransformDebugDump(xmlSecTransformPtr transform, FILE* output) {
xmlSecAssert(xmlSecTransformIsValid(transform));
xmlSecAssert(output != NULL);
fprintf(output, "=== Transform: %s (href=%s)\n",
xmlSecErrorsSafeString(transform->id->name),
xmlSecErrorsSafeString(transform->id->href));
}
/**
* xmlSecTransformDebugXmlDump:
* @transform: the pointer to transform.
* @output: the pointer to output FILE.
*
* Prints transform's debug information to @output in XML format.
*/
EXPORT_C
void
xmlSecTransformDebugXmlDump(xmlSecTransformPtr transform, FILE* output) {
xmlSecAssert(xmlSecTransformIsValid(transform));
xmlSecAssert(output != NULL);
fprintf(output, "<Transform name=\"%s\" href=\"%s\" />\n",
xmlSecErrorsSafeString(transform->id->name),
xmlSecErrorsSafeString(transform->id->href));
}
/************************************************************************
*
* Operations on transforms chain
*
************************************************************************/
/**
* xmlSecTransformConnect:
* @left: the pointer to left (prev) transform.
* @right: the pointer to right (next) transform.
* @transformCtx: the transform's chaing processing context.
*
* If the data object is a node-set and the next transform requires octets,
* the signature application MUST attempt to convert the node-set to an octet
* stream using Canonical XML [XML-C14N].
*
* The story is different if the right transform is base64 decode
* (http://www.w3.org/TR/xmldsig-core/#sec-Base-64):
*
* This transform requires an octet stream for input. If an XPath node-set
* (or sufficiently functional alternative) is given as input, then it is
* converted to an octet stream by performing operations logically equivalent
* to 1) applying an XPath transform with expression self::text(), then 2)
* taking the string-value of the node-set. Thus, if an XML element is
* identified by a barename XPointer in the Reference URI, and its content
* consists solely of base64 encoded character data, then this transform
* automatically strips away the start and end tags of the identified element
* and any of its descendant elements as well as any descendant comments and
* processing instructions. The output of this transform is an octet stream.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformConnect(xmlSecTransformPtr left, xmlSecTransformPtr right,
xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformDataType leftType;
xmlSecTransformDataType rightType;
xmlSecTransformId middleId;
xmlSecTransformPtr middle;
xmlSecAssert2(xmlSecTransformIsValid(left), -1);
xmlSecAssert2(xmlSecTransformIsValid(right), -1);
xmlSecAssert2(transformCtx != NULL, -1);
leftType = xmlSecTransformGetDataType(left, xmlSecTransformModePop, transformCtx);
rightType = xmlSecTransformGetDataType(right, xmlSecTransformModePush, transformCtx);
if((((leftType & xmlSecTransformDataTypeBin) != 0) &&
((rightType & xmlSecTransformDataTypeBin) != 0)) ||
(((leftType & xmlSecTransformDataTypeXml) != 0) &&
((rightType & xmlSecTransformDataTypeXml) != 0))) {
left->next = right;
right->prev = left;
return(0);
}
if(((leftType & xmlSecTransformDataTypeBin) != 0) &&
((rightType & xmlSecTransformDataTypeXml) != 0)) {
/* need to insert parser */
middleId = xmlSecTransformXmlParserId;
} else if(((leftType & xmlSecTransformDataTypeXml) != 0) &&
((rightType & xmlSecTransformDataTypeBin) != 0)) {
/* need to insert c14n or special pre-base64 transform */
if(xmlSecTransformCheckId(right, xmlSecTransformBase64Id)) {
middleId = xmlSecTransformRemoveXmlTagsC14NId;
} else {
middleId = xmlSecTransformInclC14NId;
}
} else {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(left)),
xmlSecErrorsSafeString(xmlSecTransformGetName(right)),
XMLSEC_ERRORS_R_INVALID_TRANSFORM,
"leftType=%d;rightType=%d",
leftType, rightType);
return(-1);
}
/* insert transform */
middle = xmlSecTransformCreate(middleId);
if(middle == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(left)),
"xmlSecTransformCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"transform=%s",
xmlSecErrorsSafeString(xmlSecTransformKlassGetName(middleId)));
return(-1);
}
left->next = middle;
middle->prev = left;
middle->next = right;
right->prev = middle;
return(0);
}
/**
* xmlSecTransformRemove:
* @transform: the pointer to #xmlSecTransform structure.
*
* Removes @transform from the chain.
*/
EXPORT_C
void
xmlSecTransformRemove(xmlSecTransformPtr transform) {
xmlSecAssert(xmlSecTransformIsValid(transform));
if(transform->next != NULL) {
transform->next->prev = transform->prev;
}
if(transform->prev != NULL) {
transform->prev->next = transform->next;
}
transform->next = transform->prev = NULL;
}
/************************************************************************
*
* Default callbacks, most of the transforms can use them
*
************************************************************************/
/**
* xmlSecTransformDefaultGetDataType:
* @transform: the pointer to transform.
* @mode: the data mode (push or pop).
* @transformCtx: the transform's chaing processing context.
*
* Gets transform input (@mode is "push") or output (@mode is "pop") data
* type (binary or XML) by analyzing available pushBin/popBin/pushXml/popXml
* methods.
*
* Returns the transform's data type for the @mode operation.
*/
EXPORT_C
xmlSecTransformDataType
xmlSecTransformDefaultGetDataType(xmlSecTransformPtr transform, xmlSecTransformMode mode,
xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformDataType type = xmlSecTransformDataTypeUnknown;
xmlSecAssert2(xmlSecTransformIsValid(transform), xmlSecTransformDataTypeUnknown);
xmlSecAssert2(transformCtx != NULL, xmlSecTransformDataTypeUnknown);
/* we'll try to guess the data type based on the handlers we have */
switch(mode) {
case xmlSecTransformModePush:
if(transform->id->pushBin != NULL) {
type |= xmlSecTransformDataTypeBin;
}
if(transform->id->pushXml != NULL) {
type |= xmlSecTransformDataTypeXml;
}
break;
case xmlSecTransformModePop:
if(transform->id->popBin != NULL) {
type |= xmlSecTransformDataTypeBin;
}
if(transform->id->popXml != NULL) {
type |= xmlSecTransformDataTypeXml;
}
break;
default:
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
NULL,
XMLSEC_ERRORS_R_INVALID_DATA,
"mode=%d", mode);
return(xmlSecTransformDataTypeUnknown);
}
return(type);
}
/**
* xmlSecTransformDefaultPushBin:
* @transform: the pointer to transform object.
* @data: the input binary data,
* @dataSize: the input data size.
* @final: the flag: if set to 1 then it's the last
* data chunk.
* @transformCtx: the pointer to transform context object.
*
* Process binary @data by calling transform's execute method and pushes
* results to next transform.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformDefaultPushBin(xmlSecTransformPtr transform, const xmlSecByte* data,
xmlSecSize dataSize, int final, xmlSecTransformCtxPtr transformCtx) {
xmlSecSize inSize = 0;
xmlSecSize outSize = 0;
int finalData = 0;
int ret;
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transformCtx != NULL, -1);
do {
/* append data to input buffer */
if(dataSize > 0) {
xmlSecSize chunkSize;
xmlSecAssert2(data != NULL, -1);
chunkSize = dataSize;
if(chunkSize > XMLSEC_TRANSFORM_BINARY_CHUNK) {
chunkSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
}
ret = xmlSecBufferAppend(&(transform->inBuf), data, chunkSize);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferAppend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", chunkSize);
return(-1);
}
dataSize -= chunkSize;
data += chunkSize;
}
/* process data */
inSize = xmlSecBufferGetSize(&(transform->inBuf));
outSize = xmlSecBufferGetSize(&(transform->outBuf));
finalData = (((dataSize == 0) && (final != 0)) ? 1 : 0);
ret = xmlSecTransformExecute(transform, finalData, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"final=%d", final);
return(-1);
}
/* push data to the next transform */
inSize = xmlSecBufferGetSize(&(transform->inBuf));
outSize = xmlSecBufferGetSize(&(transform->outBuf));
if(inSize > 0) {
finalData = 0;
}
/* we don't want to puch too much */
if(outSize > XMLSEC_TRANSFORM_BINARY_CHUNK) {
outSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
finalData = 0;
}
if((transform->next != NULL) && ((outSize > 0) || (finalData != 0))) {
ret = xmlSecTransformPushBin(transform->next,
xmlSecBufferGetData(&(transform->outBuf)),
outSize,
finalData,
transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform->next)),
"xmlSecTransformPushBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"final=%d;outSize=%d", final, outSize);
return(-1);
}
}
/* remove data anyway */
if(outSize > 0) {
ret = xmlSecBufferRemoveHead(&(transform->outBuf), outSize);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferAppend",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", outSize);
return(-1);
}
}
} while((dataSize > 0) || (outSize > 0));
return(0);
}
/**
* xmlSecTransformDefaultPopBin:
* @transform: the pointer to transform object.
* @data: the buffer to store result data.
* @maxDataSize: the size of the buffer #data.
* @dataSize: the pointer to returned data size.
* @transformCtx: the pointer to transform context object.
*
* Pops data from previous transform in the chain, processes data by calling
* transform's execute method and returns result in the @data buffer. The
* size of returned data is placed in the @dataSize.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformDefaultPopBin(xmlSecTransformPtr transform, xmlSecByte* data,
xmlSecSize maxDataSize, xmlSecSize* dataSize, xmlSecTransformCtxPtr transformCtx) {
xmlSecSize outSize;
int final = 0;
int ret;
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(data != NULL, -1);
xmlSecAssert2(dataSize != NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
while((xmlSecBufferGetSize(&(transform->outBuf)) == 0) && (final == 0)) {
/* read data from previous transform if exist */
if(transform->prev != NULL) {
xmlSecSize inSize, chunkSize;
inSize = xmlSecBufferGetSize(&(transform->inBuf));
chunkSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
/* ensure that we have space for at least one data chunk */
ret = xmlSecBufferSetMaxSize(&(transform->inBuf), inSize + chunkSize);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferSetMaxSize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", inSize + chunkSize);
return(-1);
}
/* get data from previous transform */
ret = xmlSecTransformPopBin(transform->prev,
xmlSecBufferGetData(&(transform->inBuf)) + inSize,
chunkSize, &chunkSize, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform->prev)),
"xmlSecTransformPopBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* adjust our size if needed */
if(chunkSize > 0) {
ret = xmlSecBufferSetSize(&(transform->inBuf), inSize + chunkSize);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferSetSize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", inSize + chunkSize);
return(-1);
}
final = 0; /* the previous transform returned some data..*/
} else {
final = 1; /* no data returned from previous transform, we are done */
}
} else {
final = 1; /* no previous transform, we are "permanently final" */
}
/* execute our transform */
ret = xmlSecTransformExecute(transform, final, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
/* copy result (if any) */
outSize = xmlSecBufferGetSize(&(transform->outBuf));
if(outSize > maxDataSize) {
outSize = maxDataSize;
}
/* we don't want to put too much */
if(outSize > XMLSEC_TRANSFORM_BINARY_CHUNK) {
outSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
}
if(outSize > 0) {
xmlSecAssert2(xmlSecBufferGetData(&(transform->outBuf)), -1);
memcpy(data, xmlSecBufferGetData(&(transform->outBuf)), outSize);
ret = xmlSecBufferRemoveHead(&(transform->outBuf), outSize);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecBufferRemoveHead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"size=%d", outSize);
return(-1);
}
}
/* set the result size */
(*dataSize) = outSize;
return(0);
}
/**
* xmlSecTransformDefaultPushXml:
* @transform: the pointer to transform object.
* @nodes: the input nodes.
* @transformCtx: the pointer to transform context object.
*
* Processes @nodes by calling transform's execute method and pushes
* result to the next transform in the chain.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformDefaultPushXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr nodes,
xmlSecTransformCtxPtr transformCtx) {
int ret;
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->inNodes == NULL, -1);
xmlSecAssert2(transform->outNodes == NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
/* execute our transform */
transform->inNodes = nodes;
ret = xmlSecTransformExecute(transform, 1, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* push result to the next transform (if exist) */
if(transform->next != NULL) {
ret = xmlSecTransformPushXml(transform->next, transform->outNodes, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformPushXml",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
return(0);
}
/**
* xmlSecTransformDefaultPopXml:
* @transform: the pointer to transform object.
* @nodes: the pointer to store popinter to result nodes.
* @transformCtx: the pointer to transform context object.
*
* Pops data from previous transform in the chain, processes the data
* by calling transform's execute method and returns result in @nodes.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformDefaultPopXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr* nodes,
xmlSecTransformCtxPtr transformCtx) {
int ret;
xmlSecAssert2(xmlSecTransformIsValid(transform), -1);
xmlSecAssert2(transform->inNodes == NULL, -1);
xmlSecAssert2(transform->outNodes == NULL, -1);
xmlSecAssert2(transformCtx != NULL, -1);
/* pop result from the prev transform (if exist) */
if(transform->prev != NULL) {
ret = xmlSecTransformPopXml(transform->prev, &(transform->inNodes), transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformPopXml",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
/* execute our transform */
ret = xmlSecTransformExecute(transform, 1, transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* return result if requested */
if(nodes != NULL) {
(*nodes) = transform->outNodes;
}
return(0);
}
/***********************************************************************
*
* Transform Ids list
*
**********************************************************************/
static xmlSecPtrListKlass xmlSecTransformIdListKlass = {
BAD_CAST "transform-ids-list",
NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
NULL, /* xmlSecPtrDestroyItemMethod destroyItem; */
NULL, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
NULL, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
};
/**
* xmlSecTransformIdListGetKlass:
*
* The transform id list klass.
*
* Returns pointer to the transform id list klass.
*/
EXPORT_C
xmlSecPtrListId
xmlSecTransformIdListGetKlass(void) {
return(&xmlSecTransformIdListKlass);
}
/**
* xmlSecTransformIdListFind:
* @list: the pointer to transform ids list.
* @transformId: the transform klass.
*
* Lookups @dataId in @list.
*
* Returns 1 if @dataId is found in the @list, 0 if not and a negative
* value if an error occurs.
*/
EXPORT_C
int
xmlSecTransformIdListFind(xmlSecPtrListPtr list, xmlSecTransformId transformId) {
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecTransformIdListId), -1);
xmlSecAssert2(transformId != NULL, -1);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
if((xmlSecTransformId)xmlSecPtrListGetItem(list, i) == transformId) {
return(1);
}
}
return(0);
}
/**
* xmlSecTransformIdListFindByHref:
* @list: the pointer to transform ids list.
* @href: the desired transform klass href.
* @usage: the desired transform usage.
*
* Lookups data klass in the list with given @href and @usage in @list.
*
* Returns transform klass is found and NULL otherwise.
*/
EXPORT_C
xmlSecTransformId
xmlSecTransformIdListFindByHref(xmlSecPtrListPtr list, const xmlChar* href,
xmlSecTransformUsage usage) {
xmlSecTransformId transformId;
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecTransformIdListId), xmlSecTransformIdUnknown);
xmlSecAssert2(href != NULL, xmlSecTransformIdUnknown);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
transformId = (xmlSecTransformId)xmlSecPtrListGetItem(list, i);
xmlSecAssert2(transformId != xmlSecTransformIdUnknown, xmlSecTransformIdUnknown);
if(((usage & transformId->usage) != 0) && (transformId->href != NULL) &&
xmlStrEqual(href, transformId->href)) {
return(transformId);
}
}
return(xmlSecTransformIdUnknown);
}
/**
* xmlSecTransformIdListFindByName:
* @list: the pointer to transform ids list.
* @name: the desired transform klass name.
* @usage: the desired transform usage.
*
* Lookups data klass in the list with given @name and @usage in @list.
*
* Returns transform klass is found and NULL otherwise.
*/
EXPORT_C
xmlSecTransformId
xmlSecTransformIdListFindByName(xmlSecPtrListPtr list, const xmlChar* name,
xmlSecTransformUsage usage) {
xmlSecTransformId transformId;
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecTransformIdListId), xmlSecTransformIdUnknown);
xmlSecAssert2(name != NULL, xmlSecTransformIdUnknown);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
transformId = (xmlSecTransformId)xmlSecPtrListGetItem(list, i);
xmlSecAssert2(transformId != xmlSecTransformIdUnknown, xmlSecTransformIdUnknown);
if(((usage & transformId->usage) != 0) && (transformId->name != NULL) &&
xmlStrEqual(name, BAD_CAST transformId->name)) {
return(transformId);
}
}
return(xmlSecTransformIdUnknown);
}
/**
* xmlSecTransformIdListDebugDump:
* @list: the pointer to transform ids list.
* @output: the pointer to output FILE.
*
* Prints binary transform debug information to @output.
*/
EXPORT_C
void
xmlSecTransformIdListDebugDump(xmlSecPtrListPtr list, FILE* output) {
xmlSecTransformId transformId;
xmlSecSize i, size;
xmlSecAssert(xmlSecPtrListCheckId(list, xmlSecTransformIdListId));
xmlSecAssert(output != NULL);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
transformId = (xmlSecTransformId)xmlSecPtrListGetItem(list, i);
xmlSecAssert(transformId != NULL);
xmlSecAssert(transformId->name != NULL);
if(i > 0) {
fprintf(output, ",\"%s\"", transformId->name);
} else {
fprintf(output, "\"%s\"", transformId->name);
}
}
fprintf(output, "\n");
}
/**
* xmlSecTransformIdListDebugXmlDump:
* @list: the pointer to transform ids list.
* @output: the pointer to output FILE.
*
* Prints binary transform debug information to @output in XML format.
*/
EXPORT_C
void
xmlSecTransformIdListDebugXmlDump(xmlSecPtrListPtr list, FILE* output) {
xmlSecTransformId transformId;
xmlSecSize i, size;
xmlSecAssert(xmlSecPtrListCheckId(list, xmlSecTransformIdListId));
xmlSecAssert(output != NULL);
fprintf(output, "<TransformIdsList>\n");
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
transformId = (xmlSecTransformId)xmlSecPtrListGetItem(list, i);
xmlSecAssert(transformId != NULL);
xmlSecAssert(transformId->name != NULL);
fprintf(output, "<TransformId name=\"%s\" />", transformId->name);
}
fprintf(output, "</TransformIdsList>\n");
}
/************************************************************************
*
* IO buffers for transforms
*
************************************************************************/
typedef struct _xmlSecTransformIOBuffer xmlSecTransformIOBuffer,
*xmlSecTransformIOBufferPtr;
typedef enum {
xmlSecTransformIOBufferModeRead,
xmlSecTransformIOBufferModeWrite
} xmlSecTransformIOBufferMode;
struct _xmlSecTransformIOBuffer {
xmlSecTransformIOBufferMode mode;
xmlSecTransformPtr transform;
xmlSecTransformCtxPtr transformCtx;
};
static xmlSecTransformIOBufferPtr xmlSecTransformIOBufferCreate (xmlSecTransformIOBufferMode mode,
xmlSecTransformPtr transform,
xmlSecTransformCtxPtr transformCtx);
static void xmlSecTransformIOBufferDestroy (xmlSecTransformIOBufferPtr buffer);
static int xmlSecTransformIOBufferRead (xmlSecTransformIOBufferPtr buffer,
xmlSecByte *buf,
xmlSecSize size);
static int xmlSecTransformIOBufferWrite (xmlSecTransformIOBufferPtr buffer,
const xmlSecByte *buf,
xmlSecSize size);
static int xmlSecTransformIOBufferClose (xmlSecTransformIOBufferPtr buffer);
/**
* xmlSecTransformCreateOutputBuffer:
* @transform: the pointer to transform.
* @transformCtx: the pointer to transform context object.
*
* Creates output buffer to write data to @transform.
*
* Returns pointer to new output buffer or NULL if an error occurs.
*/
EXPORT_C
xmlOutputBufferPtr
xmlSecTransformCreateOutputBuffer(xmlSecTransformPtr transform, xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformIOBufferPtr buffer;
xmlSecTransformDataType type;
xmlOutputBufferPtr output;
xmlSecAssert2(xmlSecTransformIsValid(transform), NULL);
xmlSecAssert2(transformCtx != NULL, NULL);
/* check that we have binary push method for this transform */
type = xmlSecTransformDefaultGetDataType(transform, xmlSecTransformModePush, transformCtx);
if((type & xmlSecTransformDataTypeBin) == 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
NULL,
XMLSEC_ERRORS_R_INVALID_TRANSFORM,
"push binary data not supported");
return(NULL);
}
buffer = xmlSecTransformIOBufferCreate(xmlSecTransformIOBufferModeWrite, transform, transformCtx);
if(buffer == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformIOBufferCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(NULL);
}
output = xmlOutputBufferCreateIO((xmlOutputWriteCallback)xmlSecTransformIOBufferWrite,
(xmlOutputCloseCallback)xmlSecTransformIOBufferClose,
buffer,
NULL);
if(output == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlOutputBufferCreateIO",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecTransformIOBufferDestroy(buffer);
return(NULL);
}
return(output);
}
/**
* xmlSecTransformCreateInputBuffer:
* @transform: the pointer to transform.
* @transformCtx: the pointer to transform context object.
*
* Creates input buffer to read data from @transform.
*
* Returns pointer to new input buffer or NULL if an error occurs.
*/
EXPORT_C
xmlParserInputBufferPtr
xmlSecTransformCreateInputBuffer(xmlSecTransformPtr transform, xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformIOBufferPtr buffer;
xmlSecTransformDataType type;
xmlParserInputBufferPtr input;
xmlSecAssert2(xmlSecTransformIsValid(transform), NULL);
xmlSecAssert2(transformCtx != NULL, NULL);
/* check that we have binary pop method for this transform */
type = xmlSecTransformDefaultGetDataType(transform, xmlSecTransformModePop, transformCtx);
if((type & xmlSecTransformDataTypeBin) == 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
NULL,
XMLSEC_ERRORS_R_INVALID_TRANSFORM,
"pop binary data not supported");
return(NULL);
}
buffer = xmlSecTransformIOBufferCreate(xmlSecTransformIOBufferModeRead, transform, transformCtx);
if(buffer == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlSecTransformIOBufferCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(NULL);
}
input = xmlParserInputBufferCreateIO((xmlInputReadCallback)xmlSecTransformIOBufferRead,
(xmlInputCloseCallback)xmlSecTransformIOBufferClose,
buffer,
XML_CHAR_ENCODING_NONE);
if(input == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
"xmlParserInputBufferCreateIO",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecTransformIOBufferDestroy(buffer);
return(NULL);
}
return(input);
}
static xmlSecTransformIOBufferPtr
xmlSecTransformIOBufferCreate(xmlSecTransformIOBufferMode mode, xmlSecTransformPtr transform,
xmlSecTransformCtxPtr transformCtx) {
xmlSecTransformIOBufferPtr buffer;
xmlSecAssert2(xmlSecTransformIsValid(transform), NULL);
xmlSecAssert2(transformCtx != NULL, NULL);
buffer = (xmlSecTransformIOBufferPtr)xmlMalloc(sizeof(xmlSecTransformIOBuffer));
if(buffer == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_MALLOC_FAILED,
"size=%d", sizeof(xmlSecTransformIOBuffer));
return(NULL);
}
memset(buffer, 0, sizeof(xmlSecTransformIOBuffer));
buffer->mode = mode;
buffer->transform = transform;
buffer->transformCtx = transformCtx;
return(buffer);
}
static void
xmlSecTransformIOBufferDestroy(xmlSecTransformIOBufferPtr buffer) {
xmlSecAssert(buffer != NULL);
memset(buffer, 0, sizeof(xmlSecTransformIOBuffer));
xmlFree(buffer);
}
static int
xmlSecTransformIOBufferRead(xmlSecTransformIOBufferPtr buffer,
xmlSecByte *buf, xmlSecSize size) {
int ret;
xmlSecAssert2(buffer != NULL, -1);
xmlSecAssert2(buffer->mode == xmlSecTransformIOBufferModeRead, -1);
xmlSecAssert2(xmlSecTransformIsValid(buffer->transform), -1);
xmlSecAssert2(buffer->transformCtx != NULL, -1);
xmlSecAssert2(buf != NULL, -1);
ret = xmlSecTransformPopBin(buffer->transform, buf, size, &size, buffer->transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(buffer->transform)),
"xmlSecTransformPopBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(size);
}
static int
xmlSecTransformIOBufferWrite(xmlSecTransformIOBufferPtr buffer,
const xmlSecByte *buf, xmlSecSize size) {
int ret;
xmlSecAssert2(buffer != NULL, -1);
xmlSecAssert2(buffer->mode == xmlSecTransformIOBufferModeWrite, -1);
xmlSecAssert2(xmlSecTransformIsValid(buffer->transform), -1);
xmlSecAssert2(buffer->transformCtx != NULL, -1);
xmlSecAssert2(buf != NULL, -1);
ret = xmlSecTransformPushBin(buffer->transform, buf, size, 0, buffer->transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(buffer->transform)),
"xmlSecTransformPushBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(size);
}
static int
xmlSecTransformIOBufferClose(xmlSecTransformIOBufferPtr buffer) {
int ret;
xmlSecAssert2(buffer != NULL, -1);
xmlSecAssert2(xmlSecTransformIsValid(buffer->transform), -1);
xmlSecAssert2(buffer->transformCtx != NULL, -1);
/* need to flush write buffer before destroing */
if(buffer->mode == xmlSecTransformIOBufferModeWrite) {
ret = xmlSecTransformPushBin(buffer->transform, NULL, 0, 1, buffer->transformCtx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecTransformGetName(buffer->transform)),
"xmlSecTransformPushBin",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecTransformIOBufferDestroy(buffer);
return(-1);
}
}
xmlSecTransformIOBufferDestroy(buffer);
return(0);
}