/*-----------------------------------------------------------------------
 * File: FUNCSTUBS.C
 *
 * Copyright (c) 1995-2000 Intel Corporation. All rights reserved.
 *-----------------------------------------------------------------------
 */

#include "maf_include.h"

/* Define each SPI function.
 */
CSSM_RETURN CSSMSPI ADDIN_CSM_EventNotify(
                    CSSM_MODULE_HANDLE CSPHandle,
                    CSSM_CONTEXT_EVENT Event,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_CONTEXT* Context )
{
    return CSSM_OK;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_QuerySize(
                    CSM_SESSION *pSession,
                    CSSM_BOOL Encrypt,
                    uint32 QuerySizeCount,
                    CSSM_QUERY_SIZE_DATA_PTR DataBlock )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_SignData(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_ALGORITHMS DigestAlgorithm,
                    CSSM_DATA_PTR Signature )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_SignDataInit(
                    CSM_SESSION *pSession )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_SignDataUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_SignDataFinal(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR Signature )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_SignDataError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyData(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_ALGORITHMS DigestAlgorithm,
                    const CSSM_DATA *Signature )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyDataInit(
                    CSM_SESSION *pSession )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyDataUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyDataFinal(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *Signature )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_VerifyDataError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_DigestData(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_DATA_PTR Digest )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DigestDataInit(
                    CSM_SESSION *pSession )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DigestDataUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN ADDIN_CSM_DuplicateDigestState( 
                        const CSSM_CONTEXT *pContext,
                        const void *pSrcState,
                        uint32 uSrcStateSize,
                        void *pDestState )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DigestDataFinal(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR Digest )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_DigestDataError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateMac(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    CSSM_DATA_PTR Mac )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateMacInit(
                    CSM_SESSION *pSession )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateMacUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateMacFinal(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR Mac )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_GenerateMacError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyMac(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount,
                    const CSSM_DATA *Mac )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyMacInit(
                    CSM_SESSION *pSession )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyMacUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *DataBufs,
                    uint32 DataBufCount )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyMacFinal(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *Mac )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_VerifyMacError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_EncryptData(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *ClearBufs,
                    uint32 ClearBufCount,
                    CSSM_DATA_PTR CipherBufs,
                    uint32 CipherBufCount,
                    uint32 *bytesEncrypted,
                    CSSM_DATA_PTR RemData,
                    CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_EncryptDataInit(
                    CSM_SESSION *pSession,
                    CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_EncryptDataUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *ClearBufs,
                    uint32 ClearBufCount,
                    CSSM_DATA_PTR CipherBufs,
                    uint32 CipherBufCount,
                    uint32 *bytesEncrypted )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_EncryptDataFinal(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR RemData )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_EncryptDataError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_DecryptData(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *CipherBufs,
                    uint32 CipherBufCount,
                    CSSM_DATA_PTR ClearBufs,
                    uint32 ClearBufCount,
                    uint32 *bytesDecrypted,
                    CSSM_DATA_PTR RemData,
                    CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DecryptDataInit(
                    CSM_SESSION *pSession,
                    CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DecryptDataUpdate(
                    CSM_SESSION *pSession,
                    const CSSM_DATA *CipherBufs,
                    uint32 CipherBufCount,
                    CSSM_DATA_PTR ClearBufs,
                    uint32 ClearBufCount,
                    uint32 *bytesDecrypted )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DecryptDataFinal(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR RemData )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_DecryptDataError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_QueryKeySizeInBits(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_CC_HANDLE CCHandle,
                    const CSSM_CONTEXT * Context,
                    const CSSM_KEY *Key,
                    CSSM_KEY_SIZE_PTR KeySize )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateKey(
                    CSM_SESSION *pSession,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR Key,
					CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateKeyPair(
                    CSM_SESSION *pSession,
                    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 )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateRandom(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR RandomNumber )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

void ADDIN_CSM_GenerateRandomError( CSM_SESSION *pSession )
{

}

CSSM_RETURN CSSMSPI ADDIN_CSM_GenerateAlgorithmParams(
                    CSM_SESSION *pSession,
                    uint32 ParamBits,
                    CSSM_DATA_PTR Param,
                    uint32* NumberOfUpdatedAttributes,
                    CSSM_CONTEXT_ATTRIBUTE_PTR* UpdatedAttributes )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_WrapKey(
                    CSM_SESSION *pSession,
                    const CSSM_ACCESS_CREDENTIALS *Credentials,
                    const CSSM_KEY *Key,
                    const CSSM_DATA *DescriptiveData,
                    CSSM_WRAP_KEY_PTR WrappedKey,
                    CSSM_PRIVILEGE Privilege )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_UnwrapKey(
                    CSM_SESSION *pSession,
                    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 )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_DeriveKey(
                    CSM_SESSION *pSession,
                    CSSM_DATA_PTR Param,
                    uint32 KeyUsage,
                    uint32 KeyAttr,
                    const CSSM_DATA *KeyLabel,
                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                    CSSM_KEY_PTR DerivedKey )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_FreeKey(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    CSSM_KEY_PTR KeyPtr,
                    CSSM_BOOL Delete )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_PassThrough(
                    CSM_SESSION *pSession,
                    uint32 PassThroughId,
                    const void *InData,
                    void **OutData )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_Login(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_DATA *LoginName,
                    const void *Reserved )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_Logout(
                    CSSM_CSP_HANDLE CSPHandle )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_ChangeLoginAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_EDIT *AclEdit )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_ObtainPrivateKeyFromPublicKey(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *PublicKey,
                    CSSM_KEY_PTR PrivateKey )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_RetrieveUniqueId(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_DATA_PTR UniqueID )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_RetrieveCounter(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_DATA_PTR Counter )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_VerifyDevice(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_DATA *DeviceCert )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetTimeValue(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ALGORITHMS TimeAlgorithm,
                    CSSM_DATA *TimeData )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetOperationalStatistics(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_CSP_OPERATIONAL_STATISTICS *Statistics )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetLoginAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_STRING *SelectionTag,
                    uint32 *NumberOfAclInfos,
                    CSSM_ACL_ENTRY_INFO_PTR *AclInfos )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetKeyAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *Key,
                    const CSSM_STRING *SelectionTag,
                    uint32 *NumberOfAclInfos,
                    CSSM_ACL_ENTRY_INFO_PTR *AclInfos )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_ChangeKeyAcl(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_EDIT *AclEdit,
                    const CSSM_KEY *Key )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetKeyOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_KEY *Key,
                    CSSM_ACL_OWNER_PROTOTYPE_PTR Owner )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_ChangeKeyOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_KEY *Key,
                    const CSSM_ACL_OWNER_PROTOTYPE *NewOwner )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_GetLoginOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    CSSM_ACL_OWNER_PROTOTYPE_PTR Owner )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}

CSSM_RETURN CSSMSPI ADDIN_CSM_ChangeLoginOwner(
                    CSSM_CSP_HANDLE CSPHandle,
                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
                    const CSSM_ACL_OWNER_PROTOTYPE *NewOwner )
{
    return CSSMERR_CSP_FUNCTION_NOT_IMPLEMENTED;
}