/**
* XML Security Library (http://www.aleksey.com/xmlsec).
*
* "XML Key Management Specification v 2.0" implementation
* http://www.w3.org/TR/xkms2/
*
* 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_config.h"
#ifndef XMLSEC_NO_XKMS
#include "xmlsec_globals.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libxml2_tree.h>
#include <libxml2_parser.h>
#include <libxml2_globals.h>
#include "xmlsec_xmlsec.h"
#include "xmlsec_buffer.h"
#include "xmlsec_xmltree.h"
#include "xmlsec_keys.h"
#include "xmlsec_keysmngr.h"
#include "xmlsec_transforms.h"
#include "xmlsec_keyinfo.h"
#include "xmlsec_soap.h"
#include "xmlsec_xkms.h"
#include "xmlsec_private.h"
#include "xmlsec_privatexkms.h"
#include "xmlsec_errors.h"
#define XMLSEC_XKMS_ID_ATTRIBUTE_LEN 32
/* The ID attribute in XKMS is 'Id' */
static const xmlChar* xmlSecXkmsServerIds[] = { BAD_CAST "Id", NULL };
#ifndef XMLSEC_NO_SOAP
static int xmlSecXkmsServerCtxWriteSoap11FatalError (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr envNode);
static int xmlSecXkmsServerCtxWriteSoap12FatalError (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr envNode);
#endif /* XMLSEC_NO_SOAP */
static int xmlSecXkmsServerCtxRequestAbstractTypeNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxSignatureNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxMessageExtensionNodesRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxOpaqueClientDataNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxPendingNotificationNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxRespondWithNodesRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxPendingRequestNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxQueryKeyBindingNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeRead(xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite(xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxKeyInfoNodeWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxUseKeyWithNodesRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr* node);
static int xmlSecXkmsServerCtxUseKeyWithNodesWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxTimeInstantNodeRead (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxResultTypeNodeWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxRequestSignatureValueNodeWrite(xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite(xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxKeyBindingNodeWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxValidityIntervalNodeWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static int xmlSecXkmsServerCtxKeyBindingStatusNodeWrite (xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node,
xmlSecKeyPtr key);
static const xmlSecQName2IntegerInfo gXmlSecXkmsResultMajorInfo[] =
{
{ xmlSecXkmsNs, xmlSecResultMajorCodeSuccess,
xmlSecXkmsResultMajorSuccess },
{ xmlSecXkmsNs, xmlSecResultMajorCodeVersionMismatch,
xmlSecXkmsResultMajorVersionMismatch },
{ xmlSecXkmsNs, xmlSecResultMajorCodeSender,
xmlSecXkmsResultMajorSender },
{ xmlSecXkmsNs, xmlSecResultMajorCodeReceiver,
xmlSecXkmsResultMajorReceiver },
{ xmlSecXkmsNs, xmlSecResultMajorCodeRepresent,
xmlSecXkmsResultMajorRepresent },
{ xmlSecXkmsNs, xmlSecResultMajorCodePending,
xmlSecXkmsResultMajorPending, },
{ NULL , NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2IntegerInfo gXmlSecXkmsMinorErrorInfo[] =
{
{ xmlSecXkmsNs, xmlSecResultMinorCodeNoMatch,
xmlSecXkmsResultMinorNoMatch },
{ xmlSecXkmsNs, xmlSecResultMinorCodeTooManyResponses,
xmlSecXkmsResultMinorTooManyResponses },
{ xmlSecXkmsNs, xmlSecResultMinorCodeIncomplete,
xmlSecXkmsResultMinorIncomplete },
{ xmlSecXkmsNs, xmlSecResultMinorCodeFailure,
xmlSecXkmsResultMinorFailure },
{ xmlSecXkmsNs, xmlSecResultMinorCodeRefused,
xmlSecXkmsResultMinorRefused },
{ xmlSecXkmsNs, xmlSecResultMinorCodeNoAuthentication,
xmlSecXkmsResultMinorNoAuthentication },
{ xmlSecXkmsNs, xmlSecResultMinorCodeMessageNotSupported,
xmlSecXkmsResultMinorMessageNotSupported },
{ xmlSecXkmsNs, xmlSecResultMinorCodeUnknownResponseId,
xmlSecXkmsResultMinorUnknownResponseId },
{ xmlSecXkmsNs, xmlSecResultMinorCodeNotSynchronous,
xmlSecXkmsResultMinorSynchronous },
{ NULL, NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2IntegerInfo gXmlSecXkmsKeyBindingStatusInfo[] =
{
{ xmlSecXkmsNs, xmlSecKeyBindingStatusValid,
xmlSecXkmsKeyBindingStatusValid },
{ xmlSecXkmsNs, xmlSecKeyBindingStatusInvalid,
xmlSecXkmsKeyBindingStatusInvalid },
{ xmlSecXkmsNs, xmlSecKeyBindingStatusIndeterminate,
xmlSecXkmsKeyBindingStatusIndeterminate },
{ NULL, NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2BitMaskInfo gXmlSecXkmsKeyUsageInfo[] =
{
{ xmlSecXkmsNs, xmlSecKeyUsageEncryption,
xmlSecKeyUsageEncrypt | xmlSecKeyUsageDecrypt },
{ xmlSecXkmsNs, xmlSecKeyUsageSignature,
xmlSecKeyUsageSign | xmlSecKeyUsageVerify },
{ xmlSecXkmsNs, xmlSecKeyUsageExchange,
xmlSecKeyUsageKeyExchange},
{ NULL, NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2BitMaskInfo gXmlSecXkmsKeyBindingReasonInfo[] =
{
{ xmlSecXkmsNs, xmlSecKeyBindingReasonIssuerTrust,
XMLSEC_XKMS_KEY_BINDING_REASON_MASK_ISSUER_TRAST },
{ xmlSecXkmsNs, xmlSecKeyBindingReasonRevocationStatus,
XMLSEC_XKMS_KEY_BINDING_REASON_MASK_REVOCATION_STATUS },
{ xmlSecXkmsNs, xmlSecKeyBindingReasonValidityInterval,
XMLSEC_XKMS_KEY_BINDING_REASON_MASK_VALIDITY_INTERVAL },
{ xmlSecXkmsNs, xmlSecKeyBindingReasonSignature,
XMLSEC_XKMS_KEY_BINDING_REASON_MASK_SIGNATURE },
{ NULL, NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2BitMaskInfo gXmlSecXkmsResponseMechanismInfo[] =
{
{ xmlSecXkmsNs, xmlSecResponseMechanismRepresent,
XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_REPRESENT },
{ xmlSecXkmsNs, xmlSecResponseMechanismPending,
XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_PENDING },
{ xmlSecXkmsNs, xmlSecResponseMechanismRequestSignatureValue,
XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_REQUEST_SIGNATURE_VALUE },
{ NULL, NULL, 0 } /* MUST be last in the list */
};
static const xmlSecQName2IntegerInfo gXmlSecXkmsFormatInfo[] =
{
{ NULL, xmlSecXkmsFormatStrPlain,
xmlSecXkmsServerFormatPlain },
#ifndef XMLSEC_NO_SOAP
{ NULL, xmlSecXkmsFormatStrSoap11,
xmlSecXkmsServerFormatSoap11 },
{ NULL, xmlSecXkmsFormatStrSoap12,
xmlSecXkmsServerFormatSoap12 },
#endif /* XMLSEC_NO_SOAP */
{ NULL, NULL, 0 } /* MUST be last in the list */
};
/**
* xmlSecXkmsServerFormatFromString:
* @str the string.
*
* Gets xmlSecXkmsServerFormat from string @str.
*
* Returns corresponding format or xmlSecXkmsServerFormatUnknown
* if format could not be recognized.
*/
EXPORT_C
xmlSecXkmsServerFormat
xmlSecXkmsServerFormatFromString(const xmlChar* str) {
int res;
int ret;
xmlSecAssert2(str != NULL, xmlSecXkmsServerFormatUnknown);
ret = xmlSecQName2IntegerGetInteger(gXmlSecXkmsFormatInfo, NULL, str, &res);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2IntegerGetInteger",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(xmlSecXkmsServerFormatUnknown);
}
return((xmlSecXkmsServerFormat)res);
}
/**
* xmlSecXkmsServerFormatToString:
* @format: the format.
*
* Gets string from @format.
*
* Returns string corresponding to @format or NULL if an error occurs.
*/
EXPORT_C
const xmlChar*
xmlSecXkmsServerFormatToString (xmlSecXkmsServerFormat format) {
xmlSecQName2IntegerInfoConstPtr info;
xmlSecAssert2(format != xmlSecXkmsServerFormatUnknown, NULL);
info = xmlSecQName2IntegerGetInfo(gXmlSecXkmsFormatInfo, format);
if(info == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2IntegerGetInfo",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(NULL);
}
return(info->qnameLocalPart);
}
/**
* xmlSecXkmsServerCtxCreate:
* @keysMngr: the pointer to keys manager.
*
* Creates XKMS request server side processing context.
* The caller is responsible for destroying returend object by calling
* #xmlSecXkmsServerCtxDestroy function.
*
* Returns pointer to newly allocated context object or NULL if an error
* occurs.
*/
EXPORT_C
xmlSecXkmsServerCtxPtr
xmlSecXkmsServerCtxCreate(xmlSecKeysMngrPtr keysMngr) {
xmlSecXkmsServerCtxPtr ctx;
int ret;
ctx = (xmlSecXkmsServerCtxPtr) xmlMalloc(sizeof(xmlSecXkmsServerCtx));
if(ctx == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_MALLOC_FAILED,
"sizeof(xmlSecXkmsServerCtx)=%d",
sizeof(xmlSecXkmsServerCtx));
return(NULL);
}
ret = xmlSecXkmsServerCtxInitialize(ctx, keysMngr);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxDestroy(ctx);
return(NULL);
}
return(ctx);
}
/**
* xmlSecXkmsServerCtxDestroy:
* @ctx: the pointer to XKMS processing context.
*
* Destroy context object created with #xmlSecXkmsServerCtxCreate function.
*/
EXPORT_C
void
xmlSecXkmsServerCtxDestroy(xmlSecXkmsServerCtxPtr ctx) {
xmlSecAssert(ctx != NULL);
xmlSecXkmsServerCtxFinalize(ctx);
xmlFree(ctx);
}
/**
* xmlSecXkmsServerCtxInitialize:
* @ctx: the pointer to XKMS processing context.
* @keysMngr: the pointer to keys manager.
*
* Initializes XKMS element processing context.
* The caller is responsible for cleaing up returend object by calling
* #xmlSecXkmsServerCtxFinalize function.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerCtxInitialize(xmlSecXkmsServerCtxPtr ctx, xmlSecKeysMngrPtr keysMngr) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
memset(ctx, 0, sizeof(xmlSecXkmsServerCtx));
ctx->resultMajor = xmlSecXkmsResultMajorSuccess;
ctx->resultMinor = xmlSecXkmsResultMinorNone;
ctx->responseLimit = XMLSEC_XKMS_NO_RESPONSE_LIMIT;
ctx->idLen = XMLSEC_XKMS_ID_ATTRIBUTE_LEN;
/* initialize key info */
ret = xmlSecKeyInfoCtxInitialize(&(ctx->keyInfoReadCtx), keysMngr);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyInfoCtxInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ctx->keyInfoReadCtx.mode = xmlSecKeyInfoModeRead;
ret = xmlSecKeyInfoCtxInitialize(&(ctx->keyInfoWriteCtx), keysMngr);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyInfoCtxInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ctx->keyInfoWriteCtx.mode = xmlSecKeyInfoModeWrite;
/* enabled RespondWith */
ret = xmlSecPtrListInitialize(&(ctx->enabledRespondWithIds), xmlSecXkmsRespondWithIdListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* enabled ServerRequest */
ret = xmlSecPtrListInitialize(&(ctx->enabledServerRequestIds), xmlSecXkmsServerRequestIdListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* initialize keys list */
ret = xmlSecPtrListInitialize(&(ctx->keys), xmlSecKeyPtrListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* initialize RespondWith list */
ret = xmlSecPtrListInitialize(&(ctx->respWithList), xmlSecXkmsRespondWithIdListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* xmlSecXkmsServerCtxFinalize:
* @ctx: the pointer to XKMS processing context.
*
* Cleans up @ctx object.
*/
EXPORT_C
void
xmlSecXkmsServerCtxFinalize(xmlSecXkmsServerCtxPtr ctx) {
xmlSecAssert(ctx != NULL);
xmlSecXkmsServerCtxReset(ctx);
if(ctx->expectedService != NULL) {
xmlFree(ctx->expectedService);
}
if(ctx->idPrefix != NULL) {
xmlFree(ctx->idPrefix);
}
xmlSecKeyInfoCtxFinalize(&(ctx->keyInfoReadCtx));
xmlSecKeyInfoCtxFinalize(&(ctx->keyInfoWriteCtx));
xmlSecPtrListFinalize(&(ctx->enabledRespondWithIds));
xmlSecPtrListFinalize(&(ctx->enabledServerRequestIds));
xmlSecPtrListFinalize(&(ctx->keys));
xmlSecPtrListFinalize(&(ctx->respWithList));
memset(ctx, 0, sizeof(xmlSecXkmsServerCtx));
}
/**
* xmlSecXkmsServerCtxReset:
* @ctx: the pointer to XKMS processing context.
*
* Resets @ctx object, user settings are not touched.
*/
EXPORT_C
void
xmlSecXkmsServerCtxReset(xmlSecXkmsServerCtxPtr ctx) {
xmlSecAssert(ctx != NULL);
ctx->resultMajor = xmlSecXkmsResultMajorSuccess;
ctx->resultMinor = xmlSecXkmsResultMinorNone;
xmlSecKeyInfoCtxReset(&(ctx->keyInfoReadCtx));
xmlSecKeyInfoCtxReset(&(ctx->keyInfoWriteCtx));
xmlSecPtrListEmpty(&(ctx->keys));
xmlSecPtrListEmpty(&(ctx->respWithList));
ctx->requestNode = NULL;
ctx->opaqueClientDataNode = NULL;
ctx->firtsMsgExtNode = NULL;
ctx->keyInfoNode = NULL;
ctx->requestId = xmlSecXkmsServerRequestIdUnknown;
if(ctx->id != NULL) {
xmlFree(ctx->id); ctx->id = NULL;
}
if(ctx->service != NULL) {
xmlFree(ctx->service); ctx->service = NULL;
}
if(ctx->nonce != NULL) {
xmlFree(ctx->nonce); ctx->nonce = NULL;
}
if(ctx->originalRequestId != NULL) {
xmlFree(ctx->originalRequestId); ctx->originalRequestId = NULL;
}
if(ctx->pendingNotificationMechanism != NULL) {
xmlFree(ctx->pendingNotificationMechanism);
ctx->pendingNotificationMechanism = NULL;
}
if(ctx->pendingNotificationIdentifier != NULL) {
xmlFree(ctx->pendingNotificationIdentifier);
ctx->pendingNotificationIdentifier = NULL;
}
if(ctx->compoundRequestContexts != NULL) {
xmlSecPtrListDestroy(ctx->compoundRequestContexts);
ctx->compoundRequestContexts = NULL;
}
ctx->responseLimit = XMLSEC_XKMS_NO_RESPONSE_LIMIT;
ctx->responseMechanismMask = 0;
}
/**
* xmlSecXkmsServerCtxCopyUserPref:
* @dst: the pointer to destination context.
* @src: the pointer to source context.
*
* Copies user preference from @src context to @dst.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerCtxCopyUserPref(xmlSecXkmsServerCtxPtr dst, xmlSecXkmsServerCtxPtr src) {
int ret;
xmlSecAssert2(dst != NULL, -1);
xmlSecAssert2(src != NULL, -1);
dst->userData = src->userData;
dst->flags = src->flags;
dst->flags2 = src->flags2;
ret = xmlSecKeyInfoCtxCopyUserPref(&(dst->keyInfoReadCtx), &(src->keyInfoReadCtx));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyInfoCtxCopyUserPref",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecKeyInfoCtxCopyUserPref(&(dst->keyInfoWriteCtx), &(src->keyInfoWriteCtx));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyInfoCtxCopyUserPref",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
if(src->expectedService != NULL) {
dst->expectedService = xmlStrdup(src->expectedService);
if(dst->expectedService == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_MALLOC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
if(src->idPrefix != NULL) {
dst->idPrefix = xmlStrdup(src->idPrefix);
if(dst->idPrefix == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_MALLOC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
src->idLen = dst->idLen;
ret = xmlSecPtrListCopy(&(dst->enabledRespondWithIds), &(src->enabledRespondWithIds));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListCopy",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecPtrListCopy(&(dst->enabledServerRequestIds), &(src->enabledServerRequestIds));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListCopy",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* xmlSecXkmsServerCtxProcess:
* @ctx: the pointer to XKMS processing context.
* @node: the pointer to request node.
* @format: the request/response format.
* @doc: the pointer to response parent XML document (might be NULL).
*
* Reads XKMS request from @node and creates response to a newly created node.
* Caller is responsible for adding the returned node to the XML document.
*
* Returns pointer to newly created XKMS response node or NULL
* if an error occurs.
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerCtxProcess(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node,
xmlSecXkmsServerFormat format, xmlDocPtr doc) {
int ret;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(ctx->requestId == NULL, NULL);
xmlSecAssert2(ctx->requestNode == NULL, NULL);
xmlSecAssert2(node != NULL, NULL);
ctx->requestNode = xmlSecXkmsServerCtxRequestUnwrap(ctx, node, format);
if(ctx->requestNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestUnwrap",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(node->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
goto done;
}
ret = xmlSecXkmsServerCtxRequestRead(ctx, ctx->requestNode);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdListFindByNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"ctx->requestNode=%s",
xmlSecErrorsSafeString(ctx->requestNode->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
goto done;
}
ret = xmlSecXkmsServerRequestExecute(ctx->requestId, ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"ctx->requestNode=%s",
xmlSecErrorsSafeString(ctx->requestNode->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
goto done;
}
done:
/* always try to write response back */
if(ctx->requestId != NULL) {
xmlNodePtr respNode;
xmlNodePtr wrappedRespNode;
respNode = xmlSecXkmsServerCtxResponseWrite(ctx, doc);
if(respNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResponseWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"ctx->requestNode=%s",
xmlSecErrorsSafeString(ctx->requestNode->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
goto error;
}
wrappedRespNode = xmlSecXkmsServerCtxResponseWrap(ctx, respNode, format, doc);
if(wrappedRespNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResponseWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"ctx->requestNode=%s",
xmlSecErrorsSafeString(ctx->requestNode->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
xmlFreeNode(respNode);
goto error;
}
return(wrappedRespNode);
}
error:
/* last attempt: create fatatl error response */
return(xmlSecXkmsServerCtxFatalErrorResponseCreate(ctx, format, doc));
}
/**
* xmlSecXkmsServerCtxRequestRead:
* @ctx: the pointer to XKMS processing context.
* @node: the pointer to request node.
*
* Reads XKMS request from @node and stores data in @ctx.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerCtxRequestRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->requestId == NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* find out what the request is */
if(xmlSecPtrListGetSize(&(ctx->enabledServerRequestIds)) > 0) {
ctx->requestId = xmlSecXkmsServerRequestIdListFindByNode(&(ctx->enabledServerRequestIds), node);
} else {
ctx->requestId = xmlSecXkmsServerRequestIdListFindByNode(xmlSecXkmsServerRequestIdsGet(), node);
}
if(ctx->requestId == xmlSecXkmsServerRequestIdUnknown) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdListFindByNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(node->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorMessageNotSupported);
return(-1);
}
xmlSecAddIDs(node->doc, node, xmlSecXkmsServerIds);
ret = xmlSecXkmsServerRequestNodeRead(ctx->requestId, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"request=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(ctx->requestId)));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(-1);
}
return(0);
}
/**
* xmlSecXkmsServerCtxResponseWrite:
* @ctx: the pointer to XKMS processing context.
* @doc: the pointer to response parent XML document (might be NULL).
*
* Writes XKMS response from context to a newly created node. Caller is
* responsible for adding the returned node to the XML document.
*
* Returns pointer to newly created XKMS response node or NULL
* if an error occurs.
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerCtxResponseWrite(xmlSecXkmsServerCtxPtr ctx, xmlDocPtr doc) {
xmlNodePtr respNode;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(ctx->requestId != NULL, NULL);
/* now write results */
respNode = xmlSecXkmsServerRequestNodeWrite(ctx->requestId, ctx, doc, NULL);
if(respNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"request=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(ctx->requestId)));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
return(respNode);
}
/**
* xmlSecXkmsServerCtxRequestUnwrap:
* @ctx: the pointer to XKMS processing context.
* @node: the pointer to request node.
* @format: the request/response format.
*
* Removes SOAP or other envelope from XKMS request.
*
* Returns pointer to "real" XKMS request node or NULL if an error occurs.
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerCtxRequestUnwrap(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecXkmsServerFormat format) {
xmlNodePtr result = NULL;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(node != NULL, NULL);
switch(format) {
case xmlSecXkmsServerFormatPlain:
result = node;
break;
#ifndef XMLSEC_NO_SOAP
case xmlSecXkmsServerFormatSoap11:
/* verify that it is actually soap Envelope node */
if(xmlSecSoap11CheckEnvelope(node) != 1) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11CheckEnvelope",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
/* check that Body has exactly one entry */
if(xmlSecSoap11GetBodyEntriesNumber(node) != 1) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11GetBodyEntriesNumber",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
/* this one enntry is our xkms request */
result = xmlSecSoap11GetBodyEntry(node, 0);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11GetBodyEntry",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
break;
case xmlSecXkmsServerFormatSoap12:
/* verify that it is actually soap Envelope node */
if(xmlSecSoap12CheckEnvelope(node) != 1) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12CheckEnvelope",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
/* check that Body has exactly one entry */
if(xmlSecSoap12GetBodyEntriesNumber(node) != 1) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12GetBodyEntriesNumber",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
/* this one enntry is our xkms request */
result = xmlSecSoap12GetBodyEntry(node, 0);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12GetBodyEntry",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
break;
#endif /* XMLSEC_NO_SOAP */
default:
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
"format=%d",
format);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
return(result);
}
/**
* xmlSecXkmsServerCtxResponseWrap:
* @ctx: the pointer to XKMS processing context.
* @node: the pointer to response node.
* @format: the request/response format.
* @doc: the pointer to response parent XML document (might be NULL).
*
* Creates SOAP or other envelope around XKMS response.
* Caller is responsible for adding the returned node to the XML document.
*
* Returns pointer to newly created response envelope node or NULL
* if an error occurs.
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerCtxResponseWrap(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecXkmsServerFormat format, xmlDocPtr doc) {
xmlNodePtr result = NULL;
xmlSecAssert2(ctx != NULL, NULL);
xmlSecAssert2(node != NULL, NULL);
switch(format) {
case xmlSecXkmsServerFormatPlain:
result = node; /* do nothing */
break;
#ifndef XMLSEC_NO_SOAP
case xmlSecXkmsServerFormatSoap11:
result = xmlSecSoap11CreateEnvelope(doc);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11CreateEnvelope",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
if(xmlSecSoap11AddBodyEntry(result, node) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11AddBodyEntry",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
break;
case xmlSecXkmsServerFormatSoap12:
result = xmlSecSoap12CreateEnvelope(doc);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12CreateEnvelope",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
if(xmlSecSoap12AddBodyEntry(result, node) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12AddBodyEntry",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
break;
#endif /* XMLSEC_NO_SOAP */
default:
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
"format=%d",
format);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
return(result);
}
/**
* xmlSecXkmsServerCtxFatalErrorResponseCreate:
* @ctx: the pointer to XKMS processing context.
* @format: the request/response format.
* @doc: the pointer to response parent XML document (might be NULL).
*
* Creates a "fatal error" SOAP or other envelope respons. Caller is
* responsible for adding the returned node to the XML document.
*
* Returns pointer to newly created fatal error response (it might be NULL).
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerCtxFatalErrorResponseCreate(xmlSecXkmsServerCtxPtr ctx, xmlSecXkmsServerFormat format, xmlDocPtr doc) {
xmlNodePtr result = NULL;
int ret;
xmlSecAssert2(ctx != NULL, NULL);
/* make sure that we have an error */
if(ctx->resultMajor == xmlSecXkmsResultMajorSuccess) {
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
}
switch(format) {
case xmlSecXkmsServerFormatPlain:
/* try to create fatal error response with XKMS Status request */
result = xmlSecXkmsServerRequestNodeWrite(xmlSecXkmsServerRequestResultId, ctx, doc, NULL);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(NULL);
}
break;
#ifndef XMLSEC_NO_SOAP
case xmlSecXkmsServerFormatSoap11:
result = xmlSecSoap11CreateEnvelope(doc);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11CreateEnvelope",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
ret = xmlSecXkmsServerCtxWriteSoap11FatalError(ctx, result);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxWriteSoap11FatalError",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
xmlFreeNode(result);
return(NULL);
}
break;
case xmlSecXkmsServerFormatSoap12:
result = xmlSecSoap12CreateEnvelope(doc);
if(result == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12CreateEnvelope",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(NULL);
}
ret = xmlSecXkmsServerCtxWriteSoap12FatalError(ctx, result);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxWriteSoap12FatalError",
XMLSEC_ERRORS_R_INVALID_DATA,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
xmlFreeNode(result);
return(NULL);
}
break;
#endif /* XMLSEC_NO_SOAP */
default:
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
"format=%d",
format);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(NULL);
}
return(result);
}
#ifndef XMLSEC_NO_SOAP
static int
xmlSecXkmsServerCtxWriteSoap11FatalError(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr envNode) {
const xmlChar* faultCodeHref = NULL;
const xmlChar* faultCodeLocalPart = NULL;
xmlChar* faultString = NULL;
int len;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(envNode != NULL, -1);
if((ctx->resultMajor == xmlSecXkmsResultMajorVersionMismatch) ||
(ctx->requestNode == NULL)) {
/* we were not able to parse the envelope or its general version mismatch error */
faultCodeHref = xmlSecSoap11Ns;
faultCodeLocalPart = xmlSecSoapFaultCodeVersionMismatch;
faultString = xmlStrdup(xmlSecXkmsSoapFaultReasonUnsupportedVersion);
if(faultString == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
} else if((ctx->resultMajor == xmlSecXkmsResultMajorSender) &&
(ctx->requestId == NULL)) {
/* we understood the request but were not able to parse input message */
faultCodeHref = xmlSecSoap11Ns;
faultCodeLocalPart = xmlSecSoapFaultCodeClient;
len = xmlStrlen(BAD_CAST xmlSecErrorsSafeString(ctx->requestNode->name)) +
xmlStrlen(xmlSecXkmsSoapFaultReasonMessageInvalid) + 1;
faultString = xmlMalloc(len + 1);
if(faultString == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlMalloc",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
xmlSecStrPrintf(faultString, len , xmlSecXkmsSoapFaultReasonMessageInvalid,
xmlSecErrorsSafeString(ctx->requestNode->name));
} else if((ctx->resultMajor == xmlSecXkmsResultMajorReceiver) &&
(ctx->requestId == NULL)) {
/* we understood the request but were not able to process it */
faultCodeHref = xmlSecSoap11Ns;
faultCodeLocalPart = xmlSecSoapFaultCodeServer;
faultString = xmlStrdup(xmlSecXkmsSoapFaultReasonServiceUnavailable);
if(faultString == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
} else if((ctx->requestId == NULL) && (ctx->requestNode != NULL)) {
/* we parsed the envelope but were not able to understand this request */
faultCodeHref = xmlSecSoap11Ns;
faultCodeLocalPart = xmlSecSoapFaultCodeClient;
len = xmlStrlen(BAD_CAST xmlSecErrorsSafeString(ctx->requestNode->name)) +
xmlStrlen(xmlSecXkmsSoapFaultReasonMessageNotSupported) + 1;
faultString = xmlMalloc(len + 1);
if(faultString == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlMalloc",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
xmlSecStrPrintf(faultString, len , xmlSecXkmsSoapFaultReasonMessageNotSupported,
xmlSecErrorsSafeString(ctx->requestNode->name));
} else {
/* just some error */
faultCodeHref = xmlSecSoap11Ns;
faultCodeLocalPart = xmlSecSoapFaultCodeServer;
faultString = xmlStrdup(xmlSecXkmsSoapFaultReasonServiceUnavailable);
if(faultString == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
}
if(xmlSecSoap11AddFaultEntry(envNode, faultCodeHref, faultCodeLocalPart, faultString, NULL) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap11AddFaultEntry",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
xmlFree(faultString);
return(-1);
}
xmlFree(faultString);
return(0);
}
static int
xmlSecXkmsServerCtxWriteSoap12FatalError(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr envNode) {
xmlSecSoap12FaultCode faultCode = xmlSecSoap12FaultCodeUnknown;
const xmlChar* faultSubCodeHref = NULL;
const xmlChar* faultSubCodeLocalPart = NULL;
xmlChar* faultReason = NULL;
int len;
xmlNodePtr faultNode;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(envNode != NULL, -1);
if((ctx->resultMajor == xmlSecXkmsResultMajorVersionMismatch) ||
(ctx->requestNode == NULL)) {
/* we were not able to parse the envelope or its general version mismatch error */
faultCode = xmlSecSoap12FaultCodeVersionMismatch;
faultReason = xmlStrdup(xmlSecXkmsSoapFaultReasonUnsupportedVersion);
if(faultReason == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
} else if((ctx->resultMajor == xmlSecXkmsResultMajorSender) &&
(ctx->requestId == NULL)) {
/* we understood the request but were not able to parse input message */
faultCode = xmlSecSoap12FaultCodeSender;
faultSubCodeHref = xmlSecXkmsNs;
faultSubCodeLocalPart = xmlSecXkmsSoapSubcodeValueMessageNotSupported;
len = xmlStrlen(BAD_CAST xmlSecErrorsSafeString(ctx->requestNode->name)) +
xmlStrlen(xmlSecXkmsSoapFaultReasonMessageInvalid) + 1;
faultReason = xmlMalloc(len + 1);
if(faultReason == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlMalloc",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
xmlSecStrPrintf(faultReason, len , xmlSecXkmsSoapFaultReasonMessageInvalid,
xmlSecErrorsSafeString(ctx->requestNode->name));
} else if((ctx->resultMajor == xmlSecXkmsResultMajorReceiver) &&
(ctx->requestId == NULL)) {
/* we understood the request but were not able to process it */
faultCode = xmlSecSoap12FaultCodeReceiver;
faultReason = xmlStrdup(xmlSecXkmsSoapFaultReasonServiceUnavailable);
if(faultReason == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
} else if((ctx->requestId == NULL) && (ctx->requestNode != NULL)) {
/* we parsed the envelope but were not able to understand this request */
faultCode = xmlSecSoap12FaultCodeSender;
faultSubCodeHref = xmlSecXkmsNs;
faultSubCodeLocalPart = xmlSecXkmsSoapSubcodeValueBadMessage;
len = xmlStrlen(BAD_CAST xmlSecErrorsSafeString(ctx->requestNode->name)) +
xmlStrlen(xmlSecXkmsSoapFaultReasonMessageNotSupported) + 1;
faultReason = xmlMalloc(len + 1);
if(faultReason == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlMalloc",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
xmlSecStrPrintf(faultReason, len , xmlSecXkmsSoapFaultReasonMessageNotSupported,
xmlSecErrorsSafeString(ctx->requestNode->name));
} else {
/* just some error */
faultCode = xmlSecSoap12FaultCodeReceiver;
faultReason = xmlStrdup(xmlSecXkmsSoapFaultReasonServiceUnavailable);
if(faultReason == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_XML_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
return(-1);
}
}
xmlSecAssert2(faultCode != xmlSecSoap12FaultCodeUnknown, -1);
xmlSecAssert2(faultReason != NULL, -1);
faultNode = xmlSecSoap12AddFaultEntry(envNode, faultCode, faultReason,
xmlSecXkmsSoapFaultReasonLang, NULL, NULL);
if(faultNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12AddFaultEntry",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
xmlFree(faultReason);
return(-1);
}
xmlFree(faultReason);
if((faultSubCodeHref != NULL) && (faultSubCodeLocalPart != NULL)) {
/* make sure that we have subcode (xkms) namespace declared */
if(xmlNewNs(faultNode, faultSubCodeHref, BAD_CAST "xkms") == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlNewNs",
XMLSEC_ERRORS_R_XML_FAILED,
"ns=%s",
xmlSecErrorsSafeString(faultSubCodeHref));
return(-1);
}
if(xmlSecSoap12AddFaultSubcode(faultNode, faultSubCodeHref, faultSubCodeLocalPart) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecSoap12AddFaultSubcode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"href=%s,value=%s",
xmlSecErrorsSafeString(faultSubCodeHref),
xmlSecErrorsSafeString(faultSubCodeLocalPart));
return(-1);
}
}
return(0);
}
#endif /* XMLSEC_NO_SOAP */
/**
* xmlSecXkmsServerCtxSetResult:
* @ctx: the pointer to XKMS processing context.
* @resultMajor: the major result code.
* @resultMinor: the minor result code.
*
* Sets the major/minor result code in the context if no other result is already
* reported.
*/
EXPORT_C
void
xmlSecXkmsServerCtxSetResult(xmlSecXkmsServerCtxPtr ctx, xmlSecXkmsResultMajor resultMajor,
xmlSecXkmsResultMinor resultMinor) {
xmlSecAssert(ctx != NULL);
if((ctx->resultMajor == xmlSecXkmsResultMajorSuccess) &&
(resultMinor != xmlSecXkmsResultMajorSuccess)) {
ctx->resultMajor = resultMajor;
ctx->resultMinor = resultMinor;
} else if((ctx->resultMajor == xmlSecXkmsResultMajorSuccess) &&
(ctx->resultMinor == xmlSecXkmsResultMinorNone)) {
xmlSecAssert(resultMajor == xmlSecXkmsResultMajorSuccess);
ctx->resultMinor = resultMinor;
}
}
/**
* xmlSecXkmsServerCtxDebugDump:
* @ctx: the pointer to XKMS processing context.
* @output: the pointer to output FILE.
*
* Prints the debug information about @ctx to @output.
*/
EXPORT_C
void
xmlSecXkmsServerCtxDebugDump(xmlSecXkmsServerCtxPtr ctx, FILE* output) {
xmlSecAssert(ctx != NULL);
xmlSecAssert(output != NULL);
fprintf(output, "= XKMS SERVER CONTEXT: %s\n",
(ctx->requestId != xmlSecXkmsServerRequestIdUnknown &&
xmlSecXkmsServerRequestKlassGetName(ctx->requestId)) ?
xmlSecXkmsServerRequestKlassGetName(ctx->requestId) :
BAD_CAST "NULL");
xmlSecQName2IntegerDebugDump(gXmlSecXkmsResultMajorInfo,
ctx->resultMajor, BAD_CAST "resultMajor", output);
xmlSecQName2IntegerDebugDump(gXmlSecXkmsMinorErrorInfo,
ctx->resultMinor, BAD_CAST "resultMinor", output);
fprintf(output, "== id: %s\n",
(ctx->id) ? ctx->id : BAD_CAST "");
fprintf(output, "== service: %s\n",
(ctx->service) ? ctx->service : BAD_CAST "");
fprintf(output, "== nonce: %s\n",
(ctx->nonce) ? ctx->nonce : BAD_CAST "");
fprintf(output, "== originalRequestId: %s\n",
(ctx->originalRequestId) ? ctx->originalRequestId : BAD_CAST "");
fprintf(output, "== pendingNotificationMechanism: %s\n",
(ctx->pendingNotificationMechanism) ?
ctx->pendingNotificationMechanism :
BAD_CAST "");
fprintf(output, "== pendingNotificationIdentifier: %s\n",
(ctx->pendingNotificationIdentifier) ?
ctx->pendingNotificationIdentifier :
BAD_CAST "");
if(ctx->responseLimit != XMLSEC_XKMS_NO_RESPONSE_LIMIT) {
fprintf(output, "== ResponseLimit: %d\n", ctx->responseLimit);
}
xmlSecQName2BitMaskDebugDump(gXmlSecXkmsResponseMechanismInfo,
ctx->responseMechanismMask, BAD_CAST "responseMechanism", output);
if(ctx->expectedService != NULL) {
fprintf(output, "== expected service: %s\n", ctx->expectedService);
}
fprintf(output, "== flags: 0x%08x\n", ctx->flags);
fprintf(output, "== flags2: 0x%08x\n", ctx->flags2);
fprintf(output, "== Key Info Read Ctx:\n");
xmlSecKeyInfoCtxDebugDump(&(ctx->keyInfoReadCtx), output);
fprintf(output, "== Key Info Write Ctx:\n");
xmlSecKeyInfoCtxDebugDump(&(ctx->keyInfoWriteCtx), output);
if(xmlSecPtrListGetSize(&(ctx->enabledRespondWithIds)) > 0) {
fprintf(output, "== Enabled RespondWith: ");
xmlSecTransformIdListDebugDump(&(ctx->enabledRespondWithIds), output);
} else {
fprintf(output, "== Enabled RespondWith: all\n");
}
if(xmlSecPtrListGetSize(&(ctx->enabledServerRequestIds)) > 0) {
fprintf(output, "== Enabled ServerRequest: ");
xmlSecTransformIdListDebugDump(&(ctx->enabledServerRequestIds), output);
} else {
fprintf(output, "== Enabled ServerRequest: all\n");
}
fprintf(output, "== RespondWith List:\n");
xmlSecPtrListDebugDump(&(ctx->respWithList), output);
fprintf(output, "== Keys:\n");
xmlSecPtrListDebugDump(&(ctx->keys), output);
if(ctx->compoundRequestContexts != NULL) {
fprintf(output, "== Compound Request:\n");
xmlSecPtrListDebugDump(ctx->compoundRequestContexts, output);
}
}
/**
* xmlSecXkmsServerCtxDebugXmlDump:
* @ctx: the pointer to XKMS processing context.
* @output: the pointer to output FILE.
*
* Prints the debug information about @ctx to @output in XML format.
*/
EXPORT_C
void
xmlSecXkmsServerCtxDebugXmlDump(xmlSecXkmsServerCtxPtr ctx, FILE* output) {
xmlSecAssert(ctx != NULL);
xmlSecAssert(output != NULL);
fprintf(output, "<XkmsServerRequestContext name=\"%s\">\n",
(ctx->requestId != xmlSecXkmsServerRequestIdUnknown &&
xmlSecXkmsServerRequestKlassGetName(ctx->requestId)) ?
xmlSecXkmsServerRequestKlassGetName(ctx->requestId) :
BAD_CAST "NULL");
xmlSecQName2IntegerDebugXmlDump(gXmlSecXkmsResultMajorInfo,
ctx->resultMajor, BAD_CAST "MajorError", output);
xmlSecQName2IntegerDebugXmlDump(gXmlSecXkmsMinorErrorInfo,
ctx->resultMinor, BAD_CAST "MinorError", output);
fprintf(output, "<Id>%s</Id>\n",
(ctx->id) ? ctx->id : BAD_CAST "");
fprintf(output, "<Service>%s</Service>\n",
(ctx->service) ? ctx->service : BAD_CAST "");
fprintf(output, "<Nonce>%s</Nonce>\n",
(ctx->nonce) ? ctx->nonce : BAD_CAST "");
fprintf(output, "<OriginalRequestId>%s</OriginalRequestId>\n",
(ctx->originalRequestId) ? ctx->originalRequestId : BAD_CAST "");
fprintf(output, "<PendingNotificationMechanism>%s</PendingNotificationMechanism>\n",
(ctx->pendingNotificationMechanism) ?
ctx->pendingNotificationMechanism :
BAD_CAST "");
fprintf(output, "<PendingNotificationIdentifier>%s</PendingNotificationIdentifier>\n",
(ctx->pendingNotificationIdentifier) ?
ctx->pendingNotificationIdentifier :
BAD_CAST "");
if(ctx->responseLimit != XMLSEC_XKMS_NO_RESPONSE_LIMIT) {
fprintf(output, "<ResponseLimit>%d</ResponseLimit>\n", ctx->responseLimit);
}
xmlSecQName2BitMaskDebugXmlDump(gXmlSecXkmsResponseMechanismInfo,
ctx->responseMechanismMask, BAD_CAST "ResponseMechanism", output);
if(ctx->expectedService != NULL) {
fprintf(output, "<ExpectedService>%s</ExpectedService>\n", ctx->expectedService);
}
fprintf(output, "<Flags>%08x</Flags>\n", ctx->flags);
fprintf(output, "<Flags2>%08x</Flags2>\n", ctx->flags2);
fprintf(output, "<KeyInfoReadCtx>\n");
xmlSecKeyInfoCtxDebugXmlDump(&(ctx->keyInfoReadCtx), output);
fprintf(output, "</KeyInfoReadCtx>\n");
fprintf(output, "<KeyInfoWriteCtx>\n");
xmlSecKeyInfoCtxDebugXmlDump(&(ctx->keyInfoWriteCtx), output);
fprintf(output, "</KeyInfoWriteCtx>\n");
if(xmlSecPtrListGetSize(&(ctx->enabledRespondWithIds)) > 0) {
fprintf(output, "<EnabledRespondWith>\n");
xmlSecTransformIdListDebugXmlDump(&(ctx->enabledRespondWithIds), output);
fprintf(output, "</EnabledRespondWith>\n");
} else {
fprintf(output, "<EnabledRespondWith>all</EnabledRespondWith>\n");
}
if(xmlSecPtrListGetSize(&(ctx->enabledServerRequestIds)) > 0) {
fprintf(output, "<EnabledServerRequest>\n");
xmlSecTransformIdListDebugXmlDump(&(ctx->enabledServerRequestIds), output);
fprintf(output, "</EnabledServerRequest>\n");
} else {
fprintf(output, "<EnabledServerRequest>all</EnabledServerRequest>\n");
}
fprintf(output, "<RespondWithList>\n");
xmlSecPtrListDebugXmlDump(&(ctx->respWithList), output);
fprintf(output, "</RespondWithList>\n");
fprintf(output, "<Keys>\n");
xmlSecPtrListDebugXmlDump(&(ctx->keys), output);
fprintf(output, "</Keys>\n");
if(ctx->compoundRequestContexts != NULL) {
fprintf(output, "<CompoundRequest>\n");
xmlSecPtrListDebugXmlDump(ctx->compoundRequestContexts, output);
fprintf(output, "</CompoundRequest>\n");
}
fprintf(output, "</XkmsServerRequestContext>\n");
}
/**
* <xkms:MessageAbstractType Id Service Nonce?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
*
* <xkms:RequestAbstractType Id Service Nonce? OriginalRequestId? ResponseLimit?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
*
* XML Schema:
*
* <!-- RequestAbstractType -->
* <complexType name="RequestAbstractType" abstract="true">
* <complexContent>
* <extension base="xkms:MessageAbstractType">
* <sequence>
* <element ref="xkms:ResponseMechanism" minOccurs="0"
* maxOccurs="unbounded"/>
* <element ref="xkms:RespondWith" minOccurs="0"
* maxOccurs="unbounded"/>
* <element ref="xkms:PendingNotification" minOccurs="0"/>
* </sequence>
* <attribute name="OriginalRequestId" type="anyURI"
* use="optional"/>
* <attribute name="ResponseLimit" type="integer" use="optional"/>
* </extension>
* </complexContent>
* </complexType>
* <!-- /RequestAbstractType -->
*
* <!-- MessageAbstractType -->
* <complexType name="MessageAbstractType" abstract="true">
* <sequence>
* <element ref="ds:Signature" minOccurs="0"/>
* <element ref="xkms:MessageExtension" minOccurs="0"
* maxOccurs="unbounded"/>
* <element ref="xkms:OpaqueClientData" minOccurs="0"/>
* </sequence>
* <attribute name="Id" type="ID" use="required"/>
* <attribute name="Service" type="anyURI" use="required"/>
* <attribute name="Nonce" type="base64Binary" use="optional"/>
* </complexType>
* <!-- /MessageAbstractType -->
*/
static int
xmlSecXkmsServerCtxRequestAbstractTypeNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
xmlNodePtr cur;
xmlChar* tmp;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2((*node) != NULL, -1);
cur = (*node);
xmlSecAssert2(cur != NULL, -1);
/* required Id attribute */
xmlSecAssert2(ctx->id == NULL, -1);
ctx->id = xmlGetProp(cur, xmlSecAttrId);
if(ctx->id == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrId),
xmlSecErrorsSafeString(cur->name));
return(-1);
}
/* required Service attribute */
xmlSecAssert2(ctx->service == NULL, -1);
ctx->service = xmlGetProp(cur, xmlSecAttrService);
if(ctx->service == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrService),
xmlSecErrorsSafeString(cur->name));
return(-1);
}
/* check service */
if((ctx->expectedService != NULL) && (!xmlStrEqual(ctx->expectedService, ctx->service))) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_INVALID_DATA,
"expectedService=%s;actualService=%s",
xmlSecErrorsSafeString(ctx->expectedService),
xmlSecErrorsSafeString(ctx->service));
return(-1);
}
/* optional Nonce attribute */
xmlSecAssert2(ctx->nonce == NULL, -1);
ctx->nonce = xmlGetProp(cur, xmlSecAttrNonce);
/* optional OriginalRequestId attribute */
xmlSecAssert2(ctx->originalRequestId == NULL, -1);
ctx->originalRequestId = xmlGetProp(cur, xmlSecAttrOriginalRequestId);
/* optional ResponseLimit attribute */
xmlSecAssert2(ctx->responseLimit == XMLSEC_XKMS_NO_RESPONSE_LIMIT, -1);
tmp = xmlGetProp(cur, xmlSecAttrResponseLimit);
if(tmp != NULL) {
ctx->responseLimit = atoi((char*)tmp);
xmlFree(tmp);
}
/* now read children */
cur = xmlSecGetNextElementNode(cur->children);
/* first node is optional <dsig:Signature/> node */
if((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeSignature, xmlSecDSigNs)) {
ret = xmlSecXkmsServerCtxSignatureNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxSignatureNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
/* next is zero or more <xkms:MessageExtension/> nodes */
ret = xmlSecXkmsServerCtxMessageExtensionNodesRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxMessageExtensionNodesRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* next is optional <xkms:OpaqueClientData/> node */
if((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeOpaqueClientData, xmlSecXkmsNs)) {
ret = xmlSecXkmsServerCtxOpaqueClientDataNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxOpaqueClientDataNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
/* next is zero or more <xkms:ResponseMechanism/> nodes */
ret = xmlSecQName2BitMaskNodesRead(gXmlSecXkmsResponseMechanismInfo, &cur,
xmlSecNodeResponseMechanism, xmlSecXkmsNs,
((ctx->flags & XMLSEC_XKMS_SERVER_FLAGS_STOP_ON_UNKNOWN_RESPONSE_MECHANISM) != 0) ? 1 : 0,
&ctx->responseMechanismMask);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2BitMaskNodesRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecNodeResponseMechanism));
return(-1);
}
/* next is zero or more <xkms:RespondWith/> nodes */
ret = xmlSecXkmsServerCtxRespondWithNodesRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRespondWithNodesRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* next is optional <xkms:PendingNotification/> node */
if((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodePendingNotification, xmlSecXkmsNs)) {
ret = xmlSecXkmsServerCtxPendingNotificationNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxPendingNotificationNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
(*node) = cur;
return(0);
}
static int
xmlSecXkmsServerCtxSignatureNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
return(0);
}
/**
* <!-- MessageExtension -->
* <element name="MessageExtension" type="xkms:MessageExtensionAbstractType"
* abstract="true"/>
* <complexType name="MessageExtensionAbstractType" abstract="true"/>
* <!-- /MessageExtension -->
*/
static int
xmlSecXkmsServerCtxMessageExtensionNodesRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
xmlNodePtr cur;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->firtsMsgExtNode == NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = (*node);
while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeMessageExtension, xmlSecXkmsNs)) {
if(ctx->firtsMsgExtNode == NULL) {
ctx->firtsMsgExtNode = cur;
}
cur = xmlSecGetNextElementNode(cur->next);
}
(*node) = cur;
return(0);
}
static int
xmlSecXkmsServerCtxOpaqueClientDataNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(ctx->opaqueClientDataNode == NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* remember that node, will copy it in the response later */
ctx->opaqueClientDataNode = node;
return(0);
}
static int
xmlSecXkmsServerCtxRespondWithNodesRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = (*node);
while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeRespondWith, xmlSecXkmsNs)) {
xmlSecXkmsRespondWithId id = xmlSecXkmsRespondWithIdUnknown;
if(xmlSecPtrListGetSize(&(ctx->enabledRespondWithIds)) > 0) {
id = xmlSecXkmsRespondWithIdListFindByNodeValue(&(ctx->enabledRespondWithIds), cur);
} else {
id = xmlSecXkmsRespondWithIdListFindByNodeValue(xmlSecXkmsRespondWithIdsGet(), cur);
}
if(id != xmlSecXkmsRespondWithIdUnknown) {
ret = xmlSecXkmsRespondWithNodeRead(id, ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecCreateTree",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
} else if((ctx->flags & XMLSEC_XKMS_SERVER_FLAGS_STOP_ON_UNKNOWN_RESPOND_WITH) != 0) {
xmlChar* content ;
content = xmlNodeGetContent(cur);
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
NULL,
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s,value=%s",
xmlSecErrorsSafeString(cur->name),
xmlSecErrorsSafeString(content));
if(content != NULL) {
xmlFree(content);
}
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
(*node) = cur;
return(0);
}
/**
* XML Schema:
* <!-- PendingNotification -->
* <element name="PendingNotification" type="xkms:PendingNotificationType"/>
* <complexType name="PendingNotificationType">
* <attribute name="Mechanism" type="anyURI" use="required"/>
* <attribute name="Identifier" type="anyURI" use="required"/>
* </complexType>
* <!-- /PendingNotification -->
*/
static int
xmlSecXkmsServerCtxPendingNotificationNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2(ctx->pendingNotificationMechanism == NULL, -1);
ctx->pendingNotificationMechanism = xmlGetProp(node, xmlSecAttrMechanism);
if(ctx->pendingNotificationMechanism == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrMechanism),
xmlSecErrorsSafeString(node->name));
return(-1);
}
xmlSecAssert2(ctx->pendingNotificationIdentifier == NULL, -1);
ctx->pendingNotificationIdentifier = xmlGetProp(node, xmlSecAttrIdentifier);
if(ctx->pendingNotificationIdentifier == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrIdentifier),
xmlSecErrorsSafeString(node->name));
return(-1);
}
return(0);
}
/**
* <xkms:PendingRequestType Id Service Nonce? OriginalRequestId? ResponseLimit? ResponseId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
*
* XML Schema:
*
* <!-- PendingRequest -->
* <element name="PendingRequest" type="xkms:PendingRequestType"/>
* <complexType name="PendingRequestType">
* <complexContent>
* <extension base="xkms:RequestAbstractType">
* <attribute name="ResponseId" type="anyURI" use="optional"/>
* </extension>
* </complexContent>
* </complexType>
* <!-- /PendingRequest --> *
*/
static int
xmlSecXkmsServerCtxPendingRequestNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first read "parent" type */
ret = xmlSecXkmsServerCtxRequestAbstractTypeNodeRead(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestAbstractTypeNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:QueryKeyBinding Id?
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:TimeInstant Time>?
*
* XML Schema:
* <!-- QueryKeyBinding -->
* <element name="QueryKeyBinding" type="xkms:QueryKeyBindingType"/>
* <complexType name="QueryKeyBindingType">
* <complexContent>
* <extension base="xkms:KeyBindingAbstractType">
* <sequence>
* <element ref="xkms:TimeInstant" minOccurs="0"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /QueryKeyBinding -->
*/
static int
xmlSecXkmsServerCtxQueryKeyBindingNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first read "parent" type */
cur = node;
ret = xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* next is optional <xkms:TimeInstant/> node */
if((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeTimeInstant, xmlSecXkmsNs)) {
ret = xmlSecXkmsServerCtxTimeInstantNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxTimeInstantNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
/* check that there is nothing after the last node */
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:KeyBindingAbstractType Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
*
* XML Schema:
* <!-- KeyBindingAbstractType-->
* <complexType name="KeyBindingAbstractType" abstract="true">
* <sequence>
* <element ref="ds:KeyInfo" minOccurs="0"/>
* <element ref="xkms:KeyUsage" minOccurs="0" maxOccurs="3"/>
* <element ref="xkms:UseKeyWith" minOccurs="0"
* maxOccurs="unbounded"/>
* </sequence>
* <attribute name="Id" type="ID" use="optional"/>
* </complexType>
* <!-- /KeyBindingAbstractType-->
*/
static int
xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2((*node) != NULL, -1);
cur = (*node);
xmlSecAssert2(cur != NULL, -1);
/* we don't care about Id attribute in this node */
cur = xmlSecGetNextElementNode(cur->children);
/* first node is optional <dsig:KeyInfo/> node. for now we only remember pointer */
xmlSecAssert2(ctx->keyInfoNode == NULL, -1);
if((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeKeyInfo, xmlSecDSigNs)) {
ctx->keyInfoNode = cur;
cur = xmlSecGetNextElementNode(cur->next);
}
/* next is zero or more <xkms:KeyUsage/> nodes */
ret = xmlSecQName2BitMaskNodesRead(gXmlSecXkmsKeyUsageInfo, &cur,
xmlSecNodeKeyUsage, xmlSecXkmsNs,
((ctx->flags & XMLSEC_XKMS_SERVER_FLAGS_STOP_ON_UNKNOWN_KEY_USAGE) != 0) ? 1 : 0,
&(ctx->keyInfoReadCtx.keyReq.keyUsage));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2BitMaskNodesRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecNodeKeyUsage));
return(-1);
}
/* next is zero or more <xkms:UseKeyWith/> nodes */
ret = xmlSecXkmsServerCtxUseKeyWithNodesRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxUseKeyWithNodesRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
(*node) = cur;
return(0);
}
static int
xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2(key != NULL, -1);
/* generate and add Id attribute */
ret = xmlSecGenerateAndAddID(node, xmlSecAttrId, ctx->idPrefix, ctx->idLen);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecGenerateAndAddID",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* <dsig:KeyInfo/> node */
cur = xmlSecAddChild(node, xmlSecNodeKeyInfo, xmlSecDSigNs);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeKeyInfo));
return(-1);
}
ret = xmlSecXkmsServerCtxKeyInfoNodeWrite(ctx, cur, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyInfoNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* next is <xkms:KeyUsage/> node */
ret = xmlSecQName2BitMaskNodesWrite(gXmlSecXkmsKeyUsageInfo, node,
xmlSecNodeKeyUsage, xmlSecXkmsNs,
key->usage);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2BitMaskNodesWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecNodeKeyUsage));
return(-1);
}
/* and the last node is <xkms:UseKeyWith/> */
ret = xmlSecXkmsServerCtxUseKeyWithNodesWrite(ctx, node, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxUseKeyWithNodesWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
static int
xmlSecXkmsServerCtxKeyInfoNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(key != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* add child nodes as requested in <xkms:RespondWith/> nodes */
ret = xmlSecXkmsRespondWithIdListWrite(&(ctx->respWithList), ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdListWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
ret = xmlSecKeyInfoNodeWrite(node, key, &(ctx->keyInfoWriteCtx));
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyInfoNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* XML Schema:
* <!-- UseKeyWith -->
* <element name="UseKeyWith" type="xkms:UseKeyWithType"/>
* <complexType name="UseKeyWithType">
* <attribute name="Application" type="anyURI" use="required"/>
* <attribute name="Identifier" type="string" use="required"/>
* </complexType>
* <!-- /UseKeyWith -->
*/
static int
xmlSecXkmsServerCtxUseKeyWithNodesRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr* node) {
xmlSecPtrListPtr list;
xmlNodePtr cur;
xmlSecKeyUseWithPtr keyUseWith;
xmlChar* application;
xmlChar* identifier;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
list = &(ctx->keyInfoReadCtx.keyReq.keyUseWithList);
xmlSecAssert2(xmlSecPtrListGetSize(list) == 0, -1);
cur = (*node);
while((cur != NULL) && xmlSecCheckNodeName(cur, xmlSecNodeUseKeyWith, xmlSecXkmsNs)) {
application = xmlGetProp(cur, xmlSecAttrApplication);
if(application == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrApplication),
xmlSecErrorsSafeString(cur->name));
return(-1);
}
identifier = xmlGetProp(cur, xmlSecAttrIdentifier);
if(identifier == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlGetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s;node=%s",
xmlSecErrorsSafeString(xmlSecAttrIdentifier),
xmlSecErrorsSafeString(cur->name));
xmlFree(application);
return(-1);
}
keyUseWith = xmlSecKeyUseWithCreate(application, identifier);
if(keyUseWith == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecKeyUseWithCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlFree(application);
xmlFree(identifier);
return(-1);
}
xmlFree(application);
xmlFree(identifier);
ret = xmlSecPtrListAdd(list, keyUseWith);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecKeyUseWithDestroy(keyUseWith);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
(*node) = cur;
return(0);
}
static int
xmlSecXkmsServerCtxUseKeyWithNodesWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
xmlSecAssert2(key != NULL, -1);
return(0);
}
static int
xmlSecXkmsServerCtxTimeInstantNodeRead(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
return(0);
}
/**
* <xkms:ResultType Id Service Nonce? ResultMajor ResultMinor? RequestId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:RequestSignatureValue>*
*
* XML Schema:
* <!-- ResultType -->
* <element name="Result" type="xkms:ResultType"/>
* <complexType name="ResultType">
* <complexContent>
* <extension base="xkms:MessageAbstractType">
* <sequence>
* <element ref="xkms:RequestSignatureValue" minOccurs="0"/>
* </sequence>
* <attribute name="ResultMajor" type="QName" use="required"/>
* <attribute name="ResultMinor" type="QName" use="optional"/>
* <attribute name="RequestId" type="anyURI" use="optional"/>
* </extension>
* </complexContent>
* </complexType>
* <!-- /ResultType -->
*/
static int
xmlSecXkmsServerCtxResultTypeNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* generate and add Id attribute */
ret = xmlSecGenerateAndAddID(node, xmlSecAttrId, ctx->idPrefix, ctx->idLen);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecGenerateAndAddID",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* set Service atribute (required) */
if((ctx->service == NULL) || (xmlSetProp(node, xmlSecAttrService, ctx->service) == NULL)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s,value=%s",
xmlSecErrorsSafeString(xmlSecAttrService),
xmlSecErrorsSafeString(ctx->service));
return(-1);
}
/* set RequestId atribute (optional) */
if((ctx->id != NULL) && (xmlSetProp(node, xmlSecAttrRequestId, ctx->id) == NULL)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s,value=%s",
xmlSecErrorsSafeString(xmlSecAttrRequestId),
xmlSecErrorsSafeString(ctx->id));
return(-1);
}
/* set major code (required) */
ret = xmlSecQName2IntegerAttributeWrite(gXmlSecXkmsResultMajorInfo, node,
xmlSecAttrResultMajor, ctx->resultMajor);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2IntegerAttributeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s,value=%d",
xmlSecErrorsSafeString(xmlSecAttrResultMajor),
ctx->resultMajor);
return(-1);
}
/* set minor code (optional) */
if(ctx->resultMinor != xmlSecXkmsResultMinorNone) {
ret = xmlSecQName2IntegerAttributeWrite(gXmlSecXkmsMinorErrorInfo, node,
xmlSecAttrResultMinor, ctx->resultMinor);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2IntegerAttributeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s,value=%d",
xmlSecErrorsSafeString(xmlSecAttrResultMinor),
ctx->resultMinor);
return(-1);
}
}
/* <xkms:OpaqueClientData/>: An XKMS service SHOULD return the value of
* the <OpaqueClientData> element unmodified in a request in a response
* with status code Succes */
if((ctx->resultMajor == xmlSecXkmsResultMajorSuccess) && (ctx->opaqueClientDataNode != NULL)) {
xmlNodePtr copyNode;
copyNode = xmlDocCopyNode(ctx->opaqueClientDataNode, node->doc, 1);
if(copyNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSetProp",
XMLSEC_ERRORS_R_XML_FAILED,
"name=%s",
xmlSecErrorsSafeString(ctx->opaqueClientDataNode->name));
return(-1);
}
if(xmlSecAddChildNode(node, copyNode) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChildNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(copyNode->name));
return(-1);
}
}
ret = xmlSecXkmsServerCtxRequestSignatureValueNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestSignatureValueNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* A service SHOULD include the <RequestSignatureValue> element in a response
* if the following conditions are satisfied and MUST NOT include the value
* otherwise:
*
*
* - The <ds:Signature> element was present in the corresponding request
* - The service successfully verified the <ds:Signature> element in the
* corresponding request, and
* - The ResponseMechanism RequestSignatureValue was specified.
*
*/
static int
xmlSecXkmsServerCtxRequestSignatureValueNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
if((ctx->responseMechanismMask & XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_REQUEST_SIGNATURE_VALUE) == 0) {
/* The ResponseMechanism RequestSignatureValue was not specified. */
return(0);
}
return(0);
}
/**
*
* <xkms:UnverifiedKeyBindingType Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:ValidityInterval NotBefore NotOnOrAfter>?
*
* XML Schema:
*
* <!-- UnverifiedKeyBinding -->
* <element name="UnverifiedKeyBinding" type="xkms:UnverifiedKeyBindingType"/>
* <complexType name="UnverifiedKeyBindingType">
* <complexContent>
* <extension base="xkms:KeyBindingAbstractType">
* <sequence>
* <element ref="xkms:ValidityInterval" minOccurs="0"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /UnverifiedKeyBinding -->
*/
static int
xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(key != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first write "parent" type */
ret = xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite(ctx, node, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* <xkms:ValidityInterval/> node */
ret = xmlSecXkmsServerCtxValidityIntervalNodeWrite(ctx, node, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxValidityIntervalNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
static int
xmlSecXkmsServerCtxValidityIntervalNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(key != NULL, -1);
xmlSecAssert2(node != NULL, -1);
return(0);
}
/**
* <xkms:KeyBinding Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:ValidityInterval NotBefore NotOnOrAfter>?
* <xkms:Status StatusValue>
* (<xkms:ValidReason>?
* <xkms:IndeterminateReason>?
* <xkms:InvalidReason>?
* )*
*
* XML Schema:
*
* <!-- KeyBinding -->
* <element name="KeyBinding" type="xkms:KeyBindingType"/>
* <complexType name="KeyBindingType">
* <complexContent>
* <extension base="xkms:UnverifiedKeyBindingType">
* <sequence>
* <element ref="xkms:Status"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /KeyBinding -->
*/
static int
xmlSecXkmsServerCtxKeyBindingNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(key != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first write "parent" type */
ret = xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite(ctx, node, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* <xkms:Status/> node */
ret = xmlSecXkmsServerCtxKeyBindingStatusNodeWrite(ctx, node, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyBindingStatusNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:Status StatusValue>
* (<xkms:ValidReason>?
* <xkms:IndeterminateReason>?
* <xkms:InvalidReason>?
* )*
*
* XML Schema:
*
* <!-- Status -->
* <element name="Status" type="xkms:StatusType"/>
* <complexType name="StatusType">
* <sequence>
* <element ref="xkms:ValidReason" minOccurs="0"
* maxOccurs="unbounded"/>
* <element ref="xkms:IndeterminateReason" minOccurs="0"
* maxOccurs="unbounded"/>
* <element ref="xkms:InvalidReason" minOccurs="0"
* maxOccurs="unbounded"/>
* </sequence>
* <attribute name="StatusValue" type="xkms:KeyBindingStatus"
* use="required"/>
* </complexType>
* <simpleType name="KeyBindingStatus">
* <restriction base="QName">
* <enumeration value="xkms:Valid"/>
* <enumeration value="xkms:Invalid"/>
* <enumeration value="xkms:Indeterminate"/>
* </restriction>
* </simpleType>
* <!-- /Status -->
*/
static int
xmlSecXkmsServerCtxKeyBindingStatusNodeWrite(xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node, xmlSecKeyPtr key) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(key != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = xmlSecAddChild(node, xmlSecNodeStatus, xmlSecXkmsNs);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeStatus));
return(-1);
}
/* if we are here then the key was validated */
ret = xmlSecQName2IntegerAttributeWrite(gXmlSecXkmsKeyBindingStatusInfo, cur,
xmlSecAttrStatusValue, xmlSecXkmsKeyBindingStatusValid);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecQName2IntegerAttributeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecAttrStatusValue));
return(-1);
}
return(0);
}
/************************************************************************
*
* xmlSecXkmsServerCtx list
*
************************************************************************/
static xmlSecPtrListKlass xmlSecXkmsServerCtxPtrListKlass = {
BAD_CAST "xkms-server-ctx-list",
NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
(xmlSecPtrDestroyItemMethod)xmlSecXkmsServerCtxDestroy, /* xmlSecPtrDestroyItemMethod destroyItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsServerCtxDebugDump, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsServerCtxDebugXmlDump, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
};
EXPORT_C
xmlSecPtrListId
xmlSecXkmsServerCtxPtrListGetKlass(void) {
return(&xmlSecXkmsServerCtxPtrListKlass);
}
/**************************************************************************
*
* Global xmlSecXkmsRespondWithIds list functions
*
*************************************************************************/
static xmlSecPtrList xmlSecAllXkmsRespondWithIds;
/**
* xmlSecXkmsRespondWithIdsGet:
*
* Gets global registered RespondWith klasses list.
*
* Returns the pointer to list of all registered RespondWith klasses.
*/
EXPORT_C
xmlSecPtrListPtr
xmlSecXkmsRespondWithIdsGet(void) {
return(&xmlSecAllXkmsRespondWithIds);
}
/**
* xmlSecXkmsRespondWithIdsInit:
*
* Initializes the RespondWith 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
xmlSecXkmsRespondWithIdsInit(void) {
int ret;
ret = xmlSecPtrListInitialize(xmlSecXkmsRespondWithIdsGet(), xmlSecXkmsRespondWithIdListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListPtrInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"xmlSecXkmsRespondWithIdListId");
return(-1);
}
ret = xmlSecXkmsRespondWithIdsRegisterDefault();
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegisterDefault",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* xmlSecXkmsRespondWithIdsShutdown:
*
* 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
xmlSecXkmsRespondWithIdsShutdown(void) {
xmlSecPtrListFinalize(xmlSecXkmsRespondWithIdsGet());
}
/**
* xmlSecXkmsRespondWithIdsRegister:
* @id: the RespondWith klass.
*
* Registers @id in the global list of RespondWith klasses.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithId id) {
int ret;
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
ret = xmlSecPtrListAdd(xmlSecXkmsRespondWithIdsGet(), (xmlSecPtr)id);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"RespondWith=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)));
return(-1);
}
return(0);
}
/**
* xmlSecXkmsRespondWithIdsRegisterDefault:
*
* Registers default (implemented by XML Security Library)
* RespondWith klasses: KeyName, KeyValue,...
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsRespondWithIdsRegisterDefault(void) {
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithKeyNameId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithKeyNameId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithKeyValueId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithKeyValueId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithPrivateKeyId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithPrivateKeyId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithRetrievalMethodId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithRetrievalMethodId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithX509CertId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithX509CertId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithX509ChainId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithX509ChainId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithX509CRLId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithX509CRLId)));
return(-1);
}
/*
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithPGPId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithPGPId)));
return(-1);
}
if(xmlSecXkmsRespondWithIdsRegister(xmlSecXkmsRespondWithSPKIId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsRespondWithIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(xmlSecXkmsRespondWithSPKIId)));
return(-1);
}
*/
return(0);
}
/************************************************************************
*
* XKMS RespondWith Klass
*
************************************************************************/
/**
* xmlSecXkmsRespondWithNodeRead:
* @id: the RespondWith class.
* @ctx: the XKMS request processing context.
* @node: the pointer to <xkms:RespondWith/> node.
*
* Reads the content of the <xkms:RespondWith/> @node.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsRespondWithNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
if(id->readNode != NULL) {
return((id->readNode)(id, ctx, node));
}
return(0);
}
/**
* xmlSecXkmsRespondWithNodeWrite:
* @id: the RespondWith class.
* @ctx: the XKMS request processing context.
* @node: the pointer to <xkms:RespondWith/> node.
*
* Writes the content of the <xkms:RespondWith/> @node.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsRespondWithNodeWrite(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
if(id->writeNode != NULL) {
return((id->writeNode)(id, ctx, node));
}
return(0);
}
/**
* xmlSecXkmsRespondWithDebugDump:
* @id: the RespondWith class.
* @output: the output file.
*
* Writes debug information about @id into the @output.
*/
EXPORT_C
void
xmlSecXkmsRespondWithDebugDump(xmlSecXkmsRespondWithId id, FILE* output) {
xmlSecAssert(id != xmlSecXkmsRespondWithIdUnknown);
xmlSecAssert(output != NULL);
fprintf(output, "=== RespondWith: \"%s\" (href=\"%s\")\n",
xmlSecErrorsSafeString(id->valueName),
xmlSecErrorsSafeString(id->valueNs));
}
/**
* xmlSecXkmsRespondWithDebugXmlDump:
* @id: the RespondWith class.
* @output: the output file.
*
* Writes debug information about @id into the @output in XML format.
*/
EXPORT_C
void
xmlSecXkmsRespondWithDebugXmlDump(xmlSecXkmsRespondWithId id, FILE* output) {
xmlSecAssert(id != xmlSecXkmsRespondWithIdUnknown);
xmlSecAssert(output != NULL);
fprintf(output, "<RespondWith href=\"%s\">%s</RespondWith>\n",
xmlSecErrorsSafeString(id->valueNs),
xmlSecErrorsSafeString(id->valueName));
}
EXPORT_C
int
xmlSecXkmsRespondWithDefaultNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
ret = xmlSecXkmsRespondWithIdListFind(&(ctx->respWithList), id);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithIdListFind",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
} else if(ret > 0) {
/* do nothing, we already have it in the list */
return(0);
}
ret = xmlSecPtrListAdd(&(ctx->respWithList), id);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
EXPORT_C
int
xmlSecXkmsRespondWithDefaultNodeWrite(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
xmlNodePtr cur;
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
xmlSecAssert2(id->nodeName != NULL, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = xmlSecAddChild(node, id->nodeName, id->nodeNs);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(id->nodeName));
return(-1);
}
return(0);
}
/************************************************************************
*
* XKMS RespondWith Klass List
*
************************************************************************/
static xmlSecPtrListKlass xmlSecXkmsRespondWithIdListKlass = {
BAD_CAST "respond-with-ids-list",
NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
NULL, /* xmlSecPtrDestroyItemMethod destroyItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsRespondWithDebugDump, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsRespondWithDebugXmlDump, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
};
EXPORT_C
xmlSecPtrListId
xmlSecXkmsRespondWithIdListGetKlass(void) {
return(&xmlSecXkmsRespondWithIdListKlass);
}
EXPORT_C
int
xmlSecXkmsRespondWithIdListFind(xmlSecPtrListPtr list, xmlSecXkmsRespondWithId id) {
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsRespondWithIdListId), -1);
xmlSecAssert2(id != xmlSecXkmsRespondWithIdUnknown, -1);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
if((xmlSecXkmsRespondWithId)xmlSecPtrListGetItem(list, i) == id) {
return(1);
}
}
return(0);
}
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithIdListFindByNodeValue(xmlSecPtrListPtr list, xmlNodePtr node) {
xmlSecXkmsRespondWithId result = xmlSecXkmsRespondWithIdUnknown;
xmlSecXkmsRespondWithId id;
xmlChar* content;
xmlChar* qnameLocalPart = NULL;
xmlChar* qnamePrefix = NULL;
const xmlChar* qnameHref;
xmlNsPtr ns;
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsRespondWithIdListId), xmlSecXkmsRespondWithIdUnknown);
xmlSecAssert2(node != NULL, xmlSecXkmsRespondWithIdUnknown);
content = xmlNodeGetContent(node);
if(content == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlNodeGetContent",
XMLSEC_ERRORS_R_XML_FAILED,
"node=%s",
xmlSecErrorsSafeString(node->name));
return(xmlSecXkmsRespondWithIdUnknown);
}
qnameLocalPart = (xmlChar*)xmlStrchr(content, ':');
if(qnameLocalPart != NULL) {
qnamePrefix = content;
*(qnameLocalPart++) = '\0';
} else {
qnamePrefix = NULL;
qnameLocalPart = content;
}
/* search namespace href */
ns = xmlSearchNs(node->doc, node, qnamePrefix);
if((ns == NULL) && (qnamePrefix != NULL)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSearchNs",
XMLSEC_ERRORS_R_XML_FAILED,
"node=%s,qnamePrefix=%s",
xmlSecErrorsSafeString(node->name),
xmlSecErrorsSafeString(qnamePrefix));
xmlFree(content);
return(xmlSecXkmsRespondWithIdUnknown);
}
qnameHref = (ns != NULL) ? ns->href : BAD_CAST NULL;
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
id = (xmlSecXkmsRespondWithId)xmlSecPtrListGetItem(list, i);
if((id != xmlSecXkmsRespondWithIdUnknown) &&
xmlStrEqual(id->valueName, qnameLocalPart) &&
xmlStrEqual(id->valueNs, qnameHref)) {
result = id;
break;
}
}
xmlFree(content);
return(result);
}
EXPORT_C
int
xmlSecXkmsRespondWithIdListWrite(xmlSecPtrListPtr list, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecXkmsRespondWithId id;
xmlSecSize i, size;
int ret;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsRespondWithIdListId), -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
id = (xmlSecXkmsRespondWithId)xmlSecPtrListGetItem(list, i);
if(id != xmlSecXkmsRespondWithIdUnknown) {
ret = xmlSecXkmsRespondWithNodeWrite(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
}
return(0);
}
/********************************************************************
*
* XML Sec Library RespondWith Ids
*
*******************************************************************/
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithKeyNameKlass = {
xmlSecRespondWithKeyName, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeKeyName, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithDefaultNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithKeyNameGetKlass:
*
* The respond with KeyName klass.
*
* Returns respond with KeyName klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithKeyNameGetKlass(void) {
return(&xmlSecXkmsRespondWithKeyNameKlass);
}
static int xmlSecXkmsRespondWithKeyValueNodeRead (xmlSecXkmsRespondWithId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithKeyValueKlass = {
xmlSecRespondWithKeyValue, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeKeyValue, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithKeyValueNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithKeyValueGetKlass:
*
* The respond with KeyValue klass.
*
* Returns respond with KeyValue klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithKeyValueGetKlass(void) {
return(&xmlSecXkmsRespondWithKeyValueKlass);
}
static int
xmlSecXkmsRespondWithKeyValueNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsRespondWithKeyValueId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* do usual stuff */
ret = xmlSecXkmsRespondWithDefaultNodeRead(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithDefaultNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* and now set some parameters in the ctx to look for a public or private
* key and to write a public key
*/
ctx->keyInfoReadCtx.keyReq.keyType |= (xmlSecKeyDataTypePublic | xmlSecKeyDataTypePrivate);
ctx->keyInfoWriteCtx.keyReq.keyType |= xmlSecKeyDataTypePublic;
return(0);
}
static int xmlSecXkmsRespondWithPrivateKeyNodeRead (xmlSecXkmsRespondWithId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithPrivateKeyKlass = {
xmlSecRespondWithPrivateKey, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeKeyValue, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithPrivateKeyNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithPrivateKeyGetKlass:
*
* The respond with PrivateKey klass.
*
* Returns respond with PrivateKey klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithPrivateKeyGetKlass(void) {
return(&xmlSecXkmsRespondWithPrivateKeyKlass);
}
static int
xmlSecXkmsRespondWithPrivateKeyNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsRespondWithPrivateKeyId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* do usual stuff */
ret = xmlSecXkmsRespondWithDefaultNodeRead(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithDefaultNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* and now set some parameters in the ctx to look for a private
* key and to write a private key
*/
ctx->keyInfoReadCtx.keyReq.keyType |= xmlSecKeyDataTypePrivate;
ctx->keyInfoWriteCtx.keyReq.keyType |= xmlSecKeyDataTypePrivate;
return(0);
}
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithRetrievalMethodKlass = {
xmlSecRespondWithRetrievalMethod, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeRetrievalMethod, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithDefaultNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithRetrievalMethodGetKlass:
*
* The respond with RetrievalMethod klass.
*
* Returns respond with RetrievalMethod klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithRetrievalMethodGetKlass(void) {
return(&xmlSecXkmsRespondWithRetrievalMethodKlass);
}
static int xmlSecXkmsRespondWithX509CertNodeRead (xmlSecXkmsRespondWithId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithX509CertKlass = {
xmlSecRespondWithX509Cert, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeX509Data, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithX509CertNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithX509CertGetKlass:
*
* The respond with X509Cert klass.
*
* Returns respond with X509Cert klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithX509CertGetKlass(void) {
return(&xmlSecXkmsRespondWithX509CertKlass);
}
static int
xmlSecXkmsRespondWithX509CertNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsRespondWithX509CertId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* do usual stuff */
ret = xmlSecXkmsRespondWithDefaultNodeRead(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithDefaultNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
static int xmlSecXkmsRespondWithX509ChainNodeRead (xmlSecXkmsRespondWithId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithX509ChainKlass = {
xmlSecRespondWithX509Chain, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeX509Data, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithX509ChainNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithX509ChainGetKlass:
*
* The respond with X509Chain klass.
*
* Returns respond with X509Chain klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithX509ChainGetKlass(void) {
return(&xmlSecXkmsRespondWithX509ChainKlass);
}
static int
xmlSecXkmsRespondWithX509ChainNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsRespondWithX509ChainId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* do usual stuff */
ret = xmlSecXkmsRespondWithDefaultNodeRead(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithDefaultNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
static int xmlSecXkmsRespondWithX509CRLNodeRead (xmlSecXkmsRespondWithId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithX509CRLKlass = {
xmlSecRespondWithX509CRL, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeX509Data, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithX509CRLNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithX509CRLGetKlass:
*
* The respond with X509CRL klass.
*
* Returns respond with X509CRL klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithX509CRLGetKlass(void) {
return(&xmlSecXkmsRespondWithX509CRLKlass);
}
static int
xmlSecXkmsRespondWithX509CRLNodeRead(xmlSecXkmsRespondWithId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsRespondWithX509CRLId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* do usual stuff */
ret = xmlSecXkmsRespondWithDefaultNodeRead(id, ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
xmlSecErrorsSafeString(xmlSecXkmsRespondWithKlassGetName(id)),
"xmlSecXkmsRespondWithDefaultNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithPGPKlass = {
xmlSecRespondWithPGP, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodePGPData, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithDefaultNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithPGPGetKlass:
*
* The respond with PGP klass.
*
* Returns respond with PGP klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithPGPGetKlass(void) {
return(&xmlSecXkmsRespondWithPGPKlass);
}
static xmlSecXkmsRespondWithKlass xmlSecXkmsRespondWithSPKIKlass = {
xmlSecRespondWithSPKI, /* const xmlChar* valueName; */
xmlSecXkmsNs, /* const xmlChar* valueNs; */
xmlSecNodeSPKIData, /* const xmlChar* nodeName; */
xmlSecDSigNs, /* const xmlChar* nodeNs; */
xmlSecXkmsRespondWithDefaultNodeRead, /* xmlSecXkmsRespondWithNodeReadMethod readNode; */
xmlSecXkmsRespondWithDefaultNodeWrite, /* xmlSecXkmsRespondWithNodeWriteMethod writeNode; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsRespondWithSPKIGetKlass:
*
* The respond with SPKI klass.
*
* Returns respond with SPKI klass.
*/
EXPORT_C
xmlSecXkmsRespondWithId
xmlSecXkmsRespondWithSPKIGetKlass(void) {
return(&xmlSecXkmsRespondWithSPKIKlass);
}
/**************************************************************************
*
* Global xmlSecXkmsServerRequestIds list functions
*
*************************************************************************/
static xmlSecPtrList xmlSecAllXkmsServerRequestIds;
/**
* xmlSecXkmsServerRequestIdsGet:
*
* Gets global registered ServerRequest klasses list.
*
* Returns the pointer to list of all registered ServerRequest klasses.
*/
EXPORT_C
xmlSecPtrListPtr
xmlSecXkmsServerRequestIdsGet(void) {
return(&xmlSecAllXkmsServerRequestIds);
}
/**
* xmlSecXkmsServerRequestIdsInit:
*
* Initializes the ServerRequest 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
xmlSecXkmsServerRequestIdsInit(void) {
int ret;
ret = xmlSecPtrListInitialize(xmlSecXkmsServerRequestIdsGet(), xmlSecXkmsServerRequestIdListId);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListPtrInitialize",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"xmlSecXkmsServerRequestIdListId");
return(-1);
}
ret = xmlSecXkmsServerRequestIdsRegisterDefault();
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegisterDefault",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* xmlSecXkmsServerRequestIdsShutdown:
*
* 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
xmlSecXkmsServerRequestIdsShutdown(void) {
xmlSecPtrListFinalize(xmlSecXkmsServerRequestIdsGet());
}
/**
* xmlSecXkmsServerRequestIdsRegister:
* @id: the ServerRequest klass.
*
* Registers @id in the global list of ServerRequest klasses.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestId id) {
int ret;
xmlSecAssert2(id != xmlSecXkmsServerRequestIdUnknown, -1);
ret = xmlSecPtrListAdd(xmlSecXkmsServerRequestIdsGet(), (xmlSecPtr)id);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"ServerRequest=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(id)));
return(-1);
}
return(0);
}
/**
* xmlSecXkmsServerRequestIdsRegisterDefault:
*
* Registers default (implemented by XML Security Library)
* ServerRequest klasses: KeyName, KeyValue,...
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerRequestIdsRegisterDefault(void) {
if(xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestResultId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(xmlSecXkmsServerRequestResultId)));
return(-1);
}
if(xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestStatusId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(xmlSecXkmsServerRequestStatusId)));
return(-1);
}
if(xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestCompoundId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(xmlSecXkmsServerRequestCompoundId)));
return(-1);
}
if(xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestLocateId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(xmlSecXkmsServerRequestLocateId)));
return(-1);
}
if(xmlSecXkmsServerRequestIdsRegister(xmlSecXkmsServerRequestValidateId) < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdsRegister",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"name=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(xmlSecXkmsServerRequestValidateId)));
return(-1);
}
return(0);
}
/************************************************************************
*
* XKMS ServerRequest Klass
*
************************************************************************/
/**
* xmlSecXkmsServerRequestNodeRead:
* @id: the ServerRequest class.
* @ctx: the XKMS request processing context.
* @node: the pointer to <xkms:ServerRequest/> node.
*
* Reads the content of the <xkms:ServerRequest/> @node.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerRequestNodeRead(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node) {
xmlSecAssert2(id != xmlSecXkmsServerRequestIdUnknown, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
if(id->readNode != NULL) {
return((id->readNode)(id, ctx, node));
}
return(0);
}
/**
* xmlSecXkmsServerExecute:
* @id: the ServerRequest class.
* @ctx: the XKMS request processing context.
*
* Executes XKMS server request.
*
* Returns 0 on success or a negative value if an error occurs.
*/
EXPORT_C
int
xmlSecXkmsServerRequestExecute(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx) {
xmlSecAssert2(id != xmlSecXkmsServerRequestIdUnknown, -1);
xmlSecAssert2(ctx != NULL, -1);
if(id->execute != NULL) {
return((id->execute)(id, ctx));
}
return(0);
}
/**
* xmlSecXkmsServerResponseNodeWrite:
* @id: the ServerRequest class.
* @ctx: the XKMS request processing context.
* @doc: the pointer to response parent XML document (might be NULL).
* @node: the pointer to response parent XML node (might be NULL).
*
* Writes XKMS response from context to a newly created node. Caller is
* responsible for adding the returned node to the XML document.
*
* Returns pointer to newly created XKMS response node or NULL
* if an error occurs.
*/
EXPORT_C
xmlNodePtr
xmlSecXkmsServerRequestNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx,
xmlDocPtr doc, xmlNodePtr node) {
xmlNodePtr respNode;
int ret;
xmlSecAssert2(id != xmlSecXkmsServerRequestIdUnknown, NULL);
xmlSecAssert2(ctx != NULL, NULL);
/* create the response root node */
if(node == NULL) {
xmlNsPtr ns;
respNode = xmlNewDocNode(doc, NULL, id->resultNodeName, NULL);
if(respNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlNewDocNode",
XMLSEC_ERRORS_R_XML_FAILED,
"node=%s",
xmlSecErrorsSafeString(id->resultNodeName));
return(NULL);
}
ns = xmlNewNs(respNode, id->resultNodeNs, NULL);
if(ns == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlNewNs",
XMLSEC_ERRORS_R_XML_FAILED,
"ns=%s",
xmlSecErrorsSafeString(id->resultNodeNs));
xmlFreeNode(respNode);
return(NULL);
}
xmlSetNs(respNode, ns);
} else {
respNode = xmlSecAddChild(node, id->resultNodeName, id->resultNodeNs);
if(respNode == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(id->resultNodeName));
return(NULL);
}
}
if(id->writeNode != NULL) {
ret = (id->writeNode)(id, ctx, respNode);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"writeNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(id->resultNodeName));
xmlFreeNode(respNode);
return(NULL);
}
}
return(respNode);
}
/**
* xmlSecXkmsServerRequestDebugDump:
* @id: the ServerRequest class.
* @output: the output file.
*
* Writes debug information about @id into the @output.
*/
EXPORT_C
void
xmlSecXkmsServerRequestDebugDump(xmlSecXkmsServerRequestId id, FILE* output) {
xmlSecAssert(id != xmlSecXkmsServerRequestIdUnknown);
xmlSecAssert(output != NULL);
fprintf(output, "=== ServerRequest: %s\n", xmlSecErrorsSafeString(id->name));
}
/**
* xmlSecXkmsServerRequestDebugXmlDump:
* @id: the ServerRequest class.
* @output: the output file.
*
* Writes debug information about @id into the @output in XML format.
*/
EXPORT_C
void
xmlSecXkmsServerRequestDebugXmlDump(xmlSecXkmsServerRequestId id, FILE* output) {
xmlSecAssert(id != xmlSecXkmsServerRequestIdUnknown);
xmlSecAssert(output != NULL);
fprintf(output, "<ServerRequest>%s</ServerRequest>\n", xmlSecErrorsSafeString(id->name));
}
/************************************************************************
*
* XKMS ServerRequest Klass List
*
************************************************************************/
static xmlSecPtrListKlass xmlSecXkmsServerRequestIdListKlass = {
BAD_CAST "xkms-server-request-ids-list",
NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
NULL, /* xmlSecPtrDestroyItemMethod destroyItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsServerRequestDebugDump, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
(xmlSecPtrDebugDumpItemMethod)xmlSecXkmsServerRequestDebugXmlDump, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
};
EXPORT_C
xmlSecPtrListId
xmlSecXkmsServerRequestIdListGetKlass(void) {
return(&xmlSecXkmsServerRequestIdListKlass);
}
EXPORT_C
int
xmlSecXkmsServerRequestIdListFind(xmlSecPtrListPtr list, xmlSecXkmsServerRequestId id) {
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsServerRequestIdListId), -1);
xmlSecAssert2(id != xmlSecXkmsServerRequestIdUnknown, -1);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
if((xmlSecXkmsServerRequestId)xmlSecPtrListGetItem(list, i) == id) {
return(1);
}
}
return(0);
}
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestIdListFindByName(xmlSecPtrListPtr list, const xmlChar* name) {
xmlSecXkmsServerRequestId id;
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsServerRequestIdListId), xmlSecXkmsServerRequestIdUnknown);
xmlSecAssert2(name != NULL, xmlSecXkmsServerRequestIdUnknown);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
id = (xmlSecXkmsServerRequestId)xmlSecPtrListGetItem(list, i);
if((id != xmlSecXkmsServerRequestIdUnknown) && xmlStrEqual(id->name, name)) {
return(id);
}
}
return(xmlSecXkmsServerRequestIdUnknown);
}
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestIdListFindByNode(xmlSecPtrListPtr list, xmlNodePtr node) {
xmlSecXkmsServerRequestId id;
xmlSecSize i, size;
xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecXkmsServerRequestIdListId), xmlSecXkmsServerRequestIdUnknown);
xmlSecAssert2(node != NULL, xmlSecXkmsServerRequestIdUnknown);
size = xmlSecPtrListGetSize(list);
for(i = 0; i < size; ++i) {
id = (xmlSecXkmsServerRequestId)xmlSecPtrListGetItem(list, i);
if((id != xmlSecXkmsServerRequestIdUnknown) &&
xmlSecCheckNodeName(node, id->requestNodeName, id->requestNodeNs)) {
return(id);
}
}
return(xmlSecXkmsServerRequestIdUnknown);
}
/********************************************************************
*
* XML Sec Library ServerRequest Ids
*
*******************************************************************/
/********************************************************************
*
* Result response
*
*******************************************************************/
static int xmlSecXkmsServerRequestResultNodeWrite (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsServerRequestKlass xmlSecXkmsServerRequestResultKlass = {
xmlSecXkmsServerRequestResultName, /* const xmlChar* name; */
NULL, /* const xmlChar* requestNodeName; */
NULL, /* const xmlChar* requestNodeNs; */
xmlSecNodeResult, /* const xmlChar* responseNodeName; */
xmlSecXkmsNs, /* const xmlChar* responseNodeNs; */
0, /* xmlSecBitMask flags; */
NULL, /* xmlSecXkmsServerRequestNodeReadMethod readNode; */
xmlSecXkmsServerRequestResultNodeWrite, /* xmlSecXkmsServerRequestNodeWriteMethod writeNode; */
NULL, /* xmlSecXkmsServerRequestExecuteMethod execute; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsServerRequestResultGetKlass:
*
* The Result response klass.
*
* Returns Result response klass.
*/
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestResultGetKlass(void) {
return(&xmlSecXkmsServerRequestResultKlass);
}
static int
xmlSecXkmsServerRequestResultNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestResultId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* set missing parameters (if any) */
if(ctx->service == NULL) {
ctx->service = xmlStrdup((ctx->expectedService != NULL) ? ctx->expectedService : BAD_CAST "");
if(ctx->service == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlStrdup",
XMLSEC_ERRORS_R_MALLOC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
/* first write the "parent" type */
ret = xmlSecXkmsServerCtxResultTypeNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResultTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/********************************************************************
*
* StatusRequest/StatusResponse
*
*******************************************************************/
static int xmlSecXkmsServerRequestStatusNodeRead (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestStatusNodeWrite (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static xmlSecXkmsServerRequestKlass xmlSecXkmsServerRequestStatusKlass = {
xmlSecXkmsServerRequestStatusName, /* const xmlChar* name; */
xmlSecNodeStatusRequest, /* const xmlChar* requestNodeName; */
xmlSecXkmsNs, /* const xmlChar* requestNodeNs; */
xmlSecNodeStatusResult, /* const xmlChar* responseNodeName; */
xmlSecXkmsNs, /* const xmlChar* responseNodeNs; */
0, /* xmlSecBitMask flags; */
xmlSecXkmsServerRequestStatusNodeRead, /* xmlSecXkmsServerRequestNodeReadMethod readNode; */
xmlSecXkmsServerRequestStatusNodeWrite, /* xmlSecXkmsServerRequestNodeWriteMethod writeNode; */
NULL, /* xmlSecXkmsServerRequestExecuteMethod execute; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsServerRequestStatusGetKlass:
*
* The StatusRequest klass.
*
* Returns StatusRequest klass.
*/
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestStatusGetKlass(void) {
return(&xmlSecXkmsServerRequestStatusKlass);
}
/**
*
* <xkms:StatusRequest Id Service Nonce? OriginalRequestId? ResponseLimit? ResponseId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
*
* XML Schema:
* <!-- StatusRequest -->
* <element name="StatusRequest" type="xkms:StatusRequestType"/>
* <complexType name="StatusRequestType">
* <complexContent>
* <extension base="xkms:PendingRequestType"/>
* </complexContent>
* </complexType>
* <!-- /StatusRequest -->
*/
static int
xmlSecXkmsServerRequestStatusNodeRead(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestStatusId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = node;
/* first read "parent" type */
ret = xmlSecXkmsServerCtxPendingRequestNodeRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxPendingRequestNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* check that there is nothing after the last node */
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
*
* <xkms:StatusResult Id Service Nonce? ResultMajor ResultMinor? RequestId? Success? Failure? Pending?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:RequestSignatureValue>*
*
* XML Schema:
*
* <!-- StatusResult -->
* <element name="StatusResult" type="xkms:StatusResultType"/>
* <complexType name="StatusResultType">
* <complexContent>
* <extension base="xkms:ResultType">
* <attribute name="Success" type="integer" use="optional"/>
* <attribute name="Failure" type="integer" use="optional"/>
* <attribute name="Pending" type="integer" use="optional"/>
* </extension>
* </complexContent>
* </complexType>
* <!-- /StatusResult --> *
*/
static int
xmlSecXkmsServerRequestStatusNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestStatusId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first write the "parent" type */
ret = xmlSecXkmsServerCtxResultTypeNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResultTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/********************************************************************
*
* CompoundRequest/CompoundResponse
*
*******************************************************************/
static int xmlSecXkmsServerRequestCompoundNodeRead (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestCompoundNodeWrite(xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestCompoundExecute (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx);
static xmlSecXkmsServerRequestKlass xmlSecXkmsServerRequestCompoundKlass = {
xmlSecXkmsServerRequestCompoundName, /* const xmlChar* name; */
xmlSecNodeCompoundRequest, /* const xmlChar* requestNodeName; */
xmlSecXkmsNs, /* const xmlChar* requestNodeNs; */
xmlSecNodeCompoundResult, /* const xmlChar* responseNodeName; */
xmlSecXkmsNs, /* const xmlChar* responseNodeNs; */
0, /* xmlSecBitMask flags; */
xmlSecXkmsServerRequestCompoundNodeRead, /* xmlSecXkmsServerRequestNodeReadMethod readNode; */
xmlSecXkmsServerRequestCompoundNodeWrite, /* xmlSecXkmsServerRequestNodeWriteMethod writeNode; */
xmlSecXkmsServerRequestCompoundExecute, /* xmlSecXkmsServerRequestExecuteMethod execute; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsServerRequestCompoundGetKlass:
*
* The CompoundRequest klass.
*
* Returns CompoundRequest klass.
*/
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestCompoundGetKlass(void) {
return(&xmlSecXkmsServerRequestCompoundKlass);
}
/**
* <xkms:CompoundRequest Id Service Nonce? OriginalRequestId? ResponseLimit?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
* (
* <xkms:LocateRequest>?
* <xkms:ValidateRequest>?
* <xkms:RegisterRequest>?
* <xkms:ReissueRequest>?
* <xkms:RecoverRequest>?
* <xkms:RevokeRequest>?
* )*
*
* XML Schema:
*
* <!-- CompoundRequest -->
* <element name="CompoundRequest" type="xkms:CompoundRequestType"/>
* <complexType name="CompoundRequestType">
* <complexContent>
* <extension base="xkms:RequestAbstractType">
* <choice maxOccurs="unbounded">
* <element ref="xkms:LocateRequest"/>
* <element ref="xkms:ValidateRequest"/>
* <element ref="xkms:RegisterRequest"/>
* <element ref="xkms:ReissueRequest"/>
* <element ref="xkms:RecoverRequest"/>
* <element ref="xkms:RevokeRequest"/>
* </choice>
* </extension>
* </complexContent>
* </complexType>
* <!-- /CompoundRequest -->
*/
static int
xmlSecXkmsServerRequestCompoundNodeRead(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecPtrListPtr serverRequestIdsList;
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestCompoundId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = node;
/* first read "parent" type */
ret = xmlSecXkmsServerCtxRequestAbstractTypeNodeRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestAbstractTypeNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* create list for compound requests */
xmlSecAssert2(ctx->compoundRequestContexts == NULL, -1);
ctx->compoundRequestContexts = xmlSecPtrListCreate(xmlSecXkmsServerCtxPtrListId);
if(ctx->compoundRequestContexts == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* get the list of enabled or all request klasses */
if(xmlSecPtrListGetSize(&(ctx->enabledServerRequestIds)) > 0) {
serverRequestIdsList = &(ctx->enabledServerRequestIds);
} else {
serverRequestIdsList = xmlSecXkmsServerRequestIdsGet();
}
xmlSecAssert2(serverRequestIdsList != NULL, -1);
while(cur != NULL) {
xmlSecXkmsServerCtxPtr ctxChild;
/* create a new context */
ctxChild = xmlSecXkmsServerCtxCreate(ctx->keyInfoReadCtx.keysMngr);
if(ctxChild == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxCreate",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* copy all settings from us */
ret = xmlSecXkmsServerCtxCopyUserPref(ctxChild, ctx);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxCopyUserPref",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxDestroy(ctxChild);
return(-1);
}
/* add it to the list */
ret = xmlSecPtrListAdd(ctx->compoundRequestContexts, ctxChild);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxDestroy(ctxChild);
return(-1);
}
/* and now process request from current node */
ctxChild->requestId = xmlSecXkmsServerRequestIdListFindByNode(serverRequestIdsList, cur);
if((ctxChild->requestId == xmlSecXkmsServerRequestIdUnknown) ||
((ctxChild->requestId->flags & XMLSEC_XKMS_SERVER_REQUEST_KLASS_ALLOWED_IN_COUMPOUND) == 0)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestIdListFindByNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(node->name));
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorMessageNotSupported);
return(-1);
}
ret = xmlSecXkmsServerRequestNodeRead(ctxChild->requestId, ctxChild, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"request=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(ctxChild->requestId)));
xmlSecXkmsServerCtxSetResult(ctxChild, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
}
/* check that there is nothing after the last node */
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:CompoundResult Id Service Nonce? ResultMajor ResultMinor? RequestId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:RequestSignatureValue>*
* (
* <xkms:LocateResult>?
* <xkms:ValidateResult>?
* <xkms:RegisterResult>?
* <xkms:ReissueResult>?
* <xkms:RecoverResult>?
* <xkms:RevokeResult>?
* )*
*
*
* XML Schema:
*
* <!-- CompoundResponse -->
* <element name="CompoundResult" type="xkms:CompoundResultType"/>
* <complexType name="CompoundResultType">
* <complexContent>
* <extension base="xkms:ResultType">
* <choice maxOccurs="unbounded">
* <element ref="xkms:LocateResult"/>
* <element ref="xkms:ValidateResult"/>
* <element ref="xkms:RegisterResult"/>
* <element ref="xkms:ReissueResult"/>
* <element ref="xkms:RecoverResult"/>
* <element ref="xkms:RevokeResult"/>
* </choice>
* </extension>
* </complexContent>
* </complexType>
* <!-- /CompoundResponse -->
*/
static int
xmlSecXkmsServerRequestCompoundNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestCompoundId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* walk thru the list of chilren and pickup first error */
if(ctx->compoundRequestContexts != NULL) {
xmlSecSize pos;
for(pos = 0; pos < xmlSecPtrListGetSize(ctx->compoundRequestContexts); pos++) {
xmlSecXkmsServerCtxPtr ctxChild;
ctxChild = (xmlSecXkmsServerCtxPtr)xmlSecPtrListGetItem(ctx->compoundRequestContexts, pos);
if(ctxChild == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListGetItem",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
if(ctxChild->resultMajor != xmlSecXkmsResultMajorSuccess) {
xmlSecXkmsServerCtxSetResult(ctx, ctxChild->resultMajor, ctxChild->resultMinor);
break;
}
}
}
/* first write the "parent" type */
ret = xmlSecXkmsServerCtxResultTypeNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResultTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* write compound result */
if(ctx->compoundRequestContexts != NULL) {
xmlSecSize pos;
for(pos = 0; pos < xmlSecPtrListGetSize(ctx->compoundRequestContexts); pos++) {
xmlSecXkmsServerCtxPtr ctxChild;
xmlNodePtr cur;
ctxChild = (xmlSecXkmsServerCtxPtr)xmlSecPtrListGetItem(ctx->compoundRequestContexts, pos);
if(ctxChild == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListGetItem",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecXkmsServerRequestNodeWrite(ctxChild->requestId, ctxChild, node->doc, node);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"request=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(ctxChild->requestId)));
return(-1);
}
if(xmlSecAddChildNode(node, cur) == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChildNode",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlFreeNode(cur);
return(-1);
}
}
}
return(0);
}
static int
xmlSecXkmsServerRequestCompoundExecute(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx) {
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestCompoundId, -1);
xmlSecAssert2(ctx != NULL, -1);
if(ctx->compoundRequestContexts != NULL) {
xmlSecSize pos;
for(pos = 0; pos < xmlSecPtrListGetSize(ctx->compoundRequestContexts); pos++) {
xmlSecXkmsServerCtxPtr ctxChild;
ctxChild = (xmlSecXkmsServerCtxPtr)xmlSecPtrListGetItem(ctx->compoundRequestContexts, pos);
if(ctxChild == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListGetItem",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorReceiver, xmlSecXkmsResultMinorFailure);
continue;
}
ret = xmlSecXkmsServerRequestExecute(ctxChild->requestId, ctxChild);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerRequestExecute",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"request=%s",
xmlSecErrorsSafeString(xmlSecXkmsServerRequestKlassGetName(ctxChild->requestId)));
xmlSecXkmsServerCtxSetResult(ctxChild, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorFailure);
continue;
}
}
}
return(0);
}
/********************************************************************
*
* LocateRequest/LocateResponse
*
*******************************************************************/
static int xmlSecXkmsServerRequestLocateNodeRead (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestLocateNodeWrite (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestLocateExecute (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx);
static xmlSecXkmsServerRequestKlass xmlSecXkmsServerRequestLocateKlass = {
xmlSecXkmsServerRequestLocateName, /* const xmlChar* name; */
xmlSecNodeLocateRequest, /* const xmlChar* requestNodeName; */
xmlSecXkmsNs, /* const xmlChar* requestNodeNs; */
xmlSecNodeLocateResult, /* const xmlChar* responseNodeName; */
xmlSecXkmsNs, /* const xmlChar* responseNodeNs; */
XMLSEC_XKMS_SERVER_REQUEST_KLASS_ALLOWED_IN_COUMPOUND, /* xmlSecBitMask flags; */
xmlSecXkmsServerRequestLocateNodeRead, /* xmlSecXkmsServerRequestNodeReadMethod readNode; */
xmlSecXkmsServerRequestLocateNodeWrite, /* xmlSecXkmsServerRequestNodeWriteMethod writeNode; */
xmlSecXkmsServerRequestLocateExecute, /* xmlSecXkmsServerRequestExecuteMethod execute; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsServerRequestLocateGetKlass:
*
* The LocateRequest klass.
*
* Returns LocateRequest klass.
*/
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestLocateGetKlass(void) {
return(&xmlSecXkmsServerRequestLocateKlass);
}
/**
* <xkms:LocateRequest Id Service Nonce? OriginalRequestId? ResponseLimit?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
* <xkms:QueryKeyBinding Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:TimeInstant Time>?
*
* XML Schema:
*
* <!-- LocateRequest -->
* <element name="LocateRequest" type="xkms:LocateRequestType"/>
* <complexType name="LocateRequestType">
* <complexContent>
* <extension base="xkms:RequestAbstractType">
* <sequence>
* <element ref="xkms:QueryKeyBinding"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /LocateRequest -->
*/
static int
xmlSecXkmsServerRequestLocateNodeRead(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestLocateId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = node;
/* first read "parent" type */
ret = xmlSecXkmsServerCtxRequestAbstractTypeNodeRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestAbstractTypeNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* now read required <xkms:QueryKeyBinding/> node */
if((cur == NULL) || (!xmlSecCheckNodeName(cur, xmlSecNodeQueryKeyBinding, xmlSecXkmsNs))) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_INVALID_NODE,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeQueryKeyBinding));
return(-1);
}
/* read <xkms:QueryKeyBinding/> node */
ret = xmlSecXkmsServerCtxQueryKeyBindingNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxQueryKeyBindingNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
/* check that there is nothing after the last node */
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:LocateResult Id Service Nonce? ResultMajor ResultMinor? RequestId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:RequestSignatureValue>*
* (<xkms:UnverifiedKeyBinding Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:ValidityInterval NotBefore NotOnOrAfter>?
* )*
*
* XML Schema:
* <!-- LocateResult -->
* <element name="LocateResult" type="xkms:LocateResultType"/>
* <complexType name="LocateResultType">
* <complexContent>
* <extension base="xkms:ResultType">
* <sequence>
* <element ref="xkms:UnverifiedKeyBinding" minOccurs="0"
* maxOccurs="unbounded"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /LocateResult -->
*/
static int
xmlSecXkmsServerRequestLocateNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecSize pos, size;
xmlSecKeyPtr key;
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestLocateId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first write the "parent" type */
ret = xmlSecXkmsServerCtxResultTypeNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResultTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* write keys in <xkms:UnverifiedKeyBinding> nodes */
size = xmlSecPtrListGetSize(&(ctx->keys));
for(pos = 0; pos < size; ++pos) {
key = (xmlSecKeyPtr)xmlSecPtrListGetItem(&(ctx->keys), pos);
if(key == NULL) {
continue;
}
cur = xmlSecAddChild(node, xmlSecNodeUnverifiedKeyBinding, xmlSecXkmsNs);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeUnverifiedKeyBinding));
return(-1);
}
ret = xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite(ctx, cur, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
return(0);
}
static int
xmlSecXkmsServerRequestLocateExecute(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx) {
xmlSecKeyPtr key = NULL;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestLocateId, -1);
xmlSecAssert2(ctx != NULL, -1);
/* now we are ready to search for key */
if((ctx->keyInfoReadCtx.keysMngr != NULL) && (ctx->keyInfoReadCtx.keysMngr->getKey != NULL)) {
key = (ctx->keyInfoReadCtx.keysMngr->getKey)(ctx->keyInfoNode, &(ctx->keyInfoReadCtx));
}
/* check that we got what we needed */
if((key == NULL) || (!xmlSecKeyMatch(key, NULL, &(ctx->keyInfoReadCtx.keyReq)))) {
if(key != NULL) {
xmlSecKeyDestroy(key);
}
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorNoMatch);
return(-1);
}
xmlSecAssert2(key != NULL, -1);
ret = xmlSecPtrListAdd(&(ctx->keys), key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecKeyDestroy(key);
return(-1);
}
return(0);
}
/********************************************************************
*
* ValidateRequest/ValidateResponse
*
*******************************************************************/
static int xmlSecXkmsServerRequestValidateNodeRead (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestValidateNodeWrite(xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx,
xmlNodePtr node);
static int xmlSecXkmsServerRequestValidateExecute (xmlSecXkmsServerRequestId id,
xmlSecXkmsServerCtxPtr ctx);
static xmlSecXkmsServerRequestKlass xmlSecXkmsServerRequestValidateKlass = {
xmlSecXkmsServerRequestValidateName, /* const xmlChar* name; */
xmlSecNodeValidateRequest, /* const xmlChar* requestNodeName; */
xmlSecXkmsNs, /* const xmlChar* requestNodeNs; */
xmlSecNodeValidateResult, /* const xmlChar* responseNodeName; */
xmlSecXkmsNs, /* const xmlChar* responseNodeNs; */
XMLSEC_XKMS_SERVER_REQUEST_KLASS_ALLOWED_IN_COUMPOUND, /* xmlSecBitMask flags; */
xmlSecXkmsServerRequestValidateNodeRead, /* xmlSecXkmsServerRequestNodeReadMethod readNode; */
xmlSecXkmsServerRequestValidateNodeWrite, /* xmlSecXkmsServerRequestNodeWriteMethod writeNode; */
xmlSecXkmsServerRequestValidateExecute, /* xmlSecXkmsServerRequestExecuteMethod execute; */
NULL, /* void* reserved1; */
NULL /* void* reserved2; */
};
/**
* xmlSecXkmsServerRequestValidateGetKlass:
*
* The ValidateRequest klass.
*
* Returns ValidateRequest klass.
*/
EXPORT_C
xmlSecXkmsServerRequestId
xmlSecXkmsServerRequestValidateGetKlass(void) {
return(&xmlSecXkmsServerRequestValidateKlass);
}
/**
* <xkms:ValidateRequest Id Service Nonce? OriginalRequestId? ResponseLimit?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:ResponseMechanism>*
* <xkms:RespondWith>*
* <xkms:PendingNotification Mechanism Identifier>?
* <xkms:QueryKeyBinding Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:TimeInstant Time>?
*
* XML Schema:
*
* <!-- ValidateRequest -->
* <element name="ValidateRequest" type="xkms:ValidateRequestType"/>
* <complexType name="ValidateRequestType">
* <complexContent>
* <extension base="xkms:RequestAbstractType">
* <sequence>
* <element ref="xkms:QueryKeyBinding"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /ValidateRequest -->
*/
static int
xmlSecXkmsServerRequestValidateNodeRead(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestValidateId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
cur = node;
/* first read "parent" type */
ret = xmlSecXkmsServerCtxRequestAbstractTypeNodeRead(ctx, &cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxRequestAbstractTypeNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* now read required <xkms:QueryKeyBinding/> node */
if((cur == NULL) || (!xmlSecCheckNodeName(cur, xmlSecNodeQueryKeyBinding, xmlSecXkmsNs))) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_INVALID_NODE,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeQueryKeyBinding));
return(-1);
}
/* read <xkms:QueryKeyBinding/> node */
ret = xmlSecXkmsServerCtxQueryKeyBindingNodeRead(ctx, cur);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxQueryKeyBindingNodeRead",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
cur = xmlSecGetNextElementNode(cur->next);
/* check that there is nothing after the last node */
if(cur != NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
XMLSEC_ERRORS_R_UNEXPECTED_NODE,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
return(0);
}
/**
* <xkms:ValidateResult Id Service Nonce? ResultMajor ResultMinor? RequestId?>
* <ds:Signature>?
* <xkms:MessageExtension>*
* (<xkms:OpaqueClientData>
* <xkms:OpaqueData>?
* )?
* <xkms:RequestSignatureValue>*
* (<xkms:KeyBinding Id?>
* <ds:KeyInfo>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:KeyUsage>?
* <xkms:UseKeyWith Application Identifier>*
* <xkms:ValidityInterval NotBefore NotOnOrAfter>?
* <xkms:Status StatusValue>
* (<xkms:ValidReason>?
* <xkms:IndeterminateReason>?
* <xkms:InvalidReason>?
* )*
* )*
*
* XML Schema:
*
* <!-- ValidateResult -->
* <element name="ValidateResult" type="xkms:ValidateResultType"/>
* <complexType name="ValidateResultType">
* <complexContent>
* <extension base="xkms:ResultType">
* <sequence>
* <element ref="xkms:KeyBinding" minOccurs="0"
* maxOccurs="unbounded"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* <!-- /ValidateResult -->
*/
static int
xmlSecXkmsServerRequestValidateNodeWrite(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx, xmlNodePtr node) {
xmlSecSize pos, size;
xmlSecKeyPtr key;
xmlNodePtr cur;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestValidateId, -1);
xmlSecAssert2(ctx != NULL, -1);
xmlSecAssert2(node != NULL, -1);
/* first write the "parent" type */
ret = xmlSecXkmsServerCtxResultTypeNodeWrite(ctx, node);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxResultTypeNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
/* write keys in <xkms:UnverifiedKeyBinding> nodes */
size = xmlSecPtrListGetSize(&(ctx->keys));
for(pos = 0; pos < size; ++pos) {
key = (xmlSecKeyPtr)xmlSecPtrListGetItem(&(ctx->keys), pos);
if(key == NULL) {
continue;
}
cur = xmlSecAddChild(node, xmlSecNodeUnverifiedKeyBinding, xmlSecXkmsNs);
if(cur == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecAddChild",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
"node=%s",
xmlSecErrorsSafeString(xmlSecNodeUnverifiedKeyBinding));
return(-1);
}
ret = xmlSecXkmsServerCtxKeyBindingNodeWrite(ctx, cur, key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecXkmsServerCtxKeyBindingNodeWrite",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
return(-1);
}
}
return(0);
}
static int
xmlSecXkmsServerRequestValidateExecute(xmlSecXkmsServerRequestId id, xmlSecXkmsServerCtxPtr ctx) {
xmlSecKeyPtr key = NULL;
int ret;
xmlSecAssert2(id == xmlSecXkmsServerRequestValidateId, -1);
xmlSecAssert2(ctx != NULL, -1);
/* now we are ready to search for key */
if((ctx->keyInfoReadCtx.keysMngr != NULL) && (ctx->keyInfoReadCtx.keysMngr->getKey != NULL)) {
key = (ctx->keyInfoReadCtx.keysMngr->getKey)(ctx->keyInfoNode, &(ctx->keyInfoReadCtx));
}
/* check that we got what we needed */
if((key == NULL) || (!xmlSecKeyMatch(key, NULL, &(ctx->keyInfoReadCtx.keyReq)))) {
if(key != NULL) {
xmlSecKeyDestroy(key);
}
xmlSecXkmsServerCtxSetResult(ctx, xmlSecXkmsResultMajorSender, xmlSecXkmsResultMinorNoMatch);
return(-1);
}
xmlSecAssert2(key != NULL, -1);
ret = xmlSecPtrListAdd(&(ctx->keys), key);
if(ret < 0) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"xmlSecPtrListAdd",
XMLSEC_ERRORS_R_XMLSEC_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
xmlSecKeyDestroy(key);
return(-1);
}
return(0);
}
#endif /* XMLSEC_NO_XKMS */