/** * XML Security Library (http://www.aleksey.com/xmlsec). * * Key data. * * This is free software; see Copyright file in the source * distribution for preciese wording. * * Copyright (C) 2002-2003 Aleksey Sanin */ #ifndef __XMLSEC_KEYSDATA_H__ #define __XMLSEC_KEYSDATA_H__ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #include #include #include #include /**************************************************************************** * * Forward declarations * ****************************************************************************/ typedef const struct _xmlSecKeyDataKlass xmlSecKeyDataKlass, *xmlSecKeyDataId; typedef const struct _xmlSecKeyDataStoreKlass xmlSecKeyDataStoreKlass, *xmlSecKeyDataStoreId; typedef struct _xmlSecKeyDataList xmlSecKeyDataList, *xmlSecKeyDataListPtr; /************************************************************************** * * xmlSecKeyDataUsage * *************************************************************************/ /** * xmlSecKeyDataUsage: * * The bits mask that determines possible keys data usage. */ typedef unsigned int xmlSecKeyDataUsage; /** * xmlSecKeyDataUsageUnknown: * * The key data usage is unknown. */ #define xmlSecKeyDataUsageUnknown 0x00000 /** * xmlSecKeyDataUsageKeyInfoNodeRead: * * The key data could be read from a child. */ #define xmlSecKeyDataUsageKeyInfoNodeRead 0x00001 /** * xmlSecKeyDataUsageKeyInfoNodeWrite: * * The key data could be written to a child. */ #define xmlSecKeyDataUsageKeyInfoNodeWrite 0x00002 /** * xmlSecKeyDataUsageKeyValueNodeRead: * * The key data could be read from a child. */ #define xmlSecKeyDataUsageKeyValueNodeRead 0x00004 /** * xmlSecKeyDataUsageKeyValueNodeWrite: * * The key data could be written to a child. */ #define xmlSecKeyDataUsageKeyValueNodeWrite 0x00008 /** * xmlSecKeyDataUsageRetrievalMethodNodeXml: * * The key data could be retrieved using node * in XML format. */ #define xmlSecKeyDataUsageRetrievalMethodNodeXml 0x00010 /** * xmlSecKeyDataUsageRetrievalMethodNodeBin: * * The key data could be retrieved using node * in binary format. */ #define xmlSecKeyDataUsageRetrievalMethodNodeBin 0x00020 /** * xmlSecKeyDataUsageAny: * * Any key data usage. */ #define xmlSecKeyDataUsageAny 0xFFFFF /** * xmlSecKeyDataUsageKeyInfoNode: * * The key data could be read and written from/to a child. */ #define xmlSecKeyDataUsageKeyInfoNode \ (xmlSecKeyDataUsageKeyInfoNodeRead | xmlSecKeyDataUsageKeyInfoNodeWrite) /** * xmlSecKeyDataUsageKeyValueNode: * * The key data could be read and written from/to a child. */ #define xmlSecKeyDataUsageKeyValueNode \ (xmlSecKeyDataUsageKeyValueNodeRead | xmlSecKeyDataUsageKeyValueNodeWrite) /** * xmlSecKeyDataUsageRetrievalMethodNode: * * The key data could be retrieved using node * in any format. */ #define xmlSecKeyDataUsageRetrievalMethodNode \ (xmlSecKeyDataUsageRetrievalMethodNodeXml | xmlSecKeyDataUsageRetrievalMethodNodeBin) /************************************************************************** * * xmlSecKeyDataType * *************************************************************************/ /** * xmlSecKeyDataType: * * The key data type (public/private, session/permanet, etc.). */ typedef unsigned int xmlSecKeyDataType; /** * xmlSecKeyDataTypeUnknown: * * The key data type is unknown (same as #xmlSecKeyDataTypeNone). */ #define xmlSecKeyDataTypeUnknown 0x0000 /** * xmlSecKeyDataTypeNone: * * The key data type is unknown (same as #xmlSecKeyDataTypeUnknown). */ #define xmlSecKeyDataTypeNone xmlSecKeyDataTypeUnknown /** * xmlSecKeyDataTypePublic: * * The key data contain a public key. */ #define xmlSecKeyDataTypePublic 0x0001 /** * xmlSecKeyDataTypePrivate: * * The key data contain a private key. */ #define xmlSecKeyDataTypePrivate 0x0002 /** * xmlSecKeyDataTypeSymmetric: * * The key data contain a symmetric key. */ #define xmlSecKeyDataTypeSymmetric 0x0004 /** * xmlSecKeyDataTypeSession: * * The key data contain session key (one time key, not stored in keys manager). */ #define xmlSecKeyDataTypeSession 0x0008 /** * xmlSecKeyDataTypePermanent: * * The key data contain permanent key (stored in keys manager). */ #define xmlSecKeyDataTypePermanent 0x0010 /** * xmlSecKeyDataTypeTrusted: * * The key data is trusted. */ #define xmlSecKeyDataTypeTrusted 0x0100 /** * xmlSecKeyDataTypeAny: * * Any key data. */ #define xmlSecKeyDataTypeAny 0xFFFF /************************************************************************** * * xmlSecKeyDataFormat * *************************************************************************/ /** * xmlSecKeyDataFormat: * @xmlSecKeyDataFormatUnknown: the key data format is unknown. * @xmlSecKeyDataFormatBinary: the binary key data. * @xmlSecKeyDataFormatPem: the PEM key data (cert or public/private key). * @xmlSecKeyDataFormatDer: the DER key data (cert or public/private key). * @xmlSecKeyDataFormatPkcs8Pem: the PKCS8 PEM private key. * @xmlSecKeyDataFormatPkcs8Der: the PKCS8 DER private key. * @xmlSecKeyDataFormatPkcs12: the PKCS12 format (bag of keys and certs) * @xmlSecKeyDataFormatCertPem: the PEM cert. * @xmlSecKeyDataFormatCertDer: the DER cert. * * The key data format (binary, der, pem, etc.). */ typedef enum { xmlSecKeyDataFormatUnknown = 0, xmlSecKeyDataFormatBinary, xmlSecKeyDataFormatPem, xmlSecKeyDataFormatDer, xmlSecKeyDataFormatPkcs8Pem, xmlSecKeyDataFormatPkcs8Der, xmlSecKeyDataFormatPkcs12, xmlSecKeyDataFormatCertPem, xmlSecKeyDataFormatCertDer } xmlSecKeyDataFormat; /************************************************************************** * * Global xmlSecKeyDataIds methods * *************************************************************************/ XMLSEC_EXPORT xmlSecPtrListPtr xmlSecKeyDataIdsGet (void); XMLSEC_EXPORT int xmlSecKeyDataIdsInit (void); XMLSEC_EXPORT void xmlSecKeyDataIdsShutdown (void); XMLSEC_EXPORT int xmlSecKeyDataIdsRegisterDefault (void); XMLSEC_EXPORT int xmlSecKeyDataIdsRegister (xmlSecKeyDataId id); /************************************************************************** * * xmlSecKeyData * *************************************************************************/ /** * xmlSecKeyData: * @id: the data id (#xmlSecKeyDataId). * @reserved0: reserved for the future. * @reserved1: reserved for the future. * * The key data: key value (crypto material), x509 data, pgp data, etc. */ struct _xmlSecKeyData { xmlSecKeyDataId id; void* reserved0; void* reserved1; }; XMLSEC_EXPORT xmlSecKeyDataPtr xmlSecKeyDataCreate (xmlSecKeyDataId id); XMLSEC_EXPORT xmlSecKeyDataPtr xmlSecKeyDataDuplicate (xmlSecKeyDataPtr data); XMLSEC_EXPORT void xmlSecKeyDataDestroy (xmlSecKeyDataPtr data); XMLSEC_EXPORT int xmlSecKeyDataGenerate (xmlSecKeyDataPtr data, xmlSecSize sizeBits, xmlSecKeyDataType type); XMLSEC_EXPORT xmlSecKeyDataType xmlSecKeyDataGetType (xmlSecKeyDataPtr data); XMLSEC_EXPORT xmlSecSize xmlSecKeyDataGetSize (xmlSecKeyDataPtr data); XMLSEC_EXPORT const xmlChar* xmlSecKeyDataGetIdentifier (xmlSecKeyDataPtr data); XMLSEC_EXPORT void xmlSecKeyDataDebugDump (xmlSecKeyDataPtr data, FILE *output); XMLSEC_EXPORT void xmlSecKeyDataDebugXmlDump (xmlSecKeyDataPtr data, FILE *output); XMLSEC_EXPORT int xmlSecKeyDataXmlRead (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataXmlWrite (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataBinRead (xmlSecKeyDataId id, xmlSecKeyPtr key, const xmlSecByte* buf, xmlSecSize bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataBinWrite (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlSecByte** buf, xmlSecSize* bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); /** * xmlSecKeyDataGetName: * @data: the pointer to key data. * * Macro. Returns the key data name. */ #define xmlSecKeyDataGetName(data) \ ((xmlSecKeyDataIsValid((data))) ? \ xmlSecKeyDataKlassGetName((data)->id) : NULL) /** * xmlSecKeyDataIsValid: * @data: the pointer to data. * * Macro. Returns 1 if @data is not NULL and @data->id is not NULL * or 0 otherwise. */ #define xmlSecKeyDataIsValid(data) \ ((( data ) != NULL) && \ (( data )->id != NULL) && \ (( data )->id->klassSize >= sizeof(xmlSecKeyDataKlass)) && \ (( data )->id->objSize >= sizeof(xmlSecKeyData)) && \ (( data )->id->name != NULL)) /** * xmlSecKeyDataCheckId: * @data: the pointer to data. * @dataId: the data Id. * * Macro. Returns 1 if @data is valid and @data's id is equal to @dataId. */ #define xmlSecKeyDataCheckId(data, dataId) \ (xmlSecKeyDataIsValid(( data )) && \ ((( data )->id) == ( dataId ))) /** * xmlSecKeyDataCheckUsage: * @data: the pointer to data. * @usg: the data usage. * * Macro. Returns 1 if @data is valid and could be used for @usg. */ #define xmlSecKeyDataCheckUsage(data, usg) \ (xmlSecKeyDataIsValid(( data )) && \ (((( data )->id->usage) & ( usg )) != 0)) /** * xmlSecKeyDataCheckSize: * @data: the pointer to data. * @size: the expected size. * * Macro. Returns 1 if @data is valid and @data's object has at least @size bytes. */ #define xmlSecKeyDataCheckSize(data, size) \ (xmlSecKeyDataIsValid(( data )) && \ (( data )->id->objSize >= size)) /************************************************************************** * * xmlSecKeyDataKlass * *************************************************************************/ /** * xmlSecKeyDataIdUnknown: * * The "unknown" id. */ #define xmlSecKeyDataIdUnknown ((xmlSecKeyDataId)NULL) /** * xmlSecKeyDataInitMethod: * @data: the pointer to key data. * * Key data specific initialization method. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataInitMethod) (xmlSecKeyDataPtr data); /** * xmlSecKeyDataDuplicateMethod: * @dst: the pointer to destination key data. * @src: the poiniter to source key data. * * Key data specific duplication (copy) method. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataDuplicateMethod) (xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src); /** * xmlSecKeyDataFinalizeMethod: * @data: the data. * * Key data specific finalization method. All the objects and resources allocated * by the key data object must be freed inside this method. */ typedef void (*xmlSecKeyDataFinalizeMethod) (xmlSecKeyDataPtr data); /** * xmlSecKeyDataXmlReadMethod: * @id: the data id. * @key: the key. * @node: the pointer to data's value XML node. * @keyInfoCtx: the node processing context. * * Key data specific method for reading XML node. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataXmlReadMethod) (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); /** * xmlSecKeyDataXmlWriteMethod: * @id: the data id. * @key: the key. * @node: the pointer to data's value XML node. * @keyInfoCtx: the node processing context. * * Key data specific method for writing XML node. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataXmlWriteMethod) (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); /** * xmlSecKeyDataBinReadMethod: * @id: the data id. * @key: the key. * @buf: the input buffer. * @bufSize: the buffer size. * @keyInfoCtx: the node processing context. * * Key data specific method for reading binary buffer. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataBinReadMethod) (xmlSecKeyDataId id, xmlSecKeyPtr key, const xmlSecByte* buf, xmlSecSize bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); /** * xmlSecKeyDataBinWriteMethod: * @id: the data id. * @key: the key. * @buf: the output buffer. * @bufSize: the buffer size. * @keyInfoCtx: the node processing context. * * Key data specific method for reading binary buffer. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataBinWriteMethod) (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlSecByte** buf, xmlSecSize* bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); /** * xmlSecKeyDataGenerateMethod: * @data: the pointer to key data. * @sizeBits: the key data specific size. * @type: the required key type (session/permanent, etc.) * * Key data specific method for generating new key data. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataGenerateMethod) (xmlSecKeyDataPtr data, xmlSecSize sizeBits, xmlSecKeyDataType type); /** * xmlSecKeyDataGetTypeMethod: * @data: the data. * * Key data specific method to get the key type. * * Returns: the key type. */ typedef xmlSecKeyDataType (*xmlSecKeyDataGetTypeMethod) (xmlSecKeyDataPtr data); /** * xmlSecKeyDataGetSizeMethod: * @data: the pointer to key data. * * Key data specific method to get the key size. * * Returns: the key size in bits. */ typedef xmlSecSize (*xmlSecKeyDataGetSizeMethod) (xmlSecKeyDataPtr data); /** * xmlSecKeyDataGetIdentifierMethod: * @data: the pointer to key data. * * Key data specific method to get the key data identifier string (for example, * X509 data identifier is the subject of the verified cert). * * Returns: the identifier string or NULL if an error occurs. */ typedef const xmlChar* (*xmlSecKeyDataGetIdentifierMethod) (xmlSecKeyDataPtr data); /** * xmlSecKeyDataDebugDumpMethod: * @data: the data. * @output: the FILE to print debug info (should be open for writing). * * Key data specific method for printing debug info. */ typedef void (*xmlSecKeyDataDebugDumpMethod) (xmlSecKeyDataPtr data, FILE* output); /** * xmlSecKeyDataKlass: * @klassSize: the klass size. * @objSize: the object size. * @name: the object name. * @usage: the allowed data usage. * @href: the identification string (href). * @dataNodeName: the data's XML node name. * @dataNodeNs: the data's XML node namespace. * @initialize: the initialization method. * @duplicate: the duplicate (copy) method. * @finalize: the finalization (destroy) method. * @generate: the new data generation method. * @getType: the method to access data's type information. * @getSize: the method to access data's size. * @getIdentifier: the method to access data's string identifier. * @xmlRead: the method for reading data from XML node. * @xmlWrite: the method for writing data to XML node. * @binRead: the method for reading data from a binary buffer. * @binWrite: the method for writing data to binary buffer. * @debugDump: the method for printing debug data information. * @debugXmlDump: the method for printing debug data information in XML format. * @reserved0: reserved for the future. * @reserved1: reserved for the future. * * The data id (klass). */ struct _xmlSecKeyDataKlass { xmlSecSize klassSize; xmlSecSize objSize; /* data */ const xmlChar* name; xmlSecKeyDataUsage usage; const xmlChar* href; const xmlChar* dataNodeName; const xmlChar* dataNodeNs; /* constructors/destructor */ xmlSecKeyDataInitMethod initialize; xmlSecKeyDataDuplicateMethod duplicate; xmlSecKeyDataFinalizeMethod finalize; xmlSecKeyDataGenerateMethod generate; /* get info */ xmlSecKeyDataGetTypeMethod getType; xmlSecKeyDataGetSizeMethod getSize; xmlSecKeyDataGetIdentifierMethod getIdentifier; /* read/write */ xmlSecKeyDataXmlReadMethod xmlRead; xmlSecKeyDataXmlWriteMethod xmlWrite; xmlSecKeyDataBinReadMethod binRead; xmlSecKeyDataBinWriteMethod binWrite; /* debug */ xmlSecKeyDataDebugDumpMethod debugDump; xmlSecKeyDataDebugDumpMethod debugXmlDump; /* for the future */ void* reserved0; void* reserved1; }; /** * xmlSecKeyDataKlassGetName: * @klass: the data klass. * * Macro. Returns data klass name. */ #define xmlSecKeyDataKlassGetName(klass) \ (((klass)) ? ((klass)->name) : NULL) /*********************************************************************** * * Key Data list * **********************************************************************/ /** * xmlSecKeyDataListId: * * * The key data klasses list klass id. */ #define xmlSecKeyDataListId xmlSecKeyDataListGetKlass() XMLSEC_EXPORT xmlSecPtrListId xmlSecKeyDataListGetKlass (void); /*********************************************************************** * * Key Data Ids list * **********************************************************************/ /** * xmlSecKeyDataIdListId: * * * The key data list klass id. */ #define xmlSecKeyDataIdListId xmlSecKeyDataIdListGetKlass() XMLSEC_EXPORT xmlSecPtrListId xmlSecKeyDataIdListGetKlass (void); XMLSEC_EXPORT int xmlSecKeyDataIdListFind (xmlSecPtrListPtr list, xmlSecKeyDataId dataId); XMLSEC_EXPORT xmlSecKeyDataId xmlSecKeyDataIdListFindByNode (xmlSecPtrListPtr list, const xmlChar* nodeName, const xmlChar* nodeNs, xmlSecKeyDataUsage usage); XMLSEC_EXPORT xmlSecKeyDataId xmlSecKeyDataIdListFindByHref (xmlSecPtrListPtr list, const xmlChar* href, xmlSecKeyDataUsage usage); XMLSEC_EXPORT xmlSecKeyDataId xmlSecKeyDataIdListFindByName (xmlSecPtrListPtr list, const xmlChar* name, xmlSecKeyDataUsage usage); XMLSEC_EXPORT void xmlSecKeyDataIdListDebugDump (xmlSecPtrListPtr list, FILE* output); XMLSEC_EXPORT void xmlSecKeyDataIdListDebugXmlDump (xmlSecPtrListPtr list, FILE* output); /************************************************************************** * * xmlSecKeyDataBinary * * key (xmlSecBuffer) is located after xmlSecKeyData structure * *************************************************************************/ /** * xmlSecKeyDataBinarySize: * * The binary key data object size. */ #define xmlSecKeyDataBinarySize \ (sizeof(xmlSecKeyData) + sizeof(xmlSecBuffer)) XMLSEC_EXPORT int xmlSecKeyDataBinaryValueInitialize (xmlSecKeyDataPtr data); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueDuplicate (xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src); XMLSEC_EXPORT void xmlSecKeyDataBinaryValueFinalize (xmlSecKeyDataPtr data); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueXmlRead (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueXmlWrite (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueBinRead (xmlSecKeyDataId id, xmlSecKeyPtr key, const xmlSecByte* buf, xmlSecSize bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueBinWrite (xmlSecKeyDataId id, xmlSecKeyPtr key, xmlSecByte** buf, xmlSecSize* bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx); XMLSEC_EXPORT void xmlSecKeyDataBinaryValueDebugDump (xmlSecKeyDataPtr data, FILE* output); XMLSEC_EXPORT void xmlSecKeyDataBinaryValueDebugXmlDump (xmlSecKeyDataPtr data, FILE* output); XMLSEC_EXPORT xmlSecSize xmlSecKeyDataBinaryValueGetSize (xmlSecKeyDataPtr data); XMLSEC_EXPORT xmlSecBufferPtr xmlSecKeyDataBinaryValueGetBuffer (xmlSecKeyDataPtr data); XMLSEC_EXPORT int xmlSecKeyDataBinaryValueSetBuffer (xmlSecKeyDataPtr data, const xmlSecByte* buf, xmlSecSize bufSize); /************************************************************************** * * xmlSecKeyDataStore * *************************************************************************/ /** * xmlSecKeyDataStore: * @id: the store id (#xmlSecKeyDataStoreId). * @reserved0: reserved for the future. * @reserved1: reserved for the future. * * The key data store. Key data store holds common key data specific information * required for key data processing. For example, X509 data store may hold * information about trusted (root) certificates. */ struct _xmlSecKeyDataStore { xmlSecKeyDataStoreId id; /* for the future */ void* reserved0; void* reserved1; }; XMLSEC_EXPORT xmlSecKeyDataStorePtr xmlSecKeyDataStoreCreate (xmlSecKeyDataStoreId id); XMLSEC_EXPORT void xmlSecKeyDataStoreDestroy (xmlSecKeyDataStorePtr store); /** * xmlSecKeyDataStoreGetName: * @store: the pointer to store. * * Macro. Returns key data store name. */ #define xmlSecKeyDataStoreGetName(store) \ ((xmlSecKeyDataStoreIsValid((store))) ? \ xmlSecKeyDataStoreKlassGetName((store)->id) : NULL) /** * xmlSecKeyDataStoreIsValid: * @store: the pointer to store. * * Macro. Returns 1 if @store is not NULL and @store->id is not NULL * or 0 otherwise. */ #define xmlSecKeyDataStoreIsValid(store) \ ((( store ) != NULL) && ((( store )->id) != NULL)) /** * xmlSecKeyDataStoreCheckId: * @store: the pointer to store. * @storeId: the store Id. * * Macro. Returns 1 if @store is valid and @store's id is equal to @storeId. */ #define xmlSecKeyDataStoreCheckId(store, storeId) \ (xmlSecKeyDataStoreIsValid(( store )) && \ ((( store )->id) == ( storeId ))) /** * xmlSecKeyDataStoreCheckSize: * @store: the pointer to store. * @size: the expected size. * * Macro. Returns 1 if @data is valid and @stores's object has at least @size bytes. */ #define xmlSecKeyDataStoreCheckSize(store, size) \ (xmlSecKeyDataStoreIsValid(( store )) && \ (( store )->id->objSize >= size)) /************************************************************************** * * xmlSecKeyDataStoreKlass * *************************************************************************/ /** * xmlSecKeyDataStoreIdUnknown: * * The "unknown" id. */ #define xmlSecKeyDataStoreIdUnknown NULL /** * xmlSecKeyDataStoreInitializeMethod: * @store: the data store. * * Key data store specific initialization method. * * Returns: 0 on success or a negative value if an error occurs. */ typedef int (*xmlSecKeyDataStoreInitializeMethod) (xmlSecKeyDataStorePtr store); /** * xmlSecKeyDataStoreFinalizeMethod: * @store: the data store. * * Key data store specific finalization (destroy) method. */ typedef void (*xmlSecKeyDataStoreFinalizeMethod) (xmlSecKeyDataStorePtr store); /** * xmlSecKeyDataStoreKlass: * @klassSize: the data store klass size. * @objSize: the data store obj size. * @name: the store's name. * @initialize: the store's initialization method. * @finalize: the store's finalization (destroy) method. * @reserved0: reserved for the future. * @reserved1: reserved for the future. * * The data store id (klass). */ struct _xmlSecKeyDataStoreKlass { xmlSecSize klassSize; xmlSecSize objSize; /* data */ const xmlChar* name; /* constructors/destructor */ xmlSecKeyDataStoreInitializeMethod initialize; xmlSecKeyDataStoreFinalizeMethod finalize; /* for the future */ void* reserved0; void* reserved1; }; /** * xmlSecKeyDataStoreKlassGetName: * @klass: the pointer to store klass. * * Macro. Returns store klass name. */ #define xmlSecKeyDataStoreKlassGetName(klass) \ (((klass)) ? ((klass)->name) : NULL) /*********************************************************************** * * Key Data Store list * **********************************************************************/ /** * xmlSecKeyDataStorePtrListId: * * The data store list id (klass). */ #define xmlSecKeyDataStorePtrListId xmlSecKeyDataStorePtrListGetKlass() XMLSEC_EXPORT xmlSecPtrListId xmlSecKeyDataStorePtrListGetKlass (void); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* __XMLSEC_KEYSDATA_H__ */