xmlsec-shim 1.2.18.1

data/vendor/xmlsec1-1.2.18/include/xmlsec/xmldsig.h

@@ -0,0 +1,281 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * "XML Digital Signature" implementation
+ *  http://www.w3.org/TR/xmldsig-core/
+ *  http://www.w3.org/Signature/Overview.html
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_XMLDSIG_H__
+#define __XMLSEC_XMLDSIG_H__
+
+#ifndef XMLSEC_NO_XMLDSIG
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/list.h>
+#include <xmlsec/buffer.h>
+#include <xmlsec/keys.h>
+#include <xmlsec/keysmngr.h>
+#include <xmlsec/keyinfo.h>
+#include <xmlsec/transforms.h>
+
+typedef struct _xmlSecDSigReferenceCtx          xmlSecDSigReferenceCtx,
+                                                *xmlSecDSigReferenceCtxPtr;
+
+/**
+ * xmlSecDSigStatus:
+ * @xmlSecDSigStatusUnknown:    the status is unknow.
+ * @xmlSecDSigStatusSucceeded:  the processing succeeded.
+ * @xmlSecDSigStatusInvalid:    the processing failed.
+ *
+ * XML Digital signature processing status.
+ */
+typedef enum {
+    xmlSecDSigStatusUnknown = 0,
+    xmlSecDSigStatusSucceeded,
+    xmlSecDSigStatusInvalid
+} xmlSecDSigStatus;
+
+/**************************************************************************
+ *
+ * xmlSecDSigCtx
+ *
+ *************************************************************************/
+
+/**
+ * XMLSEC_DSIG_FLAGS_IGNORE_MANIFESTS:
+ *
+ * If this flag is set then <dsig:Manifests/> nodes will not be processed.
+ */
+#define XMLSEC_DSIG_FLAGS_IGNORE_MANIFESTS                      0x00000001
+
+/**
+ * XMLSEC_DSIG_FLAGS_STORE_SIGNEDINFO_REFERENCES:
+ *
+ * If this flag is set then pre-digest buffer for <dsig:Reference/> child
+ * of <dsig:KeyInfo/> element will be stored in #xmlSecDSigCtx.
+ */
+#define XMLSEC_DSIG_FLAGS_STORE_SIGNEDINFO_REFERENCES           0x00000002
+
+/**
+ * XMLSEC_DSIG_FLAGS_STORE_MANIFEST_REFERENCES:
+ *
+ * If this flag is set then pre-digest buffer for <dsig:Reference/> child
+ * of <dsig:Manifest/> element will be stored in #xmlSecDSigCtx.
+ */
+#define XMLSEC_DSIG_FLAGS_STORE_MANIFEST_REFERENCES             0x00000004
+
+/**
+ * XMLSEC_DSIG_FLAGS_STORE_SIGNATURE:
+ *
+ * If this flag is set then pre-signature buffer for <dsig:SignedInfo/>
+ * element processing will be stored in #xmlSecDSigCtx.
+ */
+#define XMLSEC_DSIG_FLAGS_STORE_SIGNATURE                       0x00000008
+
+/**
+ * XMLSEC_DSIG_FLAGS_USE_VISA3D_HACK:
+ *
+ * If this flag is set then URI ID references are resolved directly
+ * without using XPointers. This allows one to sign/verify Visa3D
+ * documents that don't follow XML, XPointer and XML DSig specifications.
+ */
+#define XMLSEC_DSIG_FLAGS_USE_VISA3D_HACK                       0x00000010
+
+/**
+ * xmlSecDSigCtx:
+ * @userData:                   the pointer to user data (xmlsec and xmlsec-crypto libraries
+ *                              never touches this).
+ * @flags:                      the XML Digital Signature processing flags.
+ * @flags2:                     the XML Digital Signature processing flags.
+ * @keyInfoReadCtx:             the reading key context.
+ * @keyInfoWriteCtx:            the writing key context (not used for signature verification).
+ * @transformCtx:               the <dsig:SignedInfo/> node processing context.
+ * @enabledReferenceUris:       the URI types allowed for <dsig:Reference/> node.
+ * @enabledReferenceTransforms: the list of transforms allowed in <dsig:Reference/> node.
+ * @referencePreExecuteCallback:the callback for <dsig:Reference/> node processing.
+ * @defSignMethodId:            the default signing method klass.
+ * @defC14NMethodId:            the default c14n method klass.
+ * @defDigestMethodId:          the default digest method klass.
+ * @signKey:                    the signature key; application may set #signKey
+ *                              before calling #xmlSecDSigCtxSign or #xmlSecDSigCtxVerify
+ *                              functions.
+ * @operation:                  the operation: sign or verify.
+ * @result:                     the pointer to signature (not valid for signature verificaction).
+ * @status:                     the <dsig:Signatuire/> procesisng status.
+ * @signMethod:                 the pointer to signature transform.
+ * @c14nMethod:                 the pointer to c14n transform.
+ * @preSignMemBufMethod:        the pointer to binary buffer right before signature
+ *                              (valid only if #XMLSEC_DSIG_FLAGS_STORE_SIGNATURE flag is set).
+ * @signValueNode:              the pointer to <dsig:SignatureValue/> node.
+ * @id:                         the pointer to Id attribute of <dsig:Signature/> node.
+ * @signedInfoReferences:       the list of references in <dsig:SignedInfo/> node.
+ * @manifestReferences:         the list of references in <dsig:Manifest/> nodes.
+ * @reserved0:                  reserved for the future.
+ * @reserved1:                  reserved for the future.
+ *
+ * XML DSig processing context.
+ */
+struct _xmlSecDSigCtx {
+    /* these data user can set before performing the operation */
+    void*                       userData;
+    unsigned int                flags;
+    unsigned int                flags2;
+    xmlSecKeyInfoCtx            keyInfoReadCtx;
+    xmlSecKeyInfoCtx            keyInfoWriteCtx;
+    xmlSecTransformCtx          transformCtx;
+    xmlSecTransformUriType      enabledReferenceUris;
+    xmlSecPtrListPtr            enabledReferenceTransforms;
+    xmlSecTransformCtxPreExecuteCallback referencePreExecuteCallback;
+    xmlSecTransformId           defSignMethodId;
+    xmlSecTransformId           defC14NMethodId;
+    xmlSecTransformId           defDigestMethodId;
+
+    /* these data are returned */
+    xmlSecKeyPtr                signKey;
+    xmlSecTransformOperation    operation;
+    xmlSecBufferPtr             result;
+    xmlSecDSigStatus            status;
+    xmlSecTransformPtr          signMethod;
+    xmlSecTransformPtr          c14nMethod;
+    xmlSecTransformPtr          preSignMemBufMethod;
+    xmlNodePtr                  signValueNode;
+    xmlChar*                    id;
+    xmlSecPtrList               signedInfoReferences;
+    xmlSecPtrList               manifestReferences;
+
+    /* reserved for future */
+    void*                       reserved0;
+    void*                       reserved1;
+};
+
+/* constructor/destructor */
+XMLSEC_EXPORT xmlSecDSigCtxPtr  xmlSecDSigCtxCreate             (xmlSecKeysMngrPtr keysMngr);
+XMLSEC_EXPORT void              xmlSecDSigCtxDestroy            (xmlSecDSigCtxPtr dsigCtx);
+XMLSEC_EXPORT int               xmlSecDSigCtxInitialize         (xmlSecDSigCtxPtr dsigCtx,
+                                                                 xmlSecKeysMngrPtr keysMngr);
+XMLSEC_EXPORT void              xmlSecDSigCtxFinalize           (xmlSecDSigCtxPtr dsigCtx);
+XMLSEC_EXPORT int               xmlSecDSigCtxSign               (xmlSecDSigCtxPtr dsigCtx,
+                                                                 xmlNodePtr tmpl);
+XMLSEC_EXPORT int               xmlSecDSigCtxVerify             (xmlSecDSigCtxPtr dsigCtx,
+                                                                 xmlNodePtr node);
+XMLSEC_EXPORT int               xmlSecDSigCtxEnableReferenceTransform(xmlSecDSigCtxPtr dsigCtx,
+                                                                xmlSecTransformId transformId);
+XMLSEC_EXPORT int               xmlSecDSigCtxEnableSignatureTransform(xmlSecDSigCtxPtr dsigCtx,
+                                                                xmlSecTransformId transformId);
+XMLSEC_EXPORT xmlSecBufferPtr   xmlSecDSigCtxGetPreSignBuffer   (xmlSecDSigCtxPtr dsigCtx);
+XMLSEC_EXPORT void              xmlSecDSigCtxDebugDump          (xmlSecDSigCtxPtr dsigCtx,
+                                                                 FILE* output);
+XMLSEC_EXPORT void              xmlSecDSigCtxDebugXmlDump       (xmlSecDSigCtxPtr dsigCtx,
+                                                                 FILE* output);
+
+
+/**************************************************************************
+ *
+ * xmlSecDSigReferenceCtx
+ *
+ *************************************************************************/
+/**
+ * xmlSecDSigReferenceOrigin:
+ * @xmlSecDSigReferenceOriginSignedInfo:reference in <dsig:SignedInfo> node.
+ * @xmlSecDSigReferenceOriginManifest:  reference <dsig:Manifest> node.
+ *
+ * The possible <dsig:Reference/> node locations: in the <dsig:SignedInfo/>
+ * node or in the <dsig:Manifest/> node.
+ */
+typedef enum  {
+    xmlSecDSigReferenceOriginSignedInfo,
+    xmlSecDSigReferenceOriginManifest
+} xmlSecDSigReferenceOrigin;
+
+/**
+ * xmlSecDSigReferenceCtx:
+ * @userData:                   the pointer to user data (xmlsec and xmlsec-crypto libraries
+ *                              never touches this).
+ * @dsigCtx:                    the pointer to "parent" <dsig:Signature/> processing context.
+ * @origin:                     the signature origin (<dsig:SignedInfo/> or <dsig:Manifest/>).
+ * @transformCtx:               the reference processing transforms context.
+ * @digestMethod:               the pointer to digest transform.
+ * @result:                     the pointer to digest result.
+ * @status:                     the reference processing status.
+ * @preDigestMemBufMethod:      the pointer to binary buffer right before digest
+ *                              (valid only if either
+ *                              #XMLSEC_DSIG_FLAGS_STORE_SIGNEDINFO_REFERENCES or
+ *                              #XMLSEC_DSIG_FLAGS_STORE_MANIFEST_REFERENCES flags are set).
+ * @id:                         the <dsig:Reference/> node ID attribute.
+ * @uri:                        the <dsig:Reference/> node URI attribute.
+ * @type:                       the <dsig:Reference/> node Type attribute.
+ * @reserved0:                  reserved for the future.
+ * @reserved1:                  reserved for the future.
+ *
+ * The <dsig:Reference/> processing context.
+ */
+struct _xmlSecDSigReferenceCtx {
+    void*                       userData;
+    xmlSecDSigCtxPtr            dsigCtx;
+    xmlSecDSigReferenceOrigin   origin;
+    xmlSecTransformCtx          transformCtx;
+    xmlSecTransformPtr          digestMethod;
+
+    xmlSecBufferPtr             result;
+    xmlSecDSigStatus            status;
+    xmlSecTransformPtr          preDigestMemBufMethod;
+    xmlChar*                    id;
+    xmlChar*                    uri;
+    xmlChar*                    type;
+
+     /* reserved for future */
+    void*                       reserved0;
+    void*                       reserved1;
+};
+
+XMLSEC_EXPORT xmlSecDSigReferenceCtxPtr xmlSecDSigReferenceCtxCreate(xmlSecDSigCtxPtr dsigCtx,
+                                                                xmlSecDSigReferenceOrigin origin);
+XMLSEC_EXPORT void              xmlSecDSigReferenceCtxDestroy   (xmlSecDSigReferenceCtxPtr dsigRefCtx);
+XMLSEC_EXPORT int               xmlSecDSigReferenceCtxInitialize(xmlSecDSigReferenceCtxPtr dsigRefCtx,
+                                                                xmlSecDSigCtxPtr dsigCtx,
+                                                                xmlSecDSigReferenceOrigin origin);
+XMLSEC_EXPORT void              xmlSecDSigReferenceCtxFinalize  (xmlSecDSigReferenceCtxPtr dsigRefCtx);
+XMLSEC_EXPORT int               xmlSecDSigReferenceCtxProcessNode(xmlSecDSigReferenceCtxPtr dsigRefCtx,
+                                                                  xmlNodePtr node);
+XMLSEC_EXPORT xmlSecBufferPtr   xmlSecDSigReferenceCtxGetPreDigestBuffer
+                                                                (xmlSecDSigReferenceCtxPtr dsigRefCtx);
+XMLSEC_EXPORT void              xmlSecDSigReferenceCtxDebugDump (xmlSecDSigReferenceCtxPtr dsigRefCtx,
+                                                                 FILE* output);
+XMLSEC_EXPORT void              xmlSecDSigReferenceCtxDebugXmlDump(xmlSecDSigReferenceCtxPtr dsigRefCtx,
+                                                                 FILE* output);
+
+/**************************************************************************
+ *
+ * xmlSecDSigReferenceCtxListKlass
+ *
+ *************************************************************************/
+/**
+ * xmlSecDSigReferenceCtxListId:
+ *
+ * The references list klass.
+ */
+#define xmlSecDSigReferenceCtxListId \
+        xmlSecDSigReferenceCtxListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecDSigReferenceCtxListGetKlass(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* XMLSEC_NO_XMLDSIG */
+
+#endif /* __XMLSEC_XMLDSIG_H__ */
+

data/vendor/xmlsec1-1.2.18/include/xmlsec/xmlenc.h

@@ -0,0 +1,163 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * "XML Encryption" implementation
+ *  http://www.w3.org/TR/xmlenc-core
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_XMLENC_H__
+#define __XMLSEC_XMLENC_H__
+
+#ifndef XMLSEC_NO_XMLENC
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#include <stdio.h>
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
+#include <xmlsec/keys.h>
+#include <xmlsec/keysmngr.h>
+#include <xmlsec/keyinfo.h>
+#include <xmlsec/transforms.h>
+
+/**
+ * xmlEncCtxMode:
+ * @xmlEncCtxModeEncryptedData: the <enc:EncryptedData/> element procesing.
+ * @xmlEncCtxModeEncryptedKey:  the <enc:EncryptedKey/> element processing.
+ *
+ * The #xmlSecEncCtx mode.
+ */
+typedef enum {
+    xmlEncCtxModeEncryptedData = 0,
+    xmlEncCtxModeEncryptedKey
+} xmlEncCtxMode;
+
+
+/**
+ * XMLSEC_ENC_RETURN_REPLACED_NODE:
+ *
+ * If this flag is set, then the replaced node will be returned in the replacedNodeList
+ */
+#define XMLSEC_ENC_RETURN_REPLACED_NODE                 0x00000001
+
+/**
+ * xmlSecEncCtx:
+ * @userData:                   the pointer to user data (xmlsec and xmlsec-crypto libraries
+ *                              never touches this).
+ * @flags:                      the XML Encryption processing flags.
+ * @flags2:                     the XML Encryption processing flags.
+ * @mode:                       the mode.
+ * @keyInfoReadCtx:             the reading key context.
+ * @keyInfoWriteCtx:            the writing key context (not used for signature verification).
+ * @transformCtx:               the transforms processing context.
+ * @defEncMethodId:             the default encryption method (used if
+ *                              <enc:EncryptionMethod/> node is not present).
+ * @encKey:                     the signature key; application may set #encKey
+ *                              before calling encryption/decryption functions.
+ * @operation:                  the operation: encrypt or decrypt.
+ * @result:                     the pointer to signature (not valid for signature verificaction).
+ * @resultBase64Encoded:        the flag: if set then result in #result is base64 encoded.
+ * @resultReplaced:             the flag: if set then resulted <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node is added to the document.
+ * @encMethod:                  the pointer to encryption transform.
+ * @replacedNodeList: the first node of the list of replaced nodes depending on the nodeReplacementMode
+ * @id:                         the ID attribute of <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node.
+ * @type:                       the Type attribute of <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node.
+ * @mimeType:                   the MimeType attribute of <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node.
+ * @encoding:                   the Encoding attributeof <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node.
+ * @recipient:                  the Recipient attribute of <enc:EncryptedKey/> node..
+ * @carriedKeyName:             the CarriedKeyName attribute of <enc:EncryptedKey/> node.
+ * @encDataNode:                the pointer to <enc:EncryptedData/>
+ *                              or <enc:EncryptedKey/> node.
+ * @encMethodNode:              the pointer to <enc:EncryptionMethod/> node.
+ * @keyInfoNode:                the pointer to <enc:KeyInfo/> node.
+ * @cipherValueNode:            the pointer to <enc:CipherValue/> node.
+ * @reserved1:                  reserved for the future.
+ *
+ * XML Encrypiton context.
+ */
+struct _xmlSecEncCtx {
+    /* these data user can set before performing the operation */
+    void*                       userData;
+    unsigned int                flags;
+    unsigned int                flags2;
+    xmlEncCtxMode               mode;
+    xmlSecKeyInfoCtx            keyInfoReadCtx;
+    xmlSecKeyInfoCtx            keyInfoWriteCtx;
+    xmlSecTransformCtx          transformCtx;
+    xmlSecTransformId           defEncMethodId;
+
+    /* these data are returned */
+    xmlSecKeyPtr                encKey;
+    xmlSecTransformOperation    operation;
+    xmlSecBufferPtr             result;
+    int                         resultBase64Encoded;
+    int                         resultReplaced;
+    xmlSecTransformPtr          encMethod;
+
+    /* attributes from EncryptedData or EncryptedKey */
+    xmlChar*                    id;
+    xmlChar*                    type;
+    xmlChar*                    mimeType;
+    xmlChar*                    encoding;
+    xmlChar*                    recipient;
+    xmlChar*                    carriedKeyName;
+
+    /* these are internal data, nobody should change that except us */
+    xmlNodePtr                  encDataNode;
+    xmlNodePtr                  encMethodNode;
+    xmlNodePtr                  keyInfoNode;
+    xmlNodePtr                  cipherValueNode;
+
+    xmlNodePtr                  replacedNodeList; /* the pointer to the replaced node */
+    void*                       reserved1;        /* reserved for future */
+};
+
+XMLSEC_EXPORT xmlSecEncCtxPtr   xmlSecEncCtxCreate              (xmlSecKeysMngrPtr keysMngr);
+XMLSEC_EXPORT void              xmlSecEncCtxDestroy             (xmlSecEncCtxPtr encCtx);
+XMLSEC_EXPORT int               xmlSecEncCtxInitialize          (xmlSecEncCtxPtr encCtx,
+                                                                 xmlSecKeysMngrPtr keysMngr);
+XMLSEC_EXPORT void              xmlSecEncCtxFinalize            (xmlSecEncCtxPtr encCtx);
+XMLSEC_EXPORT int               xmlSecEncCtxCopyUserPref        (xmlSecEncCtxPtr dst,
+                                                                 xmlSecEncCtxPtr src);
+XMLSEC_EXPORT void              xmlSecEncCtxReset               (xmlSecEncCtxPtr encCtx);
+XMLSEC_EXPORT int               xmlSecEncCtxBinaryEncrypt       (xmlSecEncCtxPtr encCtx,
+                                                                 xmlNodePtr tmpl,
+                                                                 const xmlSecByte* data,
+                                                                 xmlSecSize dataSize);
+XMLSEC_EXPORT int               xmlSecEncCtxXmlEncrypt          (xmlSecEncCtxPtr encCtx,
+                                                                 xmlNodePtr tmpl,
+                                                                 xmlNodePtr node);
+XMLSEC_EXPORT int               xmlSecEncCtxUriEncrypt          (xmlSecEncCtxPtr encCtx,
+                                                                 xmlNodePtr tmpl,
+                                                                 const xmlChar *uri);
+XMLSEC_EXPORT int               xmlSecEncCtxDecrypt             (xmlSecEncCtxPtr encCtx,
+                                                                 xmlNodePtr node);
+XMLSEC_EXPORT xmlSecBufferPtr   xmlSecEncCtxDecryptToBuffer     (xmlSecEncCtxPtr encCtx,
+                                                                 xmlNodePtr node                );
+XMLSEC_EXPORT void              xmlSecEncCtxDebugDump           (xmlSecEncCtxPtr encCtx,
+                                                                 FILE* output);
+XMLSEC_EXPORT void              xmlSecEncCtxDebugXmlDump        (xmlSecEncCtxPtr encCtx,
+                                                                 FILE* output);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* XMLSEC_NO_XMLENC */
+
+#endif /* __XMLSEC_XMLENC_H__ */
+

data/vendor/xmlsec1-1.2.18/include/xmlsec/xmlsec.h

@@ -0,0 +1,216 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * General functions and forward declarations.
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_H__
+#define __XMLSEC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libxml/tree.h>
+
+#include <xmlsec/version.h>
+#include <xmlsec/exports.h>
+#include <xmlsec/strings.h>
+
+/***********************************************************************
+ *
+ * Basic types to make ports to exotic platforms easier
+ *
+ ***********************************************************************/
+/**
+ * xmlSecPtr:
+ *
+ * Void pointer.
+ */
+typedef void*                                   xmlSecPtr;
+
+/**
+ * xmlSecSize:
+ *
+ * Size of something. Should be typedef instead of define
+ * but it will break ABI (todo).
+ */
+#ifdef XMLSEC_NO_SIZE_T
+#define xmlSecSize                              unsigned int
+#else  /* XMLSEC_NO_SIZE_T */
+#define xmlSecSize                              size_t
+#endif /* XMLSEC_NO_SIZE_T */
+
+/**
+ * XMLSEC_SIZE_BAD_CAST:
+ * @val:        the value to cast
+ *
+ * Bad cast to xmlSecSize
+ */
+#define XMLSEC_SIZE_BAD_CAST(val)               ((xmlSecSize)(val))
+
+/**
+ * xmlSecByte:
+ *
+ * One byte. Should be typedef instead of define
+ * but it will break ABI (todo).
+ */
+#define xmlSecByte                              unsigned char
+
+/***********************************************************************
+ *
+ * Forward declarations
+ *
+ ***********************************************************************/
+typedef struct _xmlSecKeyData                   xmlSecKeyData, *xmlSecKeyDataPtr;
+typedef struct _xmlSecKeyDataStore              xmlSecKeyDataStore, *xmlSecKeyDataStorePtr;
+typedef struct _xmlSecKeyInfoCtx                xmlSecKeyInfoCtx, *xmlSecKeyInfoCtxPtr;
+typedef struct _xmlSecKey                       xmlSecKey, *xmlSecKeyPtr;
+typedef struct _xmlSecKeyStore                  xmlSecKeyStore, *xmlSecKeyStorePtr;
+typedef struct _xmlSecKeysMngr                  xmlSecKeysMngr, *xmlSecKeysMngrPtr;
+typedef struct _xmlSecTransform                 xmlSecTransform, *xmlSecTransformPtr;
+typedef struct _xmlSecTransformCtx              xmlSecTransformCtx, *xmlSecTransformCtxPtr;
+
+#ifndef XMLSEC_NO_XMLDSIG
+typedef struct _xmlSecDSigCtx                   xmlSecDSigCtx, *xmlSecDSigCtxPtr;
+#endif /* XMLSEC_NO_XMLDSIG */
+
+#ifndef XMLSEC_NO_XMLENC
+typedef struct _xmlSecEncCtx                    xmlSecEncCtx, *xmlSecEncCtxPtr;
+#endif /* XMLSEC_NO_XMLENC */
+
+#ifndef XMLSEC_NO_XKMS
+typedef struct _xmlSecXkmsServerCtx             xmlSecXkmsServerCtx, *xmlSecXkmsServerCtxPtr;
+#endif /* XMLSEC_NO_XKMS */
+
+XMLSEC_EXPORT int       xmlSecInit              (void);
+XMLSEC_EXPORT int       xmlSecShutdown          (void);
+
+
+
+/***********************************************************************
+ *
+ * Version checking
+ *
+ ***********************************************************************/
+/**
+ * xmlSecCheckVersionExact:
+ *
+ * Macro. Returns 1 if the loaded xmlsec library version exactly matches
+ * the one used to compile the caller, 0 if it does not or a negative
+ * value if an error occurs.
+ */
+#define xmlSecCheckVersionExact()       \
+    xmlSecCheckVersionExt(XMLSEC_VERSION_MAJOR, XMLSEC_VERSION_MINOR, XMLSEC_VERSION_SUBMINOR, xmlSecCheckVersionExactMatch)
+
+/**
+ * xmlSecCheckVersion:
+ *
+ * Macro. Returns 1 if the loaded xmlsec library version ABI compatible with
+ * the one used to compile the caller, 0 if it does not or a negative
+ * value if an error occurs.
+ */
+#define xmlSecCheckVersion()    \
+    xmlSecCheckVersionExt(XMLSEC_VERSION_MAJOR, XMLSEC_VERSION_MINOR, XMLSEC_VERSION_SUBMINOR, xmlSecCheckVersionABICompatible)
+
+/**
+ * xmlSecCheckVersionMode:
+ * @xmlSecCheckVersionExactMatch:       the version should match exactly.
+ * @xmlSecCheckVersionABICompatible:    the version should be ABI compatible.
+ *
+ * The xmlsec library version mode.
+ */
+typedef enum {
+    xmlSecCheckVersionExactMatch = 0,
+    xmlSecCheckVersionABICompatible
+} xmlSecCheckVersionMode;
+
+XMLSEC_EXPORT int       xmlSecCheckVersionExt   (int major,
+                                                 int minor,
+                                                 int subminor,
+                                                 xmlSecCheckVersionMode mode);
+
+/**
+ * ATTRIBUTE_UNUSED:
+ *
+ * Macro used to signal to GCC unused function parameters
+ */
+#ifdef __GNUC__
+#ifdef HAVE_ANSIDECL_H
+#include <ansidecl.h>
+#endif
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED
+#endif
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+
+/***********************************************************************
+ *
+ * Helpers to convert from void* to function pointer, this silence
+ * gcc warning
+ *
+ *     warning: ISO C forbids conversion of object pointer to function
+ *     pointer type
+ *
+ * The workaround is to declare a union that does the conversion. This is
+ * guaranteed (ISO/IEC 9899:1990 "C89"/"C90") to match exactly.
+ *
+ ***********************************************************************/
+
+/**
+ * XMLSEC_PTR_TO_FUNC_IMPL:
+ * @func_type:          the function type.
+ *
+ * Macro declares helper functions to convert between "void *" pointer and
+ * function pointer.
+ */
+#define XMLSEC_PTR_TO_FUNC_IMPL(func_type) \
+    union xmlSecPtrToFuncUnion_ ##func_type { \
+        void *ptr; \
+        func_type * func; \
+    } ; \
+    static func_type * xmlSecPtrToFunc_ ##func_type(void * ptr) { \
+         union xmlSecPtrToFuncUnion_ ##func_type x; \
+         x.ptr = ptr; \
+         return (x.func); \
+    } \
+    static void * xmlSecFuncToPtr_ ##func_type(func_type * func) { \
+         union xmlSecPtrToFuncUnion_ ##func_type x; \
+         x.func = func; \
+         return (x.ptr); \
+    }
+
+/**
+ * XMLSEC_PTR_TO_FUNC:
+ * @func_type:          the function type.
+ * @ptr:                the "void*" pointer to be converted.
+ *
+ * Macro converts from "void*" pointer to "func_type" function pointer.
+ */
+#define XMLSEC_PTR_TO_FUNC(func_type, ptr) \
+    xmlSecPtrToFunc_ ##func_type((ptr))
+
+/**
+ * XMLSEC_FUNC_TO_PTR:
+ * @func_type:          the function type.
+ * @func:               the "func_type" function pointer to be converted.
+ *
+ * Macro converts from "func_type" function pointer to "void*" pointer.
+ */
+#define XMLSEC_FUNC_TO_PTR(func_type, func) \
+    xmlSecFuncToPtr_ ##func_type((func))
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XMLSEC_H__ */
+
+