/*-----------------------------------------------------------------------
 * File: AALPROXYAPI.C
 *
 * Copyright (c) 1995-2000 Intel Corporation. All rights reserved.
 *-----------------------------------------------------------------------
 */
/*
 * OpenVMS History
 *
 * 16-Sep-2002 Carol Kelly
 *        o Merge in V3_14 changes
 *
 */

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

 NEVER MODIFY THE .C VERSION OF THIS FILE BY HAND. IT IS GENERATED USING
 THE SCRIPTS IN THE ./generate DIRECTORY. TO UPDATE THE FILE, CHANGE THE
 .ctp FILE WITH THE SAME NAME AND TYPE 'make'.

 **************************************************************************
 **************************************************************************/
#ifndef VMS
#pragma warning (disable:4055 4152)
#endif
#include <stdlib.h>
#include <aal.h>
#include <emmtype.h>
#include <emmspi.h>
#include <cssmapi.h>
#include <cssmerr.h>
#include "AALProxyInternal.h"
#include "AALProxyDefs.h"
#include <cssmapi_typecast.h>

/* Define each SPI function.
 */
CSSM_RETURN CSSMAPI CSSM_Init(
                    const CSSM_VERSION *Version,
                    CSSM_PRIVILEGE_SCOPE Scope,
                    const CSSM_GUID *CallerGuid,
                    CSSM_KEY_HIERARCHY KeyHierarchy,
                    CSSM_PVC_MODE *PvcPolicy,
                    const void *Reserved )
{
    CSSM_Init_ptr FuncPtr = (CSSM_Init_ptr)g_aalFuncTable[CSSM_INIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(Version, Scope, CallerGuid, KeyHierarchy, PvcPolicy, Reserved);
}

CSSM_RETURN CSSMAPI CSSM_Terminate(
                    void )
{
    CSSM_Terminate_ptr FuncPtr = (CSSM_Terminate_ptr)g_aalFuncTable[CSSM_TERMINATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr();
}

CSSM_RETURN CSSMAPI CSSM_ModuleLoad(
                    const CSSM_GUID *ModuleGuid,
                    CSSM_KEY_HIERARCHY KeyHierarchy,
                    CSSM_API_ModuleEventHandler AppNotifyCallback,
                    void *AppNotifyCallbackCtx )
{
    CSSM_ModuleLoad_ptr FuncPtr = (CSSM_ModuleLoad_ptr)g_aalFuncTable[CSSM_MODULELOAD].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleGuid, KeyHierarchy, AppNotifyCallback, AppNotifyCallbackCtx);
}

CSSM_RETURN CSSMAPI CSSM_ModuleUnload(
                    const CSSM_GUID *ModuleGuid,
                    CSSM_API_ModuleEventHandler AppNotifyCallback,
                    void *AppNotifyCallbackCtx )
{
    CSSM_ModuleUnload_ptr FuncPtr = (CSSM_ModuleUnload_ptr)g_aalFuncTable[CSSM_MODULEUNLOAD].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleGuid, AppNotifyCallback, AppNotifyCallbackCtx);
}

CSSM_RETURN CSSMAPI CSSM_Introduce(
                    const CSSM_GUID *ModuleID,
                    CSSM_KEY_HIERARCHY KeyHierarchy )
{
    CSSM_Introduce_ptr FuncPtr = (CSSM_Introduce_ptr)g_aalFuncTable[CSSM_INTRODUCE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleID, KeyHierarchy);
}

CSSM_RETURN CSSMAPI CSSM_Unintroduce(
                    const CSSM_GUID *ModuleID )
{
    CSSM_Unintroduce_ptr FuncPtr = (CSSM_Unintroduce_ptr)g_aalFuncTable[CSSM_UNINTRODUCE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleID);
}

CSSM_RETURN CSSMAPI CSSM_ModuleAttach(
                    const CSSM_GUID *ModuleGuid,
                    const CSSM_VERSION *Version,
                    const CSSM_API_MEMORY_FUNCS *MemoryFuncs,
                    uint32 SubserviceID,
                    CSSM_SERVICE_TYPE SubServiceType,
                    CSSM_ATTACH_FLAGS AttachFlags,
                    CSSM_KEY_HIERARCHY KeyHierarchy,
                    CSSM_FUNC_NAME_ADDR *FunctionTable,
                    uint32 NumFunctionTable,
                    const void *Reserved,
                    CSSM_MODULE_HANDLE_PTR NewModuleHandle )
{
    CSSM_ModuleAttach_ptr FuncPtr = (CSSM_ModuleAttach_ptr)g_aalFuncTable[CSSM_MODULEATTACH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleGuid, Version, MemoryFuncs, SubserviceID, SubServiceType, AttachFlags, KeyHierarchy, FunctionTable, NumFunctionTable, Reserved, NewModuleHandle);
}

CSSM_RETURN CSSMAPI CSSM_ModuleDetach(
                    CSSM_MODULE_HANDLE ModuleHandle )
{
    CSSM_ModuleDetach_ptr FuncPtr = (CSSM_ModuleDetach_ptr)g_aalFuncTable[CSSM_MODULEDETACH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleHandle);
}

CSSM_RETURN CSSMAPI CSSM_SetPrivilege(
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_SetPrivilege_ptr FuncPtr = (CSSM_SetPrivilege_ptr)g_aalFuncTable[CSSM_SETPRIVILEGE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(Privilege);
}

CSSM_RETURN CSSMAPI CSSM_GetPrivilege(
                    CSSM_PRIVILEGE *Privilege )
{
    CSSM_GetPrivilege_ptr FuncPtr = (CSSM_GetPrivilege_ptr)g_aalFuncTable[CSSM_GETPRIVILEGE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(Privilege);
}

CSSM_RETURN CSSMAPI CSSM_GetModuleGUIDFromHandle(
                    CSSM_MODULE_HANDLE ModuleHandle,
                    CSSM_GUID_PTR ModuleGUID )
{
    CSSM_GetModuleGUIDFromHandle_ptr FuncPtr = (CSSM_GetModuleGUIDFromHandle_ptr)g_aalFuncTable[CSSM_GETMODULEGUIDFROMHANDLE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleHandle, ModuleGUID);
}

CSSM_RETURN CSSMAPI CSSM_GetSubserviceUIDFromHandle(
                    CSSM_MODULE_HANDLE ModuleHandle,
                    CSSM_SUBSERVICE_UID_PTR SubserviceUID )
{
    CSSM_GetSubserviceUIDFromHandle_ptr FuncPtr = (CSSM_GetSubserviceUIDFromHandle_ptr)g_aalFuncTable[CSSM_GETSUBSERVICEUIDFROMHANDLE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ModuleHandle, SubserviceUID);
}

CSSM_RETURN CSSMAPI CSSM_ListAttachedModuleManagers(
                    uint32 *NumberOfModuleManagers,
                    CSSM_GUID_PTR ModuleManagerGuids )
{
    CSSM_ListAttachedModuleManagers_ptr FuncPtr = (CSSM_ListAttachedModuleManagers_ptr)g_aalFuncTable[CSSM_LISTATTACHEDMODULEMANAGERS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(NumberOfModuleManagers, ModuleManagerGuids);
}

CSSM_RETURN CSSMAPI CSSM_GetAPIMemoryFunctions(
                    CSSM_MODULE_HANDLE AddInHandle,
                    CSSM_API_MEMORY_FUNCS_PTR AppMemoryFuncs )
{
    CSSM_GetAPIMemoryFunctions_ptr FuncPtr = (CSSM_GetAPIMemoryFunctions_ptr)g_aalFuncTable[CSSM_GETAPIMEMORYFUNCTIONS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(AddInHandle, AppMemoryFuncs);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateSignatureContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateSignatureContext_ptr FuncPtr = (CSSM_CSP_CreateSignatureContext_ptr)g_aalFuncTable[CSSM_CSP_CREATESIGNATURECONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, AccessCred, Key, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateSymmetricContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    CSSM_ENCRYPT_MODE Mode,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    const CSSM_DATA *InitVector,
                    CSSM_PADDING Padding,
                    void *Reserved,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateSymmetricContext_ptr FuncPtr = (CSSM_CSP_CreateSymmetricContext_ptr)g_aalFuncTable[CSSM_CSP_CREATESYMMETRICCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, Mode, AccessCred, Key, InitVector, Padding, Reserved, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateDigestContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateDigestContext_ptr FuncPtr = (CSSM_CSP_CreateDigestContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEDIGESTCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateMacContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    const CSSM_KEY *Key,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateMacContext_ptr FuncPtr = (CSSM_CSP_CreateMacContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEMACCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, Key, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateRandomGenContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    const CSSM_CRYPTO_DATA *Seed,
                    uint32 Length,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateRandomGenContext_ptr FuncPtr = (CSSM_CSP_CreateRandomGenContext_ptr)g_aalFuncTable[CSSM_CSP_CREATERANDOMGENCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, Seed, Length, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateAsymmetricContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    CSSM_PADDING Padding,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateAsymmetricContext_ptr FuncPtr = (CSSM_CSP_CreateAsymmetricContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEASYMMETRICCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, AccessCred, Key, Padding, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateDeriveKeyContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    CSSM_KEY_TYPE DeriveKeyType,
                    uint32 DeriveKeyLengthInBits,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *BaseKey,
                    uint32 IterationCount,
                    const CSSM_DATA *Salt,
                    const CSSM_CRYPTO_DATA *Seed,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateDeriveKeyContext_ptr FuncPtr = (CSSM_CSP_CreateDeriveKeyContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEDERIVEKEYCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, DeriveKeyType, DeriveKeyLengthInBits, AccessCred, BaseKey, IterationCount, Salt, Seed, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreateKeyGenContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS AlgorithmID,
                    uint32 KeySizeInBits,
                    const CSSM_CRYPTO_DATA *Seed,
                    const CSSM_DATA *Salt,
                    const CSSM_DATE *StartDate,
                    const CSSM_DATE *EndDate,
                    const CSSM_DATA *Params,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreateKeyGenContext_ptr FuncPtr = (CSSM_CSP_CreateKeyGenContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEKEYGENCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AlgorithmID, KeySizeInBits, Seed, Salt, StartDate, EndDate, Params, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_CreatePassThroughContext(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *Key,
                    CSSM_CC_HANDLE *NewContextHandle )
{
    CSSM_CSP_CreatePassThroughContext_ptr FuncPtr = (CSSM_CSP_CreatePassThroughContext_ptr)g_aalFuncTable[CSSM_CSP_CREATEPASSTHROUGHCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Key, NewContextHandle);
}

CSSM_RETURN CSSMAPI CSSM_GetContext(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_CONTEXT_PTR *Context )
{
    CSSM_GetContext_ptr FuncPtr = (CSSM_GetContext_ptr)g_aalFuncTable[CSSM_GETCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Context);
}

CSSM_RETURN CSSMAPI CSSM_FreeContext(
                    CSSM_CONTEXT_PTR Context )
{
    CSSM_FreeContext_ptr FuncPtr = (CSSM_FreeContext_ptr)g_aalFuncTable[CSSM_FREECONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(Context);
}

CSSM_RETURN CSSMAPI CSSM_SetContext(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_CONTEXT *Context )
{
    CSSM_SetContext_ptr FuncPtr = (CSSM_SetContext_ptr)g_aalFuncTable[CSSM_SETCONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Context);
}

CSSM_RETURN CSSMAPI CSSM_DeleteContext(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_DeleteContext_ptr FuncPtr = (CSSM_DeleteContext_ptr)g_aalFuncTable[CSSM_DELETECONTEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_GetContextAttribute(
                    const CSSM_CONTEXT *Context,
                    uint32 AttributeType,
                    CSSM_CONTEXT_ATTRIBUTE_PTR *ContextAttribute )
{
    CSSM_GetContextAttribute_ptr FuncPtr = (CSSM_GetContextAttribute_ptr)g_aalFuncTable[CSSM_GETCONTEXTATTRIBUTE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(Context, AttributeType, ContextAttribute);
}

CSSM_RETURN CSSMAPI CSSM_UpdateContextAttributes(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 NumberAttributes,
                    const CSSM_CONTEXT_ATTRIBUTE *ContextAttributes )
{
    CSSM_UpdateContextAttributes_ptr FuncPtr = (CSSM_UpdateContextAttributes_ptr)g_aalFuncTable[CSSM_UPDATECONTEXTATTRIBUTES].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, NumberAttributes, ContextAttributes);
}

CSSM_RETURN CSSMAPI CSSM_DeleteContextAttributes(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 NumberOfAttributes,
                    const CSSM_CONTEXT_ATTRIBUTE *ContextAttributes )
{
    CSSM_DeleteContextAttributes_ptr FuncPtr = (CSSM_DeleteContextAttributes_ptr)g_aalFuncTable[CSSM_DELETECONTEXTATTRIBUTES].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, NumberOfAttributes, ContextAttributes);
}

CSSM_RETURN CSSMAPI CSSM_QuerySize(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_BOOL Encrypt,
                    uint32 QuerySizeCount,
                    CSSM_QUERY_SIZE_DATA_PTR DataBlock )
{
    CSSM_QuerySize_ptr FuncPtr = (CSSM_QuerySize_ptr)g_aalFuncTable[CSSM_QUERYSIZE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Encrypt, QuerySizeCount, DataBlock);
}

CSSM_RETURN CSSMAPI CSSM_SignData(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_ALGORITHMS DigestAlgorithm,
                    CSSM_DATA_PTR Signature )
{
    CSSM_SignData_ptr FuncPtr = (CSSM_SignData_ptr)g_aalFuncTable[CSSM_SIGNDATA].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount, DigestAlgorithm, Signature);
}

CSSM_RETURN CSSMAPI CSSM_SignDataInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_SignDataInit_ptr FuncPtr = (CSSM_SignDataInit_ptr)g_aalFuncTable[CSSM_SIGNDATAINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_SignDataUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    CSSM_SignDataUpdate_ptr FuncPtr = (CSSM_SignDataUpdate_ptr)g_aalFuncTable[CSSM_SIGNDATAUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount);
}

CSSM_RETURN CSSMAPI CSSM_SignDataFinal(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR Signature )
{
    CSSM_SignDataFinal_ptr FuncPtr = (CSSM_SignDataFinal_ptr)g_aalFuncTable[CSSM_SIGNDATAFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Signature);
}

CSSM_RETURN CSSMAPI CSSM_VerifyData(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_ALGORITHMS DigestAlgorithm,
                    const CSSM_DATA *Signature )
{
    CSSM_VerifyData_ptr FuncPtr = (CSSM_VerifyData_ptr)g_aalFuncTable[CSSM_VERIFYDATA].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount, DigestAlgorithm, Signature);
}

CSSM_RETURN CSSMAPI CSSM_VerifyDataInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_VerifyDataInit_ptr FuncPtr = (CSSM_VerifyDataInit_ptr)g_aalFuncTable[CSSM_VERIFYDATAINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_VerifyDataUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    CSSM_VerifyDataUpdate_ptr FuncPtr = (CSSM_VerifyDataUpdate_ptr)g_aalFuncTable[CSSM_VERIFYDATAUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount);
}

CSSM_RETURN CSSMAPI CSSM_VerifyDataFinal(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *Signature )
{
    CSSM_VerifyDataFinal_ptr FuncPtr = (CSSM_VerifyDataFinal_ptr)g_aalFuncTable[CSSM_VERIFYDATAFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Signature);
}

CSSM_RETURN CSSMAPI CSSM_DigestData(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_DATA_PTR Digest )
{
    CSSM_DigestData_ptr FuncPtr = (CSSM_DigestData_ptr)g_aalFuncTable[CSSM_DIGESTDATA].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount, Digest);
}

CSSM_RETURN CSSMAPI CSSM_DigestDataInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_DigestDataInit_ptr FuncPtr = (CSSM_DigestDataInit_ptr)g_aalFuncTable[CSSM_DIGESTDATAINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_DigestDataUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    CSSM_DigestDataUpdate_ptr FuncPtr = (CSSM_DigestDataUpdate_ptr)g_aalFuncTable[CSSM_DIGESTDATAUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount);
}

CSSM_RETURN CSSMAPI CSSM_DigestDataClone(
                     CSSM_CC_HANDLE CCHandle,
                    CSSM_CC_HANDLE * ClonednewCCHandle )
{
    CSSM_DigestDataClone_ptr FuncPtr = (CSSM_DigestDataClone_ptr)g_aalFuncTable[CSSM_DIGESTDATACLONE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, ClonednewCCHandle);
}

CSSM_RETURN CSSMAPI CSSM_DigestDataFinal(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR Digest )
{
    CSSM_DigestDataFinal_ptr FuncPtr = (CSSM_DigestDataFinal_ptr)g_aalFuncTable[CSSM_DIGESTDATAFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Digest);
}

CSSM_RETURN CSSMAPI CSSM_GenerateMac(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_DATA_PTR Mac )
{
    CSSM_GenerateMac_ptr FuncPtr = (CSSM_GenerateMac_ptr)g_aalFuncTable[CSSM_GENERATEMAC].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount, Mac);
}

CSSM_RETURN CSSMAPI CSSM_GenerateMacInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_GenerateMacInit_ptr FuncPtr = (CSSM_GenerateMacInit_ptr)g_aalFuncTable[CSSM_GENERATEMACINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_GenerateMacUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    CSSM_GenerateMacUpdate_ptr FuncPtr = (CSSM_GenerateMacUpdate_ptr)g_aalFuncTable[CSSM_GENERATEMACUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount);
}

CSSM_RETURN CSSMAPI CSSM_GenerateMacFinal(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR Mac )
{
    CSSM_GenerateMacFinal_ptr FuncPtr = (CSSM_GenerateMacFinal_ptr)g_aalFuncTable[CSSM_GENERATEMACFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Mac);
}

CSSM_RETURN CSSMAPI CSSM_VerifyMac(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    const CSSM_DATA *Mac )
{
    CSSM_VerifyMac_ptr FuncPtr = (CSSM_VerifyMac_ptr)g_aalFuncTable[CSSM_VERIFYMAC].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount, Mac);
}

CSSM_RETURN CSSMAPI CSSM_VerifyMacInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_VerifyMacInit_ptr FuncPtr = (CSSM_VerifyMacInit_ptr)g_aalFuncTable[CSSM_VERIFYMACINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_VerifyMacUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    CSSM_VerifyMacUpdate_ptr FuncPtr = (CSSM_VerifyMacUpdate_ptr)g_aalFuncTable[CSSM_VERIFYMACUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, DataBufs, DataBufCount);
}

CSSM_RETURN CSSMAPI CSSM_VerifyMacFinal(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *Mac )
{
    CSSM_VerifyMacFinal_ptr FuncPtr = (CSSM_VerifyMacFinal_ptr)g_aalFuncTable[CSSM_VERIFYMACFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Mac);
}

CSSM_RETURN CSSMAPI CSSM_EncryptData(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *ClearBufs,
                    uint32 ClearBufCount,
                    CSSM_DATA_PTR CipherBufs,
                    uint32 CipherBufCount,
                    uint32 *bytesEncrypted,
                    CSSM_DATA_PTR RemData )
{
    CSSM_EncryptData_ptr FuncPtr = (CSSM_EncryptData_ptr)g_aalFuncTable[CSSM_ENCRYPTDATA].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, ClearBufs, ClearBufCount, CipherBufs, CipherBufCount, bytesEncrypted, RemData);
}

CSSM_RETURN CSSMAPI CSSM_EncryptDataP(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *ClearBufs,
                    uint32 ClearBufCount,
                    CSSM_DATA_PTR CipherBufs,
                    uint32 CipherBufCount,
                    uint32 *bytesEncrypted,
                    CSSM_DATA_PTR RemData,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_EncryptDataP_ptr FuncPtr = (CSSM_EncryptDataP_ptr)g_aalFuncTable[CSSM_ENCRYPTDATAP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, ClearBufs, ClearBufCount, CipherBufs, CipherBufCount, bytesEncrypted, RemData, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_EncryptDataInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_EncryptDataInit_ptr FuncPtr = (CSSM_EncryptDataInit_ptr)g_aalFuncTable[CSSM_ENCRYPTDATAINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_EncryptDataInitP(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_EncryptDataInitP_ptr FuncPtr = (CSSM_EncryptDataInitP_ptr)g_aalFuncTable[CSSM_ENCRYPTDATAINITP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_EncryptDataUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *ClearBufs,
                    uint32 ClearBufCount,
                    CSSM_DATA_PTR CipherBufs,
                    uint32 CipherBufCount,
                    uint32 *bytesEncrypted )
{
    CSSM_EncryptDataUpdate_ptr FuncPtr = (CSSM_EncryptDataUpdate_ptr)g_aalFuncTable[CSSM_ENCRYPTDATAUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, ClearBufs, ClearBufCount, CipherBufs, CipherBufCount, bytesEncrypted);
}

CSSM_RETURN CSSMAPI CSSM_EncryptDataFinal(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR RemData )
{
    CSSM_EncryptDataFinal_ptr FuncPtr = (CSSM_EncryptDataFinal_ptr)g_aalFuncTable[CSSM_ENCRYPTDATAFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, RemData);
}

CSSM_RETURN CSSMAPI CSSM_DecryptData(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CipherBufs,
                    uint32 CipherBufCount,
                    CSSM_DATA_PTR ClearBufs,
                    uint32 ClearBufCount,
                    uint32 *bytesDecrypted,
                    CSSM_DATA_PTR RemData )
{
    CSSM_DecryptData_ptr FuncPtr = (CSSM_DecryptData_ptr)g_aalFuncTable[CSSM_DECRYPTDATA].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, CipherBufs, CipherBufCount, ClearBufs, ClearBufCount, bytesDecrypted, RemData);
}

CSSM_RETURN CSSMAPI CSSM_DecryptDataP(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CipherBufs,
                    uint32 CipherBufCount,
                    CSSM_DATA_PTR ClearBufs,
                    uint32 ClearBufCount,
                    uint32 *bytesDecrypted,
                    CSSM_DATA_PTR RemData,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_DecryptDataP_ptr FuncPtr = (CSSM_DecryptDataP_ptr)g_aalFuncTable[CSSM_DECRYPTDATAP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, CipherBufs, CipherBufCount, ClearBufs, ClearBufCount, bytesDecrypted, RemData, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_DecryptDataInit(
                    CSSM_CC_HANDLE CCHandle )
{
    CSSM_DecryptDataInit_ptr FuncPtr = (CSSM_DecryptDataInit_ptr)g_aalFuncTable[CSSM_DECRYPTDATAINIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle);
}

CSSM_RETURN CSSMAPI CSSM_DecryptDataInitP(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_DecryptDataInitP_ptr FuncPtr = (CSSM_DecryptDataInitP_ptr)g_aalFuncTable[CSSM_DECRYPTDATAINITP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_DecryptDataUpdate(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CipherBufs,
                    uint32 CipherBufCount,
                    CSSM_DATA_PTR ClearBufs,
                    uint32 ClearBufCount,
                    uint32 *bytesDecrypted )
{
    CSSM_DecryptDataUpdate_ptr FuncPtr = (CSSM_DecryptDataUpdate_ptr)g_aalFuncTable[CSSM_DECRYPTDATAUPDATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, CipherBufs, CipherBufCount, ClearBufs, ClearBufCount, bytesDecrypted);
}

CSSM_RETURN CSSMAPI CSSM_DecryptDataFinal(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR RemData )
{
    CSSM_DecryptDataFinal_ptr FuncPtr = (CSSM_DecryptDataFinal_ptr)g_aalFuncTable[CSSM_DECRYPTDATAFINAL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, RemData);
}

CSSM_RETURN CSSMAPI CSSM_QueryKeySizeInBits(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_KEY *Key,
                    CSSM_KEY_SIZE_PTR KeySize )
{
    CSSM_QueryKeySizeInBits_ptr FuncPtr = (CSSM_QueryKeySizeInBits_ptr)g_aalFuncTable[CSSM_QUERYKEYSIZEINBITS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, CCHandle, Key, KeySize);
}

CSSM_RETURN CSSMAPI CSSM_GenerateKey(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR Key )
{
    CSSM_GenerateKey_ptr FuncPtr = (CSSM_GenerateKey_ptr)g_aalFuncTable[CSSM_GENERATEKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, KeyUsage, KeyAttr, KeyLabel, CredAndAclEntry, Key);
}

CSSM_RETURN CSSMAPI CSSM_GenerateKeyP(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR Key,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_GenerateKeyP_ptr FuncPtr = (CSSM_GenerateKeyP_ptr)g_aalFuncTable[CSSM_GENERATEKEYP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, KeyUsage, KeyAttr, KeyLabel, CredAndAclEntry, Key, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_GenerateKeyPair(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 PublicKeyUsage,
                    uint32 PublicKeyAttr,
                    const CSSM_DATA *PublicKeyLabel,
                    CSSM_KEY_PTR PublicKey,
                    uint32 PrivateKeyUsage,
                    uint32 PrivateKeyAttr,
                    const CSSM_DATA *PrivateKeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR PrivateKey )
{
    CSSM_GenerateKeyPair_ptr FuncPtr = (CSSM_GenerateKeyPair_ptr)g_aalFuncTable[CSSM_GENERATEKEYPAIR].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, PublicKeyUsage, PublicKeyAttr, PublicKeyLabel, PublicKey, PrivateKeyUsage, PrivateKeyAttr, PrivateKeyLabel, CredAndAclEntry, PrivateKey);
}

CSSM_RETURN CSSMAPI CSSM_GenerateKeyPairP(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 PublicKeyUsage,
                    uint32 PublicKeyAttr,
                    const CSSM_DATA *PublicKeyLabel,
                    CSSM_KEY_PTR PublicKey,
                    uint32 PrivateKeyUsage,
                    uint32 PrivateKeyAttr,
                    const CSSM_DATA *PrivateKeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR PrivateKey,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_GenerateKeyPairP_ptr FuncPtr = (CSSM_GenerateKeyPairP_ptr)g_aalFuncTable[CSSM_GENERATEKEYPAIRP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, PublicKeyUsage, PublicKeyAttr, PublicKeyLabel, PublicKey, PrivateKeyUsage, PrivateKeyAttr, PrivateKeyLabel, CredAndAclEntry, PrivateKey, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_GenerateRandom(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR RandomNumber )
{
    CSSM_GenerateRandom_ptr FuncPtr = (CSSM_GenerateRandom_ptr)g_aalFuncTable[CSSM_GENERATERANDOM].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, RandomNumber);
}

CSSM_RETURN CSSMAPI CSSM_GenerateAlgorithmParams(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 ParamBits,
                    CSSM_DATA_PTR Param   )
{
    CSSM_GenerateAlgorithmParams_ptr FuncPtr = (CSSM_GenerateAlgorithmParams_ptr)g_aalFuncTable[CSSM_GENERATEALGORITHMPARAMS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, ParamBits, Param);
}

CSSM_RETURN CSSMAPI CSSM_WrapKey(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    const CSSM_DATA *DescriptiveData,
                    CSSM_WRAP_KEY_PTR WrappedKey )
{
    CSSM_WrapKey_ptr FuncPtr = (CSSM_WrapKey_ptr)g_aalFuncTable[CSSM_WRAPKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, AccessCred, Key, DescriptiveData, WrappedKey);
}

CSSM_RETURN CSSMAPI CSSM_WrapKeyP(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_ACCESS_CREDENTIALS *Credentials,
                    const CSSM_KEY *Key,
                    const CSSM_DATA *DescriptiveData,
                    CSSM_WRAP_KEY_PTR WrappedKey,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_WrapKeyP_ptr FuncPtr = (CSSM_WrapKeyP_ptr)g_aalFuncTable[CSSM_WRAPKEYP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Credentials, Key, DescriptiveData, WrappedKey, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_UnwrapKey(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_KEY *PublicKey,
                    const CSSM_WRAP_KEY *WrappedKey,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR UnwrappedKey,
                    CSSM_DATA_PTR DescriptiveData )
{
    CSSM_UnwrapKey_ptr FuncPtr = (CSSM_UnwrapKey_ptr)g_aalFuncTable[CSSM_UNWRAPKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, PublicKey, WrappedKey, KeyUsage, KeyAttr, KeyLabel, CredAndAclEntry, UnwrappedKey, DescriptiveData);
}

CSSM_RETURN CSSMAPI CSSM_UnwrapKeyP(
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_KEY *PublicKey,
                    const CSSM_WRAP_KEY *WrappedKey,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR UnwrappedKey,
                    CSSM_DATA_PTR DescriptiveData,
                    CSSM_PRIVILEGE Privilege )
{
    CSSM_UnwrapKeyP_ptr FuncPtr = (CSSM_UnwrapKeyP_ptr)g_aalFuncTable[CSSM_UNWRAPKEYP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, PublicKey, WrappedKey, KeyUsage, KeyAttr, KeyLabel, CredAndAclEntry, UnwrappedKey, DescriptiveData, Privilege);
}

CSSM_RETURN CSSMAPI CSSM_DeriveKey(
                    CSSM_CC_HANDLE CCHandle,
                    CSSM_DATA_PTR Param,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR DerivedKey )
{
    CSSM_DeriveKey_ptr FuncPtr = (CSSM_DeriveKey_ptr)g_aalFuncTable[CSSM_DERIVEKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, Param, KeyUsage, KeyAttr, KeyLabel, CredAndAclEntry, DerivedKey);
}

CSSM_RETURN CSSMAPI CSSM_FreeKey(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    CSSM_KEY_PTR KeyPtr,
                    CSSM_BOOL Delete )
{
    CSSM_FreeKey_ptr FuncPtr = (CSSM_FreeKey_ptr)g_aalFuncTable[CSSM_FREEKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, KeyPtr, Delete);
}

CSSM_RETURN CSSMAPI CSSM_CSP_PassThrough(
                    CSSM_CC_HANDLE CCHandle,
                    uint32 PassThroughId,
                    const void *InData,
                    void **OutData )
{
    CSSM_CSP_PassThrough_ptr FuncPtr = (CSSM_CSP_PassThrough_ptr)g_aalFuncTable[CSSM_CSP_PASSTHROUGH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CCHandle, PassThroughId, InData, OutData);
}

CSSM_RETURN CSSMAPI CSSM_CSP_Login(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_DATA *LoginName,
                    const void *Reserved )
{
    CSSM_CSP_Login_ptr FuncPtr = (CSSM_CSP_Login_ptr)g_aalFuncTable[CSSM_CSP_LOGIN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, LoginName, Reserved);
}

CSSM_RETURN CSSMAPI CSSM_CSP_Logout(
                    CSSM_CSP_HANDLE CSPHandle )
{
    CSSM_CSP_Logout_ptr FuncPtr = (CSSM_CSP_Logout_ptr)g_aalFuncTable[CSSM_CSP_LOGOUT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle);
}

CSSM_RETURN CSSMAPI CSSM_CSP_ChangeLoginAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_EDIT *AclEdit )
{
    CSSM_CSP_ChangeLoginAcl_ptr FuncPtr = (CSSM_CSP_ChangeLoginAcl_ptr)g_aalFuncTable[CSSM_CSP_CHANGELOGINACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, AclEdit);
}

CSSM_RETURN CSSMAPI CSSM_CSP_ObtainPrivateKeyFromPublicKey(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *PublicKey,
                    CSSM_KEY_PTR PrivateKey )
{
    CSSM_CSP_ObtainPrivateKeyFromPublicKey_ptr FuncPtr = (CSSM_CSP_ObtainPrivateKeyFromPublicKey_ptr)g_aalFuncTable[CSSM_CSP_OBTAINPRIVATEKEYFROMPUBLICKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, PublicKey, PrivateKey);
}

CSSM_RETURN CSSMAPI CSSM_RetrieveUniqueId(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_DATA_PTR UniqueID )
{
    CSSM_RetrieveUniqueId_ptr FuncPtr = (CSSM_RetrieveUniqueId_ptr)g_aalFuncTable[CSSM_RETRIEVEUNIQUEID].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, UniqueID);
}

CSSM_RETURN CSSMAPI CSSM_RetrieveCounter(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_DATA_PTR Counter )
{
    CSSM_RetrieveCounter_ptr FuncPtr = (CSSM_RetrieveCounter_ptr)g_aalFuncTable[CSSM_RETRIEVECOUNTER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Counter);
}

CSSM_RETURN CSSMAPI CSSM_VerifyDevice(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_DATA *DeviceCert )
{
    CSSM_VerifyDevice_ptr FuncPtr = (CSSM_VerifyDevice_ptr)g_aalFuncTable[CSSM_VERIFYDEVICE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, DeviceCert);
}

CSSM_RETURN CSSMAPI CSSM_GetTimeValue(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS TimeAlgorithm,
                    CSSM_DATA *TimeData )
{
    CSSM_GetTimeValue_ptr FuncPtr = (CSSM_GetTimeValue_ptr)g_aalFuncTable[CSSM_GETTIMEVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, TimeAlgorithm, TimeData);
}

CSSM_RETURN CSSMAPI CSSM_CSP_GetOperationalStatistics(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_CSP_OPERATIONAL_STATISTICS *Statistics )
{
    CSSM_CSP_GetOperationalStatistics_ptr FuncPtr = (CSSM_CSP_GetOperationalStatistics_ptr)g_aalFuncTable[CSSM_CSP_GETOPERATIONALSTATISTICS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Statistics);
}

CSSM_RETURN CSSMAPI CSSM_CSP_GetLoginAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_STRING *SelectionTag,
                    uint32 *NumberOfAclInfos,
                    CSSM_ACL_ENTRY_INFO_PTR *AclInfos )
{
    CSSM_CSP_GetLoginAcl_ptr FuncPtr = (CSSM_CSP_GetLoginAcl_ptr)g_aalFuncTable[CSSM_CSP_GETLOGINACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, SelectionTag, NumberOfAclInfos, AclInfos);
}

CSSM_RETURN CSSMAPI CSSM_GetKeyAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *Key,
                    const CSSM_STRING *SelectionTag,
                    uint32 *NumberOfAclInfos,
                    CSSM_ACL_ENTRY_INFO_PTR *AclInfos )
{
    CSSM_GetKeyAcl_ptr FuncPtr = (CSSM_GetKeyAcl_ptr)g_aalFuncTable[CSSM_GETKEYACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Key, SelectionTag, NumberOfAclInfos, AclInfos);
}

CSSM_RETURN CSSMAPI CSSM_ChangeKeyAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_EDIT *AclEdit,
                    const CSSM_KEY *Key )
{
    CSSM_ChangeKeyAcl_ptr FuncPtr = (CSSM_ChangeKeyAcl_ptr)g_aalFuncTable[CSSM_CHANGEKEYACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, AclEdit, Key);
}

CSSM_RETURN CSSMAPI CSSM_GetKeyOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *Key,
                    CSSM_ACL_OWNER_PROTOTYPE_PTR Owner )
{
    CSSM_GetKeyOwner_ptr FuncPtr = (CSSM_GetKeyOwner_ptr)g_aalFuncTable[CSSM_GETKEYOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Key, Owner);
}

CSSM_RETURN CSSMAPI CSSM_ChangeKeyOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    const CSSM_ACL_OWNER_PROTOTYPE *NewOwner )
{
    CSSM_ChangeKeyOwner_ptr FuncPtr = (CSSM_ChangeKeyOwner_ptr)g_aalFuncTable[CSSM_CHANGEKEYOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, Key, NewOwner);
}

CSSM_RETURN CSSMAPI CSSM_CSP_GetLoginOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ACL_OWNER_PROTOTYPE_PTR Owner )
{
    CSSM_CSP_GetLoginOwner_ptr FuncPtr = (CSSM_CSP_GetLoginOwner_ptr)g_aalFuncTable[CSSM_CSP_GETLOGINOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, Owner);
}

CSSM_RETURN CSSMAPI CSSM_CSP_ChangeLoginOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_OWNER_PROTOTYPE *NewOwner )
{
    CSSM_CSP_ChangeLoginOwner_ptr FuncPtr = (CSSM_CSP_ChangeLoginOwner_ptr)g_aalFuncTable[CSSM_CSP_CHANGELOGINOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CSPHandle, AccessCred, NewOwner);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertCreateTemplate(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CertFields,
                    CSSM_DATA_PTR CertTemplate )
{
    CSSM_CL_CertCreateTemplate_ptr FuncPtr = (CSSM_CL_CertCreateTemplate_ptr)g_aalFuncTable[CSSM_CL_CERTCREATETEMPLATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfFields, CertFields, CertTemplate);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetAllTemplateFields(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *CertTemplate,
                    uint32 *NumberOfFields,
                    CSSM_FIELD_PTR *CertFields )
{
    CSSM_CL_CertGetAllTemplateFields_ptr FuncPtr = (CSSM_CL_CertGetAllTemplateFields_ptr)g_aalFuncTable[CSSM_CL_CERTGETALLTEMPLATEFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CertTemplate, NumberOfFields, CertFields);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertSign(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CertTemplate,
                    const CSSM_FIELD *SignScope,
                    uint32 ScopeSize,
                    CSSM_DATA_PTR SignedCert )
{
    CSSM_CL_CertSign_ptr FuncPtr = (CSSM_CL_CertSign_ptr)g_aalFuncTable[CSSM_CL_CERTSIGN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CertTemplate, SignScope, ScopeSize, SignedCert);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertVerify(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CertToBeVerified,
                    const CSSM_DATA *SignerCert,
                    const CSSM_FIELD *VerifyScope,
                    uint32 ScopeSize )
{
    CSSM_CL_CertVerify_ptr FuncPtr = (CSSM_CL_CertVerify_ptr)g_aalFuncTable[CSSM_CL_CERTVERIFY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CertToBeVerified, SignerCert, VerifyScope, ScopeSize);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertVerifyWithKey(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CertToBeVerified )
{
    CSSM_CL_CertVerifyWithKey_ptr FuncPtr = (CSSM_CL_CertVerifyWithKey_ptr)g_aalFuncTable[CSSM_CL_CERTVERIFYWITHKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CertToBeVerified);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetFirstFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    const CSSM_OID *CertField,
                    CSSM_HANDLE_PTR ResultsHandle,
                    uint32 *NumberOfMatchedFields,
                    CSSM_DATA_PTR *Value )
{
    CSSM_CL_CertGetFirstFieldValue_ptr FuncPtr = (CSSM_CL_CertGetFirstFieldValue_ptr)g_aalFuncTable[CSSM_CL_CERTGETFIRSTFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, CertField, ResultsHandle, NumberOfMatchedFields, Value);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetNextFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle,
                    CSSM_DATA_PTR *Value )
{
    CSSM_CL_CertGetNextFieldValue_ptr FuncPtr = (CSSM_CL_CertGetNextFieldValue_ptr)g_aalFuncTable[CSSM_CL_CERTGETNEXTFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle, Value);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertAbortQuery(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle )
{
    CSSM_CL_CertAbortQuery_ptr FuncPtr = (CSSM_CL_CertAbortQuery_ptr)g_aalFuncTable[CSSM_CL_CERTABORTQUERY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetKeyInfo(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    CSSM_KEY_PTR *Key )
{
    CSSM_CL_CertGetKeyInfo_ptr FuncPtr = (CSSM_CL_CertGetKeyInfo_ptr)g_aalFuncTable[CSSM_CL_CERTGETKEYINFO].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, Key);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetAllFields(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    uint32 *NumberOfFields,
                    CSSM_FIELD_PTR *FieldList )
{
    CSSM_CL_CertGetAllFields_ptr FuncPtr = (CSSM_CL_CertGetAllFields_ptr)g_aalFuncTable[CSSM_CL_CERTGETALLFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, NumberOfFields, FieldList);
}

CSSM_RETURN CSSMAPI CSSM_CL_FreeFields(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    CSSM_FIELD_PTR FieldArray )
{
    CSSM_CL_FreeFields_ptr FuncPtr = (CSSM_CL_FreeFields_ptr)g_aalFuncTable[CSSM_CL_FREEFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfFields, FieldArray);
}

CSSM_RETURN CSSMAPI CSSM_CL_FreeFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_OID *CertOrCrlOid,
                    CSSM_DATA_PTR Value )
{
    CSSM_CL_FreeFieldValue_ptr FuncPtr = (CSSM_CL_FreeFieldValue_ptr)g_aalFuncTable[CSSM_CL_FREEFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CertOrCrlOid, Value);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertCache(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    CSSM_HANDLE_PTR CertHandle )
{
    CSSM_CL_CertCache_ptr FuncPtr = (CSSM_CL_CertCache_ptr)g_aalFuncTable[CSSM_CL_CERTCACHE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, CertHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetFirstCachedFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE CertHandle,
                    const CSSM_OID *CertField,
                    CSSM_HANDLE_PTR ResultsHandle,
                    uint32 *NumberOfMatchedFields,
                    CSSM_DATA_PTR *FieldValue )
{
    CSSM_CL_CertGetFirstCachedFieldValue_ptr FuncPtr = (CSSM_CL_CertGetFirstCachedFieldValue_ptr)g_aalFuncTable[CSSM_CL_CERTGETFIRSTCACHEDFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CertHandle, CertField, ResultsHandle, NumberOfMatchedFields, FieldValue);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGetNextCachedFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle,
                    CSSM_DATA_PTR *FieldValue )
{
    CSSM_CL_CertGetNextCachedFieldValue_ptr FuncPtr = (CSSM_CL_CertGetNextCachedFieldValue_ptr)g_aalFuncTable[CSSM_CL_CERTGETNEXTCACHEDFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle, FieldValue);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertAbortCache(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE CertHandle )
{
    CSSM_CL_CertAbortCache_ptr FuncPtr = (CSSM_CL_CertAbortCache_ptr)g_aalFuncTable[CSSM_CL_CERTABORTCACHE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CertHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGroupToSignedBundle(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_CERTGROUP *CertGroupToBundle,
                    const CSSM_CERT_BUNDLE_HEADER *BundleInfo,
                    CSSM_DATA_PTR SignedBundle )
{
    CSSM_CL_CertGroupToSignedBundle_ptr FuncPtr = (CSSM_CL_CertGroupToSignedBundle_ptr)g_aalFuncTable[CSSM_CL_CERTGROUPTOSIGNEDBUNDLE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CertGroupToBundle, BundleInfo, SignedBundle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertGroupFromVerifiedBundle(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_CERT_BUNDLE *CertBundle,
                    const CSSM_DATA *SignerCert,
                    CSSM_CERTGROUP_PTR *CertGroup )
{
    CSSM_CL_CertGroupFromVerifiedBundle_ptr FuncPtr = (CSSM_CL_CertGroupFromVerifiedBundle_ptr)g_aalFuncTable[CSSM_CL_CERTGROUPFROMVERIFIEDBUNDLE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CertBundle, SignerCert, CertGroup);
}

CSSM_RETURN CSSMAPI CSSM_CL_CertDescribeFormat(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 *NumberOfOids,
                    CSSM_OID_PTR *OidList )
{
    CSSM_CL_CertDescribeFormat_ptr FuncPtr = (CSSM_CL_CertDescribeFormat_ptr)g_aalFuncTable[CSSM_CL_CERTDESCRIBEFORMAT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfOids, OidList);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlCreateTemplate(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CrlTemplate,
                    CSSM_DATA_PTR NewCrl )
{
    CSSM_CL_CrlCreateTemplate_ptr FuncPtr = (CSSM_CL_CrlCreateTemplate_ptr)g_aalFuncTable[CSSM_CL_CRLCREATETEMPLATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfFields, CrlTemplate, NewCrl);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlSetFields(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CrlTemplate,
                    const CSSM_DATA *OldCrl,
                    CSSM_DATA_PTR ModifiedCrl )
{
    CSSM_CL_CrlSetFields_ptr FuncPtr = (CSSM_CL_CrlSetFields_ptr)g_aalFuncTable[CSSM_CL_CRLSETFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfFields, CrlTemplate, OldCrl, ModifiedCrl);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlAddCert(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *Cert,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CrlEntryFields,
                    const CSSM_DATA *OldCrl,
                    CSSM_DATA_PTR NewCrl )
{
    CSSM_CL_CrlAddCert_ptr FuncPtr = (CSSM_CL_CrlAddCert_ptr)g_aalFuncTable[CSSM_CL_CRLADDCERT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, Cert, NumberOfFields, CrlEntryFields, OldCrl, NewCrl);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlRemoveCert(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    const CSSM_DATA *OldCrl,
                    CSSM_DATA_PTR NewCrl )
{
    CSSM_CL_CrlRemoveCert_ptr FuncPtr = (CSSM_CL_CrlRemoveCert_ptr)g_aalFuncTable[CSSM_CL_CRLREMOVECERT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, OldCrl, NewCrl);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlSign(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *UnsignedCrl,
                    const CSSM_FIELD *SignScope,
                    uint32 ScopeSize,
                    CSSM_DATA_PTR SignedCrl )
{
    CSSM_CL_CrlSign_ptr FuncPtr = (CSSM_CL_CrlSign_ptr)g_aalFuncTable[CSSM_CL_CRLSIGN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, UnsignedCrl, SignScope, ScopeSize, SignedCrl);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlVerify(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CrlToBeVerified,
                    const CSSM_DATA *SignerCert,
                    const CSSM_FIELD *VerifyScope,
                    uint32 ScopeSize )
{
    CSSM_CL_CrlVerify_ptr FuncPtr = (CSSM_CL_CrlVerify_ptr)g_aalFuncTable[CSSM_CL_CRLVERIFY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CrlToBeVerified, SignerCert, VerifyScope, ScopeSize);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlVerifyWithKey(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CrlToBeVerified )
{
    CSSM_CL_CrlVerifyWithKey_ptr FuncPtr = (CSSM_CL_CrlVerifyWithKey_ptr)g_aalFuncTable[CSSM_CL_CRLVERIFYWITHKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, CrlToBeVerified);
}

CSSM_RETURN CSSMAPI CSSM_CL_IsCertInCrl(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    const CSSM_DATA *Crl,
                    CSSM_BOOL *CertFound )
{
    CSSM_CL_IsCertInCrl_ptr FuncPtr = (CSSM_CL_IsCertInCrl_ptr)g_aalFuncTable[CSSM_CL_ISCERTINCRL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, Crl, CertFound);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetFirstFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Crl,
                    const CSSM_OID *CrlField,
                    CSSM_HANDLE_PTR ResultsHandle,
                    uint32 *NumberOfMatchedFields,
                    CSSM_DATA_PTR *Value )
{
    CSSM_CL_CrlGetFirstFieldValue_ptr FuncPtr = (CSSM_CL_CrlGetFirstFieldValue_ptr)g_aalFuncTable[CSSM_CL_CRLGETFIRSTFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Crl, CrlField, ResultsHandle, NumberOfMatchedFields, Value);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetNextFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle,
                    CSSM_DATA_PTR *Value )
{
    CSSM_CL_CrlGetNextFieldValue_ptr FuncPtr = (CSSM_CL_CrlGetNextFieldValue_ptr)g_aalFuncTable[CSSM_CL_CRLGETNEXTFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle, Value);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlAbortQuery(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle )
{
    CSSM_CL_CrlAbortQuery_ptr FuncPtr = (CSSM_CL_CrlAbortQuery_ptr)g_aalFuncTable[CSSM_CL_CRLABORTQUERY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetAllFields(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Crl,
                    uint32 *NumberOfCrlFields,
                    CSSM_FIELD_PTR *CrlFields )
{
    CSSM_CL_CrlGetAllFields_ptr FuncPtr = (CSSM_CL_CrlGetAllFields_ptr)g_aalFuncTable[CSSM_CL_CRLGETALLFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Crl, NumberOfCrlFields, CrlFields);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlCache(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Crl,
                    CSSM_HANDLE_PTR CrlHandle )
{
    CSSM_CL_CrlCache_ptr FuncPtr = (CSSM_CL_CrlCache_ptr)g_aalFuncTable[CSSM_CL_CRLCACHE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Crl, CrlHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_IsCertInCachedCrl(
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *Cert,
                    CSSM_HANDLE CrlHandle,
                    CSSM_BOOL *CertFound,
                    CSSM_DATA_PTR CrlRecordIndex )
{
    CSSM_CL_IsCertInCachedCrl_ptr FuncPtr = (CSSM_CL_IsCertInCachedCrl_ptr)g_aalFuncTable[CSSM_CL_ISCERTINCACHEDCRL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, Cert, CrlHandle, CertFound, CrlRecordIndex);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetFirstCachedFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE CrlHandle,
                    const CSSM_DATA *CrlRecordIndex,
                    const CSSM_OID *CrlField,
                    CSSM_HANDLE_PTR ResultsHandle,
                    uint32 *NumberOfMatchedFields,
                    CSSM_DATA_PTR *FieldValue )
{
    CSSM_CL_CrlGetFirstCachedFieldValue_ptr FuncPtr = (CSSM_CL_CrlGetFirstCachedFieldValue_ptr)g_aalFuncTable[CSSM_CL_CRLGETFIRSTCACHEDFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CrlHandle, CrlRecordIndex, CrlField, ResultsHandle, NumberOfMatchedFields, FieldValue);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetNextCachedFieldValue(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE ResultsHandle,
                    CSSM_DATA_PTR *FieldValue )
{
    CSSM_CL_CrlGetNextCachedFieldValue_ptr FuncPtr = (CSSM_CL_CrlGetNextCachedFieldValue_ptr)g_aalFuncTable[CSSM_CL_CRLGETNEXTCACHEDFIELDVALUE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, ResultsHandle, FieldValue);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlGetAllCachedRecordFields(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE CrlHandle,
                    const CSSM_DATA *CrlRecordIndex,
                    uint32 *NumberOfFields,
                    CSSM_FIELD_PTR *Fields )
{
    CSSM_CL_CrlGetAllCachedRecordFields_ptr FuncPtr = (CSSM_CL_CrlGetAllCachedRecordFields_ptr)g_aalFuncTable[CSSM_CL_CRLGETALLCACHEDRECORDFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CrlHandle, CrlRecordIndex, NumberOfFields, Fields);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlAbortCache(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_HANDLE CrlHandle )
{
    CSSM_CL_CrlAbortCache_ptr FuncPtr = (CSSM_CL_CrlAbortCache_ptr)g_aalFuncTable[CSSM_CL_CRLABORTCACHE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CrlHandle);
}

CSSM_RETURN CSSMAPI CSSM_CL_CrlDescribeFormat(
                    CSSM_CL_HANDLE CLHandle,
                    uint32 *NumberOfOids,
                    CSSM_OID_PTR *OidList )
{
    CSSM_CL_CrlDescribeFormat_ptr FuncPtr = (CSSM_CL_CrlDescribeFormat_ptr)g_aalFuncTable[CSSM_CL_CRLDESCRIBEFORMAT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, NumberOfOids, OidList);
}

CSSM_RETURN CSSMAPI CSSM_CL_PassThrough(
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    uint32 PassThroughId,
                    const void *InputParams,
                    void **OutputParams )
{
    CSSM_CL_PassThrough_ptr FuncPtr = (CSSM_CL_PassThrough_ptr)g_aalFuncTable[CSSM_CL_PASSTHROUGH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(CLHandle, CCHandle, PassThroughId, InputParams, OutputParams);
}

CSSM_RETURN CSSMAPI CSSM_DL_DbOpen(
                    CSSM_DL_HANDLE DLHandle,
                    const char *DbName,
                    const CSSM_NET_ADDRESS *DbLocation,
                    CSSM_DB_ACCESS_TYPE AccessRequest,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const void *OpenParameters,
                    CSSM_DB_HANDLE *DbHandle )
{
    CSSM_DL_DbOpen_ptr FuncPtr = (CSSM_DL_DbOpen_ptr)g_aalFuncTable[CSSM_DL_DBOPEN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLHandle, DbName, DbLocation, AccessRequest, AccessCred, OpenParameters, DbHandle);
}

CSSM_RETURN CSSMAPI CSSM_DL_DbClose(
                    CSSM_DL_DB_HANDLE DLDBHandle )
{
    CSSM_DL_DbClose_ptr FuncPtr = (CSSM_DL_DbClose_ptr)g_aalFuncTable[CSSM_DL_DBCLOSE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle);
}

CSSM_RETURN CSSMAPI CSSM_DL_DbCreate(
                    CSSM_DL_HANDLE DLHandle,
                    const char *DbName,
                    const CSSM_NET_ADDRESS *DbLocation,
                    const CSSM_DBINFO *DBInfo,
                    CSSM_DB_ACCESS_TYPE AccessRequest,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    const void *OpenParameters,
                    CSSM_DB_HANDLE *DbHandle )
{
    CSSM_DL_DbCreate_ptr FuncPtr = (CSSM_DL_DbCreate_ptr)g_aalFuncTable[CSSM_DL_DBCREATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLHandle, DbName, DbLocation, DBInfo, AccessRequest, CredAndAclEntry, OpenParameters, DbHandle);
}

CSSM_RETURN CSSMAPI CSSM_DL_DbDelete(
                    CSSM_DL_HANDLE DLHandle,
                    const char *DbName,
                    const CSSM_NET_ADDRESS *DbLocation,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred )
{
    CSSM_DL_DbDelete_ptr FuncPtr = (CSSM_DL_DbDelete_ptr)g_aalFuncTable[CSSM_DL_DBDELETE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLHandle, DbName, DbLocation, AccessCred);
}

CSSM_RETURN CSSMAPI CSSM_DL_Authenticate(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_ACCESS_TYPE AccessRequest,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred )
{
    CSSM_DL_Authenticate_ptr FuncPtr = (CSSM_DL_Authenticate_ptr)g_aalFuncTable[CSSM_DL_AUTHENTICATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, AccessRequest, AccessCred);
}

CSSM_RETURN CSSMAPI CSSM_DL_GetDbAcl(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    const CSSM_STRING *SelectionTag,
                    uint32 *NumberOfAclInfos,
                    CSSM_ACL_ENTRY_INFO_PTR *AclInfos )
{
    CSSM_DL_GetDbAcl_ptr FuncPtr = (CSSM_DL_GetDbAcl_ptr)g_aalFuncTable[CSSM_DL_GETDBACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, SelectionTag, NumberOfAclInfos, AclInfos);
}

CSSM_RETURN CSSMAPI CSSM_DL_ChangeDbAcl(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_EDIT *AclEdit )
{
    CSSM_DL_ChangeDbAcl_ptr FuncPtr = (CSSM_DL_ChangeDbAcl_ptr)g_aalFuncTable[CSSM_DL_CHANGEDBACL].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, AccessCred, AclEdit);
}

CSSM_RETURN CSSMAPI CSSM_DL_GetDbOwner(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_ACL_OWNER_PROTOTYPE_PTR Owner )
{
    CSSM_DL_GetDbOwner_ptr FuncPtr = (CSSM_DL_GetDbOwner_ptr)g_aalFuncTable[CSSM_DL_GETDBOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, Owner);
}

CSSM_RETURN CSSMAPI CSSM_DL_ChangeDbOwner(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_OWNER_PROTOTYPE *NewOwner )
{
    CSSM_DL_ChangeDbOwner_ptr FuncPtr = (CSSM_DL_ChangeDbOwner_ptr)g_aalFuncTable[CSSM_DL_CHANGEDBOWNER].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, AccessCred, NewOwner);
}

CSSM_RETURN CSSMAPI CSSM_DL_GetDbNames(
                    CSSM_DL_HANDLE DLHandle,
                    CSSM_NAME_LIST_PTR *NameList )
{
    CSSM_DL_GetDbNames_ptr FuncPtr = (CSSM_DL_GetDbNames_ptr)g_aalFuncTable[CSSM_DL_GETDBNAMES].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLHandle, NameList);
}

CSSM_RETURN CSSMAPI CSSM_DL_GetDbNameFromHandle(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    char ** DbName )
{
    CSSM_DL_GetDbNameFromHandle_ptr FuncPtr = (CSSM_DL_GetDbNameFromHandle_ptr)g_aalFuncTable[CSSM_DL_GETDBNAMEFROMHANDLE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, DbName);
}

CSSM_RETURN CSSMAPI CSSM_DL_FreeNameList(
                    CSSM_DL_HANDLE DLHandle,
                    CSSM_NAME_LIST_PTR NameList )
{
    CSSM_DL_FreeNameList_ptr FuncPtr = (CSSM_DL_FreeNameList_ptr)g_aalFuncTable[CSSM_DL_FREENAMELIST].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLHandle, NameList);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataInsert(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_RECORDTYPE RecordType,
                    const CSSM_DB_RECORD_ATTRIBUTE_DATA *Attributes,
                    const CSSM_DATA *Data,
                    CSSM_DB_UNIQUE_RECORD_PTR *UniqueId )
{
    CSSM_DL_DataInsert_ptr FuncPtr = (CSSM_DL_DataInsert_ptr)g_aalFuncTable[CSSM_DL_DATAINSERT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, RecordType, Attributes, Data, UniqueId);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataDelete(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    const CSSM_DB_UNIQUE_RECORD *UniqueRecordIdentifier )
{
    CSSM_DL_DataDelete_ptr FuncPtr = (CSSM_DL_DataDelete_ptr)g_aalFuncTable[CSSM_DL_DATADELETE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, UniqueRecordIdentifier);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataModify(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_RECORDTYPE RecordType,
                    CSSM_DB_UNIQUE_RECORD_PTR UniqueRecordIdentifier,
                    const CSSM_DB_RECORD_ATTRIBUTE_DATA *AttributesToBeModified,
                    const CSSM_DATA *DataToBeModified,
                    CSSM_DB_MODIFY_MODE ModifyMode )
{
    CSSM_DL_DataModify_ptr FuncPtr = (CSSM_DL_DataModify_ptr)g_aalFuncTable[CSSM_DL_DATAMODIFY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, RecordType, UniqueRecordIdentifier, AttributesToBeModified, DataToBeModified, ModifyMode);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataGetFirst(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    const CSSM_QUERY *Query,
                    CSSM_HANDLE_PTR ResultsHandle,
                    CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
                    CSSM_DATA_PTR Data,
                    CSSM_DB_UNIQUE_RECORD_PTR *UniqueId )
{
    CSSM_DL_DataGetFirst_ptr FuncPtr = (CSSM_DL_DataGetFirst_ptr)g_aalFuncTable[CSSM_DL_DATAGETFIRST].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, Query, ResultsHandle, Attributes, Data, UniqueId);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataGetNext(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_HANDLE ResultsHandle,
                    CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
                    CSSM_DATA_PTR Data,
                    CSSM_DB_UNIQUE_RECORD_PTR *UniqueId )
{
    CSSM_DL_DataGetNext_ptr FuncPtr = (CSSM_DL_DataGetNext_ptr)g_aalFuncTable[CSSM_DL_DATAGETNEXT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, ResultsHandle, Attributes, Data, UniqueId);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataAbortQuery(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_HANDLE ResultsHandle )
{
    CSSM_DL_DataAbortQuery_ptr FuncPtr = (CSSM_DL_DataAbortQuery_ptr)g_aalFuncTable[CSSM_DL_DATAABORTQUERY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, ResultsHandle);
}

CSSM_RETURN CSSMAPI CSSM_DL_DataGetFromUniqueRecordId(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord,
                    CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
                    CSSM_DATA_PTR Data )
{
    CSSM_DL_DataGetFromUniqueRecordId_ptr FuncPtr = (CSSM_DL_DataGetFromUniqueRecordId_ptr)g_aalFuncTable[CSSM_DL_DATAGETFROMUNIQUERECORDID].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, UniqueRecord, Attributes, Data);
}

CSSM_RETURN CSSMAPI CSSM_DL_FreeUniqueRecord(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord )
{
    CSSM_DL_FreeUniqueRecord_ptr FuncPtr = (CSSM_DL_FreeUniqueRecord_ptr)g_aalFuncTable[CSSM_DL_FREEUNIQUERECORD].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, UniqueRecord);
}

CSSM_RETURN CSSMAPI CSSM_DL_CreateRelation(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_RECORDTYPE RelationID,
                    const char *RelationName,
                    uint32 NumberOfAttributes,
                    const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo,
                    uint32 NumberOfIndexes,
                    const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo )
{
    CSSM_DL_CreateRelation_ptr FuncPtr = (CSSM_DL_CreateRelation_ptr)g_aalFuncTable[CSSM_DL_CREATERELATION].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, RelationID, RelationName, NumberOfAttributes, pAttributeInfo, NumberOfIndexes, pIndexInfo);
}

CSSM_RETURN CSSMAPI CSSM_DL_DestroyRelation(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    CSSM_DB_RECORDTYPE RelationID )
{
    CSSM_DL_DestroyRelation_ptr FuncPtr = (CSSM_DL_DestroyRelation_ptr)g_aalFuncTable[CSSM_DL_DESTROYRELATION].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, RelationID);
}

CSSM_RETURN CSSMAPI CSSM_DL_PassThrough(
                    CSSM_DL_DB_HANDLE DLDBHandle,
                    uint32 PassThroughId,
                    const void *InputParams,
                    void **OutputParams )
{
    CSSM_DL_PassThrough_ptr FuncPtr = (CSSM_DL_PassThrough_ptr)g_aalFuncTable[CSSM_DL_PASSTHROUGH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(DLDBHandle, PassThroughId, InputParams, OutputParams);
}

CSSM_RETURN CSSMAPI CSSM_TP_SubmitCredRequest(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_TP_AUTHORITY_ID *PreferredAuthority,
                    CSSM_TP_AUTHORITY_REQUEST_TYPE RequestType,
                    const CSSM_TP_REQUEST_SET *RequestInput,
                    const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthContext,
                    sint32 *EstimatedTime,
                    CSSM_DATA_PTR ReferenceIdentifier )
{
    CSSM_TP_SubmitCredRequest_ptr FuncPtr = (CSSM_TP_SubmitCredRequest_ptr)g_aalFuncTable[CSSM_TP_SUBMITCREDREQUEST].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, PreferredAuthority, RequestType, RequestInput, CallerAuthContext, EstimatedTime, ReferenceIdentifier);
}

CSSM_RETURN CSSMAPI CSSM_TP_RetrieveCredResult(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_DATA *ReferenceIdentifier,
                    const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials,
                    sint32 *EstimatedTime,
                    CSSM_BOOL *ConfirmationRequired,
                    CSSM_TP_RESULT_SET_PTR *RetrieveOutput )
{
    CSSM_TP_RetrieveCredResult_ptr FuncPtr = (CSSM_TP_RetrieveCredResult_ptr)g_aalFuncTable[CSSM_TP_RETRIEVECREDRESULT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, ReferenceIdentifier, CallerAuthCredentials, EstimatedTime, ConfirmationRequired, RetrieveOutput);
}

CSSM_RETURN CSSMAPI CSSM_TP_ConfirmCredResult(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_DATA *ReferenceIdentifier,
                    const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials,
                    const CSSM_TP_CONFIRM_RESPONSE *Responses,
                    const CSSM_TP_AUTHORITY_ID *PreferredAuthority )
{
    CSSM_TP_ConfirmCredResult_ptr FuncPtr = (CSSM_TP_ConfirmCredResult_ptr)g_aalFuncTable[CSSM_TP_CONFIRMCREDRESULT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, ReferenceIdentifier, CallerAuthCredentials, Responses, PreferredAuthority);
}

CSSM_RETURN CSSMAPI CSSM_TP_ReceiveConfirmation(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_DATA *ReferenceIdentifier,
                    CSSM_TP_CONFIRM_RESPONSE_PTR *Responses,
                    sint32 *ElapsedTime )
{
    CSSM_TP_ReceiveConfirmation_ptr FuncPtr = (CSSM_TP_ReceiveConfirmation_ptr)g_aalFuncTable[CSSM_TP_RECEIVECONFIRMATION].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, ReferenceIdentifier, Responses, ElapsedTime);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertReclaimKey(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_CERTGROUP *CertGroup,
                    uint32 CertIndex,
                    CSSM_LONG_HANDLE KeyCacheHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry )
{
    CSSM_TP_CertReclaimKey_ptr FuncPtr = (CSSM_TP_CertReclaimKey_ptr)g_aalFuncTable[CSSM_TP_CERTRECLAIMKEY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CertGroup, CertIndex, KeyCacheHandle, CSPHandle, CredAndAclEntry);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertReclaimAbort(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_LONG_HANDLE KeyCacheHandle )
{
    CSSM_TP_CertReclaimAbort_ptr FuncPtr = (CSSM_TP_CertReclaimAbort_ptr)g_aalFuncTable[CSSM_TP_CERTRECLAIMABORT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, KeyCacheHandle);
}

CSSM_RETURN CSSMAPI CSSM_TP_FormRequest(
                    CSSM_TP_HANDLE TPHandle,
                    const CSSM_TP_AUTHORITY_ID *PreferredAuthority,
                    CSSM_TP_FORM_TYPE FormType,
                    CSSM_DATA_PTR BlankForm )
{
    CSSM_TP_FormRequest_ptr FuncPtr = (CSSM_TP_FormRequest_ptr)g_aalFuncTable[CSSM_TP_FORMREQUEST].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, PreferredAuthority, FormType, BlankForm);
}

CSSM_RETURN CSSMAPI CSSM_TP_FormSubmit(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_TP_FORM_TYPE FormType,
                    const CSSM_DATA *Form,
                    const CSSM_TP_AUTHORITY_ID *ClearanceAuthority,
                    const CSSM_TP_AUTHORITY_ID *RepresentedAuthority,
                    CSSM_ACCESS_CREDENTIALS_PTR Credentials )
{
    CSSM_TP_FormSubmit_ptr FuncPtr = (CSSM_TP_FormSubmit_ptr)g_aalFuncTable[CSSM_TP_FORMSUBMIT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, FormType, Form, ClearanceAuthority, RepresentedAuthority, Credentials);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertGroupVerify(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_CERTGROUP *CertGroupToBeVerified,
                    const CSSM_TP_VERIFY_CONTEXT *VerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR VerifyContextResult )
{
    CSSM_TP_CertGroupVerify_ptr FuncPtr = (CSSM_TP_CertGroupVerify_ptr)g_aalFuncTable[CSSM_TP_CERTGROUPVERIFY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, CertGroupToBeVerified, VerifyContext, VerifyContextResult);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertCreateTemplate(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CertFields,
                    CSSM_DATA_PTR CertTemplate )
{
    CSSM_TP_CertCreateTemplate_ptr FuncPtr = (CSSM_TP_CertCreateTemplate_ptr)g_aalFuncTable[CSSM_TP_CERTCREATETEMPLATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, NumberOfFields, CertFields, CertTemplate);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertGetAllTemplateFields(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DATA *CertTemplate,
                    uint32 *NumberOfFields,
                    CSSM_FIELD_PTR *CertFields )
{
    CSSM_TP_CertGetAllTemplateFields_ptr FuncPtr = (CSSM_TP_CertGetAllTemplateFields_ptr)g_aalFuncTable[CSSM_TP_CERTGETALLTEMPLATEFIELDS].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CertTemplate, NumberOfFields, CertFields);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertSign(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DATA *CertTemplateToBeSigned,
                    const CSSM_CERTGROUP *SignerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult,
                    CSSM_DATA_PTR SignedCert )
{
    CSSM_TP_CertSign_ptr FuncPtr = (CSSM_TP_CertSign_ptr)g_aalFuncTable[CSSM_TP_CERTSIGN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CCHandle, CertTemplateToBeSigned, SignerCertGroup, SignerVerifyContext, SignerVerifyResult, SignedCert);
}

CSSM_RETURN CSSMAPI CSSM_TP_CrlVerify(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ENCODED_CRL *CrlToBeVerified,
                    const CSSM_CERTGROUP *SignerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *VerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult )
{
    CSSM_TP_CrlVerify_ptr FuncPtr = (CSSM_TP_CrlVerify_ptr)g_aalFuncTable[CSSM_TP_CRLVERIFY].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, CrlToBeVerified, SignerCertGroup, VerifyContext, RevokerVerifyResult);
}

CSSM_RETURN CSSMAPI CSSM_TP_CrlCreateTemplate(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    uint32 NumberOfFields,
                    const CSSM_FIELD *CrlFields,
                    CSSM_DATA_PTR NewCrlTemplate )
{
    CSSM_TP_CrlCreateTemplate_ptr FuncPtr = (CSSM_TP_CrlCreateTemplate_ptr)g_aalFuncTable[CSSM_TP_CRLCREATETEMPLATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, NumberOfFields, CrlFields, NewCrlTemplate);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertRevoke(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_DATA *OldCrlTemplate,
                    const CSSM_CERTGROUP *CertGroupToBeRevoked,
                    const CSSM_CERTGROUP *RevokerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult,
                    CSSM_TP_CERTCHANGE_REASON Reason,
                    CSSM_DATA_PTR NewCrlTemplate )
{
    CSSM_TP_CertRevoke_ptr FuncPtr = (CSSM_TP_CertRevoke_ptr)g_aalFuncTable[CSSM_TP_CERTREVOKE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, OldCrlTemplate, CertGroupToBeRevoked, RevokerCertGroup, RevokerVerifyContext, RevokerVerifyResult, Reason, NewCrlTemplate);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertRemoveFromCrlTemplate(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_DATA *OldCrlTemplate,
                    const CSSM_CERTGROUP *CertGroupToBeRemoved,
                    const CSSM_CERTGROUP *RevokerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult,
                    CSSM_DATA_PTR NewCrlTemplate )
{
    CSSM_TP_CertRemoveFromCrlTemplate_ptr FuncPtr = (CSSM_TP_CertRemoveFromCrlTemplate_ptr)g_aalFuncTable[CSSM_TP_CERTREMOVEFROMCRLTEMPLATE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, OldCrlTemplate, CertGroupToBeRemoved, RevokerCertGroup, RevokerVerifyContext, RevokerVerifyResult, NewCrlTemplate);
}

CSSM_RETURN CSSMAPI CSSM_TP_CrlSign(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_ENCODED_CRL *CrlToBeSigned,
                    const CSSM_CERTGROUP *SignerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult,
                    CSSM_DATA_PTR SignedCrl )
{
    CSSM_TP_CrlSign_ptr FuncPtr = (CSSM_TP_CrlSign_ptr)g_aalFuncTable[CSSM_TP_CRLSIGN].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CCHandle, CrlToBeSigned, SignerCertGroup, SignerVerifyContext, SignerVerifyResult, SignedCrl);
}

CSSM_RETURN CSSMAPI CSSM_TP_ApplyCrlToDb(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ENCODED_CRL *CrlToBeApplied,
                    const CSSM_CERTGROUP *SignerCertGroup,
                    const CSSM_TP_VERIFY_CONTEXT *ApplyCrlVerifyContext,
                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR ApplyCrlVerifyResult )
{
    CSSM_TP_ApplyCrlToDb_ptr FuncPtr = (CSSM_TP_ApplyCrlToDb_ptr)g_aalFuncTable[CSSM_TP_APPLYCRLTODB].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, CrlToBeApplied, SignerCertGroup, ApplyCrlVerifyContext, ApplyCrlVerifyResult);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertGroupConstruct(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_DL_DB_LIST *DBList,
                    const void *ConstructParams,
                    const CSSM_CERTGROUP *CertGroupFrag,
                    CSSM_CERTGROUP_PTR *CertGroup )
{
    CSSM_TP_CertGroupConstruct_ptr FuncPtr = (CSSM_TP_CertGroupConstruct_ptr)g_aalFuncTable[CSSM_TP_CERTGROUPCONSTRUCT].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CSPHandle, DBList, ConstructParams, CertGroupFrag, CertGroup);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertGroupPrune(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_DL_DB_LIST *DBList,
                    const CSSM_CERTGROUP *OrderedCertGroup,
                    CSSM_CERTGROUP_PTR *PrunedCertGroup )
{
    CSSM_TP_CertGroupPrune_ptr FuncPtr = (CSSM_TP_CertGroupPrune_ptr)g_aalFuncTable[CSSM_TP_CERTGROUPPRUNE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, DBList, OrderedCertGroup, PrunedCertGroup);
}

CSSM_RETURN CSSMAPI CSSM_TP_CertGroupToTupleGroup(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_CERTGROUP *CertGroup,
                    CSSM_TUPLEGROUP_PTR *TupleGroup )
{
    CSSM_TP_CertGroupToTupleGroup_ptr FuncPtr = (CSSM_TP_CertGroupToTupleGroup_ptr)g_aalFuncTable[CSSM_TP_CERTGROUPTOTUPLEGROUP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CertGroup, TupleGroup);
}

CSSM_RETURN CSSMAPI CSSM_TP_TupleGroupToCertGroup(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    const CSSM_TUPLEGROUP *TupleGroup,
                    CSSM_CERTGROUP_PTR *CertTemplates )
{
    CSSM_TP_TupleGroupToCertGroup_ptr FuncPtr = (CSSM_TP_TupleGroupToCertGroup_ptr)g_aalFuncTable[CSSM_TP_TUPLEGROUPTOCERTGROUP].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, TupleGroup, CertTemplates);
}

CSSM_RETURN CSSMAPI CSSM_TP_PassThrough(
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DL_DB_LIST *DBList,
                    uint32 PassThroughId,
                    const void *InputParams,
                    void **OutputParams )
{
    CSSM_TP_PassThrough_ptr FuncPtr = (CSSM_TP_PassThrough_ptr)g_aalFuncTable[CSSM_TP_PASSTHROUGH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(TPHandle, CLHandle, CCHandle, DBList, PassThroughId, InputParams, OutputParams);
}

CSSM_RETURN CSSMAPI CSSM_AC_AuthCompute(
                    CSSM_AC_HANDLE ACHandle,
                    const CSSM_TUPLEGROUP *BaseAuthorizations,
                    const CSSM_TUPLEGROUP *Credentials,
                    uint32 NumberOfRequestors,
                    const CSSM_LIST *Requestors,
                    const CSSM_LIST *RequestedAuthorizationPeriod,
                    const CSSM_LIST *RequestedAuthorization,
                    CSSM_TUPLEGROUP_PTR AuthorizationResult )
{
    CSSM_AC_AuthCompute_ptr FuncPtr = (CSSM_AC_AuthCompute_ptr)g_aalFuncTable[CSSM_AC_AUTHCOMPUTE].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ACHandle, BaseAuthorizations, Credentials, NumberOfRequestors, Requestors, RequestedAuthorizationPeriod, RequestedAuthorization, AuthorizationResult);
}

CSSM_RETURN CSSMAPI CSSM_AC_PassThrough(
                    CSSM_AC_HANDLE ACHandle,
                    CSSM_TP_HANDLE TPHandle,
                    CSSM_CL_HANDLE CLHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_DL_DB_LIST *DBList,
                    uint32 PassThroughId,
                    const void *InputParams,
                    void **OutputParams )
{
    CSSM_AC_PassThrough_ptr FuncPtr = (CSSM_AC_PassThrough_ptr)g_aalFuncTable[CSSM_AC_PASSTHROUGH].Address;
    if ( FuncPtr == NULL ) return !CSSM_OK;
    return FuncPtr(ACHandle, TPHandle, CLHandle, CCHandle, DBList, PassThroughId, InputParams, OutputParams);
}