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

/*
 * OpenVMS History
 *
 * 12-Sep-2002 Carol Kelly
 *        o Merge in V3_14 changes
 *
 */

#ifdef WIN32
#pragma warning (disable:4201 4514 4214 4115)
#include <windows.h>
#include <stdio.h>
#pragma warning (default:4201 4214 4115)
#ifdef _DEBUG
#include <crtdbg.h>
#endif
#endif
#include "cssm.h"
#include "guids.h"   /* for guid definitions */
#include "cssmtype.h"
#include "emmtype.h"
#include "emmspi.h"
#include "dummyapi.h"
#include "dummyspi.h"
#include "cssmerr.h"
#include "guids.h"
#include "mds_util_api.h"
#include "mds_util_helper.h"
#include "cssmport.h"
#include "dummy_mds.h"
#ifdef ISL_INCLUDED
#include "callouts.h"
#include "eislapi.h"
#include "common.h"

ISL_VERIFIED_MODULE_PTR* VerifiedCSSMModulePtrArr= NULL;
uint32 NumSections = 0;
char szFunctionName[128];
ISL_CONST_DATA ConstData;
#endif
CSSM_GUID dummyemm_guid_30 = intel_dummy_emm_guid_init;
/* DUMMY EMM */

CSSM_STATE_FUNCS CssmStateFuncs;
#ifndef ISL_INCLUDED
CSSM_LIB_HANDLE g_cssmHandle;
#endif
CSSM_BOOL MDSUTILInitialized = CSSM_FALSE;
#ifdef CSSM_MEMTRACK_ON
void * CSSMAPI _dummy_malloc (uint32 size,
                             void *AllocRef,
                             const char * szFilename,
                             uint32 u32LineNumber)
{
    return _malloc_dbg(size, _NORMAL_BLOCK, szFilename, u32LineNumber);
}

void * CSSMAPI _dummy_realloc (void *Ptr,
                              uint32 size,
                              void *AllocRef,
                              const char * szFilename,
                              uint32 u32LineNumber)
{
    return _realloc_dbg(Ptr, size, _NORMAL_BLOCK, szFilename, u32LineNumber);
}

void CSSMAPI _dummy_free (void *Ptr, 
                         void *AllocRef,
                         const char * szFilename,
                         uint32 u32LineNumber)
{
    _free_dbg(Ptr, _NORMAL_BLOCK);
}

void * CSSMAPI _dummy_calloc (uint32 size,
                             uint32 count,
                             void* AllocRef,
                             const char * szFilename,
                             uint32 u32LineNumber)
{
    return _calloc_dbg(size, count, _NORMAL_BLOCK, szFilename, u32LineNumber);
}

#else
void * CSSMAPI _dummy_malloc (uint32 size,
                             void *AllocRef)
{
    return malloc( size );
}

void * CSSMAPI _dummy_realloc (void *Ptr,
                              uint32 size,
                              void *AllocRef)
{
    return realloc(Ptr, size);
}

void CSSMAPI _dummy_free (void *Ptr, 
                         void *AllocRef)
{
    free(Ptr);
}

void * CSSMAPI _dummy_calloc (uint32 size,
                             uint32 count,
                             void* AllocRefr)
{
    return calloc(size, count );
}

#endif

CSSM_API_MEMORY_FUNCS MemoryFuncs = { _dummy_malloc,
                                      _dummy_free,
                                      _dummy_realloc,
                                      _dummy_calloc,
                                      NULL };

CSSM_RETURN CSSMAPI DummyEmm_Passthru(CSSM_MODULE_HANDLE hAddIn, CSSM_SERVICE_MASK ServiceMask)
{
    EMM_SPI_DUMMY_FUNCS_PTR DummyFuncsPtr;
    CSSM_RETURN ret;
    void* Callback = NULL;
    CSSM_BOOL bIsOk = CSSM_TRUE;
    //MessageBox( NULL,"DummyEmm:Passthru","DUMMY EMM",MB_OK);
#ifndef ISL_INCLUDED
    CSSM_PROC_ADDR retAddress = NULL;
    if( g_cssmHandle == NULL )
        return CSSMERR_CSSM_INTERNAL_ERROR;
#endif

#ifdef ISL_INCLUDED
    /* now we get the return address */
    ISL_FUNCTION_PTR retAddress = NULL;
    EISL_GetReturnAddress(retAddress);

    /* If some body linked to emm and not called AddinAttcahe, so that 
    ModuleManagerAuthenticate did not happen and CSSM verify did not happen*/
    if(VerifiedCSSMModulePtrArr == NULL)
    {
        return CSSMERR_CSSM_INTERNAL_ERROR;
    }
#endif
    /* EMM should call cssm_IsFuncCallValid if we need to do a check of the caller or 
    check the function pointer to be within the verified module*/
    ret = CssmStateFuncs.cssm_GetAttachFunctions( hAddIn,ServiceMask,&Callback, NULL);
    if(ret == CSSM_OK && Callback != NULL)
    {
        DummyFuncsPtr = (EMM_SPI_DUMMY_FUNCS_PTR)Callback;
        if(!IsBadCodePtr((CSSM_PROC_ADDR)DummyFuncsPtr->PassThrough)) 
        {
            ret = CssmStateFuncs.cssm_IsFuncCallValid(hAddIn, 
                                                (CSSM_PROC_ADDR)retAddress,
#ifdef __arch64__
                                                (CSSM_PROC_ADDR)(*(void **)DummyFuncsPtr->PassThrough),
#else
                                                (CSSM_PROC_ADDR)DummyFuncsPtr->PassThrough,
#endif
                                                0,    /* no privilege */
                                                NULL, /* don't need privilege */
                                                0,    /* no hints */
                                                &bIsOk);
            if( ret == CSSM_OK && bIsOk )
            {

                ret = DummyFuncsPtr->PassThrough(hAddIn,ServiceMask);
            }
        }
        else
        {
            ret = DUMMY_EMM_FUNCTION_NOT_IMPLEMENTED;
        }
        CssmStateFuncs.cssm_ReleaseAttachFunctions ( hAddIn);
    }

    return ret;
}

CSSM_RETURN CSSMAPI DummyEmm_Passthru1(CSSM_MODULE_HANDLE hAddIn, CSSM_SERVICE_MASK ServiceMask)
{
    EMM_SPI_DUMMY_FUNCS_PTR DummyFuncsPtr;
    CSSM_RETURN ret;
    void* Callback = NULL;
    CSSM_BOOL bIsOk=CSSM_TRUE;
    //MessageBox( NULL,"DummyEmm:Passthru1","DUMMY EMM",MB_OK);
#ifndef ISL_INCLUDED
    CSSM_PROC_ADDR retAddress = NULL;   /* dummy for parameter passing */
    if( g_cssmHandle == NULL )
        return CSSMERR_CSSM_INTERNAL_ERROR;
#endif
#ifdef ISL_INCLUDED
    /* now we get the return address */
    ISL_FUNCTION_PTR retAddress = NULL;
    EISL_GetReturnAddress(retAddress);

    /* If some body linked to emm and not called AddinAttcahe, so that 
    ModuleManagerAuthenticate did not happen and CSSM verify did not happen*/
    if(VerifiedCSSMModulePtrArr == NULL)
    {
        return CSSMERR_CSSM_INTERNAL_ERROR;
    }
#endif
    ret = CssmStateFuncs.cssm_GetAttachFunctions( hAddIn,ServiceMask,&Callback, NULL);
    if(ret == CSSM_OK && Callback != NULL)
    {
        DummyFuncsPtr = (EMM_SPI_DUMMY_FUNCS_PTR)Callback;
        if(!IsBadCodePtr((CSSM_PROC_ADDR)DummyFuncsPtr->PassThrough1)) 
        {
            ret = CssmStateFuncs.cssm_IsFuncCallValid(hAddIn, 
                                                (CSSM_PROC_ADDR)retAddress,
#ifdef __arch64__
                                                (CSSM_PROC_ADDR)(*(void **)DummyFuncsPtr->PassThrough1),
#else
                                                (CSSM_PROC_ADDR)DummyFuncsPtr->PassThrough1,
#endif
                                                0,    /* no privilege */
                                                NULL, /* don't need privilege */
                                                0,    /* no hints */
                                                &bIsOk);
            if( ret == CSSM_OK && bIsOk )
            {

                ret = DummyFuncsPtr->PassThrough1(hAddIn,ServiceMask);
            }
        }
        else
        {
            ret = DUMMY_EMM_FUNCTION_NOT_IMPLEMENTED;
        }
        CssmStateFuncs.cssm_ReleaseAttachFunctions ( hAddIn);
    }

    return ret;
}

/*---------------------------------------------------------------
 *
 *Name: Initialize
 *
 *Description:
 *   Require function that CSSM calls during the attach process for
 *   checking the compatibilty of the version of the TP requested.   
 *
 *Parameters: 
 *   VerMajor (input) - Major version of the TP requested
 *   VerMinor (input) - Minor version of the TP requested
 *
 *Returns:
 *   CSSM_FAIL - versions are not compatible
 *   CSSM_OK - versions are compatible
 *
 *-------------------------------------------------------------*/
CSSM_RETURN CSSMAPI Initialize (uint32 VerMajor, uint32 VerMinor)
{
#ifdef ISL_INCLUDED
    /* DLL is attaching to the address space of the current process. */
    ISL_VERIFIED_MODULE_PTR VerifiedDummyModulePtr = NULL;
    VerifiedDummyModulePtr = EISL_SelfCheck();
    if(VerifiedDummyModulePtr == NULL)
    {
#ifdef _DEBUG
        OutputDebugString("EMM::EISL_SelfCheck() Failed\n");
#endif
        return CSSM_FALSE;
    }
    EISL_RecycleVerifiedModuleCredentials(VerifiedDummyModulePtr);
#endif
     return (CSSM_OK);
}

/*---------------------------------------------------------------
 *
 *Name: Terminate
 *
 *Description:
 *   Require function that CSSM calls during the detach process.
 *
 *Parameters: 
 *   None
 *
 *Returns:
 *   CSSM_FAIL - Don't free library
 *   CSSM_OK - OK to free the library
 *
 *-------------------------------------------------------------*/
CSSM_RETURN CSSMAPI Terminate (void)
{
#ifdef ISL_INCLUDED
    if(VerifiedCSSMModulePtrArr != NULL)
    {
        cssm_FreeVerifiedCredentials( VerifiedCSSMModulePtrArr, NumSections);
        dummy_free(VerifiedCSSMModulePtrArr, 0);
    }
#endif
    if( MDSUTILInitialized)
    {
        MDSUTIL_Term();
        MDSUTILInitialized = CSSM_FALSE;
    }
    return (CSSM_OK);
}

/* this function is called from CSSM after ModuleManagerAuthenticate,
   to pass cssm internal dat structure to emm*/
CSSM_RETURN CSSMAPI RegisterDispatchTable ( CSSM_STATE_FUNCS_PTR CssmStateCallTable)
{
    CssmStateFuncs.cssm_GetAttachFunctions = CssmStateCallTable->cssm_GetAttachFunctions;
    CssmStateFuncs.cssm_ReleaseAttachFunctions = CssmStateCallTable->cssm_ReleaseAttachFunctions;
    CssmStateFuncs.cssm_GetAppMemoryFunctions = CssmStateCallTable->cssm_GetAppMemoryFunctions;
    CssmStateFuncs.cssm_IsFuncCallValid = CssmStateCallTable->cssm_IsFuncCallValid;
    CssmStateFuncs.cssm_DeregisterManagerServices = CssmStateCallTable->cssm_DeregisterManagerServices;
    CssmStateFuncs.cssm_DeliverModuleManagerEvent = CssmStateCallTable->cssm_DeliverModuleManagerEvent;
    return CSSM_OK;
}


CSSM_RETURN CSSMAPI DeregisterDispatchTable (void)
{
    return CSSM_OK;
}

CSSM_RETURN CSSMAPI EventNotifyManager (const CSSM_MANAGER_EVENT_NOTIFICATION* EventDescription)
{
    switch (EventDescription->Event)
    {
        case CSSM_MANAGER_SERVICE_REQUEST:
            return CSSM_MANAGER_SERVICE_REQUEST;
        case CSSM_MANAGER_REPLY:
            return CSSM_MANAGER_REPLY;
        default:
            return 0;
    }
}

CSSM_RETURN CSSMAPI RefreshFunctionTable(CSSM_FUNC_NAME_ADDR_PTR FuncNameAddrPtr, 
                                        uint32 NumOfFuncNameAddr)
{
    uint32 i;
    if(FuncNameAddrPtr != NULL)
    {
        for(i=0;i<NumOfFuncNameAddr;i++)
        {
            if(!strcmpi(FuncNameAddrPtr[i].Name, "DummyEmm_Passthru"))
            {
                FuncNameAddrPtr[i].Address = (CSSM_PROC_ADDR)DummyEmm_Passthru;
            }
            else if(!strcmpi(FuncNameAddrPtr[i].Name, "DummyEmm_Passthru1"))
            {
                FuncNameAddrPtr[i].Address = (CSSM_PROC_ADDR)DummyEmm_Passthru;
            }

        }
    }
    return CSSM_OK;
}

#ifdef ISL_INCLUDED
CSSM_RETURN ExtractCDSAAttributeAndCheckForCSSM( ISL_MANIFEST_SECTION_PTR ManifestSectionPtr)
{
    ISL_ITERATOR_PTR AttribIterator = NULL;
    ISL_STATUS Status;
    ISL_CONST_DATA AttribValue;
    ISL_CONST_DATA AttributeName;
    const char *szAttribName = "CDSA_MODULE";
    char* szCDSAModuleTagValue = "CSSM";
    /*creates the manifest attribute enumertor*/
    /* Extract CDSA_MODULE tag from the manifest section*/
    /**/
    AttribIterator = EISL_CreateManifestSectionAttributeEnumerator(ManifestSectionPtr);
        
    if(AttribIterator == NULL)
    {
        return CSSMERR_CSSM_INTERNAL_ERROR;
    }
    AttributeName.Length = strlen(szAttribName)+1;
    AttributeName.Data = (const unsigned char*)szAttribName;
    /*Retrieves the manifest attribute*/
    Status = EISL_GetNextManifestSectionAttribute(AttribIterator, &AttributeName, &AttribValue);
    if( Status != ISL_OK || IsBadReadPtr(AttribValue.Data, AttribValue.Length) )
    {
        EISL_RecycleManifestSectionAttributeEnumerator(AttribIterator);
        
        return CSSMERR_CSSM_INTERNAL_ERROR;
    }
    if(memcmp( AttribValue.Data, szCDSAModuleTagValue, AttribValue.Length) == 0)
    {
        EISL_RecycleManifestSectionAttributeEnumerator(AttribIterator);
        return CSSM_OK;
    }
    else
    {
        EISL_RecycleManifestSectionAttributeEnumerator(AttribIterator);
        return CSSMERR_CSSM_INTERNAL_ERROR;
    }
}

#endif

static void
ReleaseCredentialMemory (CSSM_DATA CredentialImage, CSSM_DATA CredentialSearchPath)
{
    if (CredentialImage.Data)
        dummy_free (CredentialImage.Data, NULL);
    
    if (CredentialSearchPath.Data)
        dummy_free (CredentialSearchPath.Data, NULL);
}

/* AppFileName and AppPathName in the document are 
to be changed to AppCredential and AppSection*/

CSSM_RETURN CSSMAPI ModuleManagerAuthenticate(CSSM_KEY_HIERARCHY KeyHierarchy,
                          const CSSM_GUID *CssmGuid,
                          const CSSM_GUID *AppGuid,
                          CSSM_MANAGER_REGISTRATION_INFO_PTR FunctionTable)
{
    char szCSSMPath[255];
    CSSM_DATA AppCredentialImage;
    CSSM_DATA AppSearchPath;
    CSSM_DATA cssmCredentialImage;
    CSSM_DATA cssmSearchPath;
    CSSM_DATA cssmModuleName;
    CSSM_DATA cssmModulePath;
    CSSM_RETURN ret = CSSM_OK;
#ifdef ISL_INCLUDED
    ISL_STATUS islret;
#ifdef VMS
    ISL_FUNCTION_PTR retAddress;
#else
    void* retAddress;
#endif
    char szFunctionName[255];
    ISL_MANIFEST_SECTION_PTR* ManifestSectionPtr = NULL;
    ISL_CONST_DATA Credentials;
    ISL_CONST_DATA CredentialSearchPath;
#endif
    /* TODO:We need a lock here*/
    if( !MDSUTILInitialized )
    {
        ret = MDSUTIL_Init();
        MDSUTILInitialized = CSSM_TRUE;
    }
    if( ret == CSSM_OK)
    {
        /*
         * Get the credential, search path and section name from MDS
         */
        memset (&AppCredentialImage, 0, sizeof (CSSM_DATA));
        memset (&AppSearchPath, 0, sizeof (CSSM_DATA));
        if (AppGuid) {
            if (mdsutil_GetModuleCredentialInfo ((CSSM_GUID*)AppGuid,
                                            &AppCredentialImage, NULL, &AppSearchPath) != CSSM_OK)
                return CSSMERR_CSSM_MDS_ERROR;
        }

        memset (&cssmCredentialImage, 0, sizeof (CSSM_DATA));
        memset (&cssmSearchPath, 0, sizeof (CSSM_DATA));
        memset (&cssmModuleName, 0, sizeof (CSSM_DATA));
        memset (&cssmModulePath, 0, sizeof (CSSM_DATA));
        if (mdsutil_GetModuleCredentialInfo ((CSSM_GUID*)CssmGuid, &cssmCredentialImage, &cssmModuleName,
                                    &cssmSearchPath) != CSSM_OK) {
            if (AppGuid)
                ReleaseCredentialMemory (AppCredentialImage, AppSearchPath);
            return CSSMERR_CSSM_MDS_ERROR;
        }

        if (mdsutil_GetModulePath (cssmModuleName, cssmSearchPath, &cssmModulePath) != CSSM_OK) {
            ReleaseCredentialMemory (cssmCredentialImage, cssmSearchPath);
            if (cssmModuleName.Data)
                dummy_free (cssmModuleName.Data, NULL);
            if (AppGuid)
                ReleaseCredentialMemory (AppCredentialImage, AppSearchPath);
            return CSSMERR_CSSM_MDS_ERROR;
        }

    #ifdef ISL_INCLUDED
        Credentials.Data = cssmCredentialImage.Data;
        Credentials.Length = cssmCredentialImage.Length;
        CredentialSearchPath.Data = cssmSearchPath.Data;
        CredentialSearchPath.Length = cssmSearchPath.Length;

        if(( KeyHierarchy == CSSM_KEY_HIERARCHY_NONE) || (KeyHierarchy & CSSM_KEY_HIERARCHY_INTEG) )
        {
            VerifiedCSSMModulePtrArr = cssm_VerifyCredentialsAndLoadModules(
                                                        Credentials,
                                                        CredentialSearchPath,
                                                        INTEGRITY_KEY,
                                                        CSSM_FALSE,
                                                        &NumSections, 
                                                        &MemoryFuncs);
            if(VerifiedCSSMModulePtrArr == NULL)
            {
                return CSSMERR_CSSM_MODULE_MANIFEST_VERIFY_FAILED;
            }
        }
        else if( KeyHierarchy & CSSM_KEY_HIERARCHY_EXPORT)
        {
            ManifestSectionPtr = cssm_VerifyCredentials(Credentials,
                                                         CredentialSearchPath,
                                                         EXPORT_KEY, &NumSections, 
                                                         &MemoryFuncs);
            if(ManifestSectionPtr == NULL)
                return CSSMERR_CSSM_MODULE_MANIFEST_VERIFY_FAILED;
            
            ret = ExtractCDSAAttributeAndCheckForCSSM( ManifestSectionPtr[0]);
            if(ret == CSSM_OK)
                VerifiedCSSMModulePtrArr = cssm_VerifyLoadedOrLoadAllModules( ManifestSectionPtr,&NumSections,
                                       CSSM_FALSE, &MemoryFuncs);
            else
            {
                cssm_FreeManifestSections( ManifestSectionPtr, NumSections);
                dummy_free( ManifestSectionPtr, NULL);
                return CSSMERR_CSSM_MODULE_MANIFEST_VERIFY_FAILED;
            }
            if(VerifiedCSSMModulePtrArr == NULL)
            {
                cssm_FreeManifestSections( ManifestSectionPtr, NumSections);
                dummy_free( ManifestSectionPtr, NULL);
                return CSSMERR_CSSM_MODULE_MANIFEST_VERIFY_FAILED;
            }
            dummy_free( ManifestSectionPtr, NULL);


        }
        EISL_GetReturnAddress(retAddress);

        islret = EISL_CheckAddressWithinModule( VerifiedCSSMModulePtrArr[0], (ISL_FUNCTION_PTR)retAddress);
        if(islret == ISL_FAIL)
        {
            cssm_FreeVerifiedCredentials( VerifiedCSSMModulePtrArr, NumSections);
            dummy_free( VerifiedCSSMModulePtrArr, NULL);

            VerifiedCSSMModulePtrArr = NULL;
            return CSSMERR_CSSM_FUNCTION_INTEGRITY_FAIL;
        }

    #endif
    #ifndef ISL_INCLUDED
        if(  port_LoadLibrary((const char*)cssmModulePath.Data, &g_cssmHandle) != CSSM_OK)
            return CSSMERR_CSSM_INTERNAL_ERROR;
    
    #endif

        FunctionTable->Initialize = Initialize;
        FunctionTable->Terminate = Terminate;
        FunctionTable->RegisterDispatchTable = RegisterDispatchTable;
        FunctionTable->DeregisterDispatchTable = DeregisterDispatchTable;
        FunctionTable->EventNotifyManager = EventNotifyManager;
        FunctionTable->RefreshFunctionTable = RefreshFunctionTable;
    }

    szCSSMPath;
    
    return CSSM_OK;
}

#if defined (LINUX)
static int _init() __attribute__ ((constructor));
static int _fini() __attribute__ ((destructor));
#endif

#if defined (UNIX)

int _init()
{
}

int _fini()
{
}
#endif

#ifdef WIN32

/*---------------------------------------------------------------
 *
 *Name: DllMain
 *
 *Description:
 *   Entry point for the DLL.
 *
 *Parameters: 
 *   hInstance (input) - Instance handle of calling process
 *   dwReason (input) - Reasons for receiving this call
 *   lpReserved (input) - Reserved field
 *
 *Returns:
 *   FALSE - unable to initialize DLL.  This will cause the LoadLibrary
 *           call to fail.
 *   TRUE - DLL is initialize and ready to be called
 *
 *-------------------------------------------------------------*/
BOOL WINAPI DllMain (HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
{


    switch (dwReason) {
        case DLL_PROCESS_ATTACH: {

#ifdef _DEBUG
            OutputDebugString("In Dummy Emm Process Attach");
#endif

            break;
        }

        case DLL_THREAD_ATTACH:

            /* A new thread is being created in the current process. */


#ifdef _DEBUG
            OutputDebugString("In Dummy Emm thread attach");
#endif
          break;

        case DLL_THREAD_DETACH:


#ifdef _DEBUG
            OutputDebugString("In Dummy Emm thread Detach");
#endif
            break;

        case DLL_PROCESS_DETACH:
            {
            /* The calling process is detaching the DLL  */
#ifdef _DEBUG
            OutputDebugString("In Dummy Emm Process Detach");
#endif

          break;
        }
    }
    return TRUE;
}

#endif /* WIN32 */