delayimp.cpp File Reference

#include <apitest.h>
#include <strsafe.h>
#include <delayimp.h>
#include <mmsystem.h>
#include <winver.h>
#include <shlwapi.h>
#include <intshcut.h>
#include <sfc.h>
#include <imagehlp.h>
#include <mmddk.h>
#include <pseh/pseh2.h>

Include dependency graph for delayimp.cpp:

Go to the source code of this file.

Classes
struct	UnProtect

Macros
#define	FACILITY_VISUALCPP   ((LONG)0x6d)
#define	VcppException(sev, err)   ((sev) | (FACILITY_VISUALCPP<<16) | err)
#define	WINMM_DLLNAME   "WINMM.dll"
#define	LAST_DLI   333
#define	CheckDli   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDli_imp
#define	CheckDliDone   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDliDone_imp

Functions
char *	target (PDelayLoadInfo pdli)
static void	SetExpectedDli (unsigned *order)
static void	CheckDli_imp (unsigned dliNotify, PDelayLoadInfo pdli, BOOL ErrorHandler)
static void	CheckDliDone_imp ()
INT_PTR WINAPI	MyFunction ()
BOOL WINAPI	MySfcIsKeyProtected (HKEY KeyHandle, LPCWSTR SubKeyName, REGSAM KeySam)
FARPROC WINAPI	DliHook (unsigned dliNotify, PDelayLoadInfo pdli)
FARPROC WINAPI	DliFailHook (unsigned dliNotify, PDelayLoadInfo pdli)
LONG	ExceptionFilter (IN PEXCEPTION_POINTERS ExceptionInfo, ULONG ExceptionCode)
template<typename PTR >
PTR	Rva2Addr (PIMAGE_DOS_HEADER dos, RVA rva)
	START_TEST (delayimp)

Variables
bool	g_BreakFunctionName = false
bool	g_BrokenFunctionName = false
bool	g_BypassMost = false
bool	g_ExceptionIsModule = false
bool	g_ImportByName = true
const char *	g_ExpectedDll = NULL
const char *	g_ExpectedName = NULL
char	g_Target [100] = { 0 }
unsigned *	g_DliHookExpected = NULL
size_t	g_DliHookIndex = 0
static HMODULE	g_VersionDll
PfnDliHook	__pfnDliNotifyHook2
bool	g_UsePointers = false
unsigned	g_winmm_get_cur_task [] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }
unsigned	g_winmm_midi_out_close [] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }
unsigned	g_winmm_mide_in_close [] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }
unsigned	g_sfc_key [] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }
unsigned	g_sfc_file [] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }
unsigned	g_version_a [] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }
unsigned	g_version_w [] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }
unsigned	g_scard [] = { dliStartProcessing, dliNoteEndProcessing, LAST_DLI }
unsigned	g_shlwapi [] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }
unsigned	g_imagehlp [] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, LAST_DLI }

Macro Definition Documentation

CheckDli

#define CheckDli   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDli_imp

Definition at line 128 of file delayimp.cpp.

CheckDliDone

#define CheckDliDone   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDliDone_imp

Definition at line 129 of file delayimp.cpp.

FACILITY_VISUALCPP

#define FACILITY_VISUALCPP   ((LONG)0x6d)

Definition at line 28 of file delayimp.cpp.

LAST_DLI

#define LAST_DLI   333

Definition at line 88 of file delayimp.cpp.

VcppException

#define VcppException	(		sev,
			err
	)		((sev) | (FACILITY_VISUALCPP<<16) | err)

Definition at line 32 of file delayimp.cpp.

WINMM_DLLNAME

#define WINMM_DLLNAME   "WINMM.dll"

Definition at line 38 of file delayimp.cpp.

Function Documentation

CheckDli_imp()

static void CheckDli_imp ( unsigned  dliNotify, PDelayLoadInfo  pdli, BOOL  ErrorHandler  )

static

Definition at line 97 of file delayimp.cpp.

{
    if (!g_DliHookExpected) return;
 
    winetest_ok(dliNotify == g_DliHookExpected[g_DliHookIndex], "Expected dliNotify to be %u, was: %u for %s\n",
        g_DliHookExpected[g_DliHookIndex], dliNotify, target(pdli));
    if (ErrorHandler)
    {
        winetest_ok(dliNotify == dliFailGetProc || dliNotify == dliFailLoadLib,
            "Expected code %u to be processed by the Hook, not the ErrorHandler for %s\n", dliNotify, target(pdli));
    }
    else
    {
        winetest_ok(dliNotify == dliStartProcessing || dliNotify == dliNotePreLoadLibrary ||
            dliNotify == dliNotePreGetProcAddress || dliNotify == dliNoteEndProcessing,
            "Expected code %u to be processed by the ErrorHandler, not the Hook for %s\n", dliNotify, target(pdli));
    }
    if (g_DliHookExpected[g_DliHookIndex] != LAST_DLI)
        g_DliHookIndex++;
}

CheckDliDone_imp()

static void CheckDliDone_imp ( )

static

Definition at line 118 of file delayimp.cpp.

{
    if (!g_DliHookExpected) return;
    winetest_ok(LAST_DLI == g_DliHookExpected[g_DliHookIndex],
        "Expected g_DliHookExpected[g_DliHookIndex] to be %u, was: %u for %s\n",
        LAST_DLI, g_DliHookExpected[g_DliHookIndex], target(NULL));
    g_DliHookExpected = NULL;
    g_Target[0] = '\0';
}

DliFailHook()

FARPROC WINAPI DliFailHook	(	unsigned	dliNotify,
		PDelayLoadInfo	pdli
	)

Definition at line 258 of file delayimp.cpp.

{
    ok(pdli && pdli->cb >= 36,
        "Expected a valid pointer with a struct that is big enough: %p, %lu\n", pdli, pdli ? pdli->cb : 0u);
    if (!pdli || pdli->cb < 36) return NULL;
 
    CheckDli(dliNotify, pdli, TRUE);
 
    /* Redirections / fixes */
    if (dliNotify == dliFailLoadLib)
    {
        if (!_stricmp(pdli->szDll, "l_m_os.dll"))
            return (FARPROC)LoadLibraryA("sfc_os.dll");
    }
    else if (dliNotify == dliFailGetProc)
    {
        if (pdli->dlp.fImportByName && pdli->hmodCur == (HMODULE)1)
        {
            return GetProcAddress(g_VersionDll, pdli->dlp.szProcName);
        }
    }
 
    /* Parameter validation */
    ok(pdli->ppfn != NULL, "Expected ppfn to be valid, was NULL for %s\n", target(pdli));
    ok(pdli->szDll != NULL, "Expected szDll to be valid, was NULL for %s\n", target(pdli));
    if (pdli->dlp.fImportByName)
        ok(pdli->dlp.szProcName != NULL, "Expected szProcName to be valid, was NULL for %s\n", target(pdli));
    else
        ok(pdli->dlp.dwOrdinal != 0, "Expected dwOrdinal to be valid, was NULL for %s\n", target(pdli));
    switch(dliNotify)
    {
        case dliFailLoadLib:
            ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli));
            ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli));
            ok(pdli->dwLastError == ERROR_MOD_NOT_FOUND,
                "Expected dwLastError to be ERROR_MOD_NOT_FOUND, was: %lu for %s\n", pdli->dwLastError, target(pdli));
            break;
        case dliFailGetProc:
            ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli));
            ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli));
            ok(pdli->dwLastError == ERROR_PROC_NOT_FOUND,
                "Expected dwLastError to be ERROR_PROC_NOT_FOUND, was: %lu for %s\n", pdli->dwLastError, target(pdli));
            break;
    }
 
    return NULL;
}

Referenced by START_TEST().

DliHook()

FARPROC WINAPI DliHook	(	unsigned	dliNotify,
		PDelayLoadInfo	pdli
	)

Definition at line 145 of file delayimp.cpp.

{
    ok(pdli && pdli->cb >= 36, "Expected a valid pointer with a struct that is big enough: %p, %lu\n",
        pdli, pdli ? pdli->cb : 0u);
    if (!pdli || pdli->cb < 36) return NULL;
 
    CheckDli(dliNotify, pdli, FALSE);
 
    if (g_BreakFunctionName && pdli->dlp.fImportByName)
    {
        g_BreakFunctionName = false;
        g_BrokenFunctionName = true;
        char* procname = (char*)pdli->dlp.szProcName;
        UnProtect prot(procname);
        char c = procname[0];
        procname[0] = isupper(c) ? tolower(c) : toupper(c);
    }
 
    /* Validate dll name when required */
    if (g_ExpectedDll && g_ExpectedName && !g_BrokenFunctionName)
    {
        ok(!strcmp(g_ExpectedDll, pdli->szDll), "Expected szDll to be '%s', but was: '%s'\n", g_ExpectedDll, pdli->szDll);
        ok(pdli->dlp.fImportByName, "Expected import by name (%s!%s)\n", g_ExpectedDll, g_ExpectedName);
        if (pdli->dlp.fImportByName)
        {
            ok(!strcmp(g_ExpectedName, pdli->dlp.szProcName), "Expected szProcName to be '%s', but was: '%s'\n",
                g_ExpectedName, pdli->dlp.szProcName);
        }
    }
 
 
    if (dliNotify == dliStartProcessing)
    {
        /* Test loadlib fail */
        if (!_stricmp(pdli->szDll, "sfc_os.dll"))
        {
            char* dll = (char*)pdli->szDll;
            UnProtect u(dll);
            dll[0] = 'l'; dll[1] = '_'; dll[2] = 'm';
        }
        if (!_stricmp(pdli->szDll, "imagehlp.dll"))
        {
            char* dll = (char*)pdli->szDll;
            UnProtect u(dll);
            dll[0] = 'x'; dll[1] = 'x'; dll[2] = 'x'; dll[3] = 'x'; dll[4] = 'x';
        }
        /* Test bypass */
        if (!_stricmp(pdli->szDll, "dbghelp.dll"))
            return MyFunction;
    }
    else if (dliNotify == dliNotePreLoadLibrary)
    {
        /* Show that this value is actually used! */
        if (!_stricmp(pdli->szDll, "version.dll"))
        {
            g_VersionDll = LoadLibraryA("version.dll");
            return (FARPROC)1;
        }
 
    }
    else if (dliNotify == dliNotePreGetProcAddress)
    {
        if (pdli->dlp.fImportByName && !strcmp(pdli->dlp.szProcName, "SfcIsKeyProtected"))
        {
            return (FARPROC)MySfcIsKeyProtected;
        }
    }
 
    /* Parameter validation */
    ok(pdli->ppfn != NULL, "Expected ppfn to be valid, was NULL for %s\n", target(pdli));
    ok(pdli->szDll != NULL, "Expected szDll to be valid, was NULL for %s\n", target(pdli));
    ok(pdli->dwLastError == ERROR_SUCCESS,
        "Expected dwLastError to be ERROR_SUCCESS, was: %lu for %s\n", pdli->dwLastError, target(pdli));
    ok(g_ImportByName == !!pdli->dlp.fImportByName, "Expected pdli->dlp.fImportByName to equal g_ImportByname\n");
    if (pdli->dlp.fImportByName)
        ok(pdli->dlp.szProcName != NULL, "Expected szProcName to be valid, was NULL for %s\n", target(pdli));
    else
        ok(pdli->dlp.dwOrdinal != 0, "Expected dwOrdinal to be valid, was NULL for %s\n", target(pdli));
    switch(dliNotify)
    {
        case dliStartProcessing:
            ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli));
            ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli));
            break;
        case dliNotePreLoadLibrary:
            ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli));
            ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli));
            break;
        case dliNotePreGetProcAddress:
            ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli));
            ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli));
            break;
        case dliNoteEndProcessing:
            if (!g_BypassMost)
                ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli));
            ok(pdli->pfnCur != NULL, "Expected pfnCur to be a valid pointer, was NULL for %s\n", target(pdli));
            if (g_ExpectedDll && g_ExpectedName && !g_BrokenFunctionName)
            {
                FARPROC targetProc = GetProcAddress(GetModuleHandleA(g_ExpectedDll), g_ExpectedName);
                ok(targetProc != NULL, "This should not happen, the function i need is unavail! (%s!%s)\n",
                    g_ExpectedDll, g_ExpectedName);
                ok(targetProc == pdli->pfnCur, "Expected pfnCur to be %p, was %p for %s\n", targetProc, pdli->pfnCur, target(pdli));
                ok(pdli->ppfn && targetProc == *pdli->ppfn,
                    "Expected ppfn to be valid and to result in %p, was: %p(%p) for %s\n",
                    target, pdli->ppfn, pdli->ppfn ? *pdli->ppfn : NULL, target(pdli));
            }
            break;
        default:
            break;
    }
    return NULL;
}

Referenced by START_TEST().

ExceptionFilter()

LONG ExceptionFilter	(	IN PEXCEPTION_POINTERS	ExceptionInfo,
		ULONG	ExceptionCode
	)

Definition at line 307 of file delayimp.cpp.

{
    DWORD expected = VcppException(ERROR_SEVERITY_ERROR, (g_ExceptionIsModule ? ERROR_MOD_NOT_FOUND : ERROR_PROC_NOT_FOUND));
    ok(ExceptionCode == expected, "Expected code to be 0x%lx, was: 0x%lx\n", expected, ExceptionCode);
    ok(ExceptionInfo != NULL, "Expected to get exception info\n");
    ok(ExceptionInfo->ExceptionRecord != NULL, "Expected to get a valid record info\n");
 
    if (ExceptionCode != expected)
    {
        skip("Skipping other checks, this was not the exception we expected!\n");
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    if (ExceptionInfo && ExceptionInfo->ExceptionRecord)
    {
        PEXCEPTION_RECORD ExceptionRecord = ExceptionInfo->ExceptionRecord;
        ok(ExceptionRecord->ExceptionCode == expected, "Expected ExceptionCode to be 0x%lx, was 0x%lx\n",
            expected, ExceptionRecord->ExceptionCode);
        /* We can still continue. */
        ok(ExceptionRecord->ExceptionFlags == 0, "Expected ExceptionFlags to be 0, was: 0x%lx\n",
            ExceptionRecord->ExceptionFlags);
        ok(ExceptionRecord->NumberParameters == 1, "Expected 1 parameter, got %lu\n",
            ExceptionRecord->NumberParameters);
        if (ExceptionRecord->NumberParameters == 1)
        {
            PDelayLoadInfo LoadInfo = (PDelayLoadInfo)ExceptionRecord->ExceptionInformation[0];
            ok(LoadInfo && LoadInfo->cb >= 36, "Expected a valid pointer with a struct that is big enough: %p, %lu\n",
                LoadInfo, LoadInfo ? LoadInfo->cb : 0);
 
            if (g_ExpectedDll)
                ok(!strcmp(g_ExpectedDll, LoadInfo->szDll), "Expected szDll to be '%s', but was: '%s'\n",
                g_ExpectedDll, LoadInfo->szDll);
            if (g_ExpectedName)
            {
                ok(LoadInfo->dlp.fImportByName, "Expected import by name\n");
                if (LoadInfo->dlp.fImportByName)
                {
                    ok(!strcmp(g_ExpectedName, LoadInfo->dlp.szProcName),
                    "Expected szProcName to be '%s', but was: '%s'\n", g_ExpectedName, LoadInfo->dlp.szProcName);
 
                    if (g_ExceptionIsModule)
                    {
                        HMODULE mod = LoadLibraryA("imagehlp.dll");
                        LoadInfo->pfnCur = GetProcAddress(mod, g_ExpectedName);
                    }
                    else
                    {
                        char buf[100];
                        char first = isupper(g_ExpectedName[0]) ? tolower(g_ExpectedName[0]) : toupper(g_ExpectedName[0]);
                        sprintf(buf, "%c%s", first, g_ExpectedName + 1);
                        LoadInfo->pfnCur = GetProcAddress(GetModuleHandleA(g_ExpectedDll), buf);
                    }
                    return LoadInfo->pfnCur ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
                }
            }
        }
    }
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by __C_specific_handler(), and START_TEST().

MyFunction()

INT_PTR WINAPI MyFunction

(

)

Definition at line 133 of file delayimp.cpp.

{
    return 123;
}

Referenced by DliHook().

MySfcIsKeyProtected()

BOOL WINAPI MySfcIsKeyProtected	(	HKEY	KeyHandle,
		LPCWSTR	SubKeyName,
		REGSAM	KeySam
	)

Definition at line 138 of file delayimp.cpp.

{
    return 12345;
}

Referenced by DliHook().

Rva2Addr()

template<typename PTR >

PTR Rva2Addr	(	PIMAGE_DOS_HEADER	dos,
		RVA	rva
	)

Definition at line 380 of file delayimp.cpp.

{
    /* Old delayload type */
    if (g_UsePointers)
        return reinterpret_cast<PTR>(rva);
    return reinterpret_cast<PTR>((reinterpret_cast<PBYTE>(dos) + rva));
}

SetExpectedDli()

static void SetExpectedDli ( unsigned *  order )

static

Definition at line 90 of file delayimp.cpp.

{
    g_DliHookExpected = order;
    g_DliHookIndex = 0;
    g_Target[0] = '\0';
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

delayimp

)

Definition at line 402 of file delayimp.cpp.

{
    __pfnDliNotifyHook2 = DliHook;
    /* Verify that both scenario's work */
    ok(__pfnDliNotifyHook2 == DliHook, "Expected __pfnDliNotifyHook2 to be DliHook(%p), but was: %p\n",
        DliHook, __pfnDliNotifyHook2);
    ok(__pfnDliFailureHook2 == NULL, "Expected __pfnDliFailureHook2 to be NULL, but was: %p\n",
        __pfnDliFailureHook2);
 
    __pfnDliFailureHook2 = DliFailHook;
 
 
    PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)GetModuleHandle(NULL);
 
    ok(dos->e_magic == IMAGE_DOS_SIGNATURE, "Expected a DOS header\n");
    if (dos->e_magic != IMAGE_DOS_SIGNATURE)
        return;
 
    PIMAGE_NT_HEADERS nt = (PIMAGE_NT_HEADERS)((PBYTE)dos + dos->e_lfanew);
    PIMAGE_DATA_DIRECTORY delaydir = nt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT;
 
    /* Test some advanced features (loading / unloading) */
    if (delaydir->Size != 0)
    {
#if defined(_DELAY_IMP_VER) && _DELAY_IMP_VER == 2 && defined(DELAYLOAD_SUPPORTS_UNLOADING)
        /* First, before mangling the delayload stuff, let's try some v2 functions */
        HMODULE mod = GetModuleHandleA(WINMM_DLLNAME);
        ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod);
        /* Now, a mistyped module (case sensitive!) */
        HRESULT hr = __HrLoadAllImportsForDll("WiNmM.DlL");
        ok(hr == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND), "Expected hr to be HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND), was %lu\n", hr);
        mod = GetModuleHandleA(WINMM_DLLNAME);
        ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod);
 
        /* Let's load it */
        hr = __HrLoadAllImportsForDll(WINMM_DLLNAME);
        ok(hr == S_OK, "Expected hr to be S_OK, was %lu\n", hr);
        mod = GetModuleHandleA(WINMM_DLLNAME);
        ok(mod != NULL, "Expected mod to be valid, was NULL\n");
 
        BOOL status = __FUnloadDelayLoadedDLL2(WINMM_DLLNAME);
        ok(status == TRUE, "Expected __FUnloadDelayLoadedDLL2 to succeed\n");
        mod = GetModuleHandleA(WINMM_DLLNAME);
        ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod);
#else
        trace("Binary compiled without support for unloading\n");
#endif
    }
    else
    {
        skip("No IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT found, some advanced features might not work!\n");
    }
 
    /* Test the normal flow without a dll loaded */
    SetExpectedDli(g_winmm_get_cur_task);
    g_ExpectedDll = WINMM_DLLNAME;
    g_ExpectedName = "mmGetCurrentTask";
    DWORD task = mmGetCurrentTask();
    ok(task == GetCurrentThreadId(), "Expected ret to be current thread id (0x%lx), was 0x%lx\n", GetCurrentThreadId(), task);
    CheckDliDone();
 
    /* Test the normal flow with a dll loaded */
    SetExpectedDli(g_winmm_midi_out_close);
    g_ExpectedDll = WINMM_DLLNAME;
    g_ExpectedName = "midiOutClose";
    DWORD err = midiOutClose((HMIDIOUT)(ULONG_PTR)0xdeadbeef);
    ok(err == MMSYSERR_INVALHANDLE, "Expected err to be MMSYSERR_INVALHANDLE, was 0x%lx\n", err);
    CheckDliDone();
 
    /* Make sure GetProcAddress fails, also ignore the Failure hook, use the exception to set the address */
    SetExpectedDli(g_winmm_mide_in_close);
    g_ExpectedDll = WINMM_DLLNAME;
    g_ExpectedName = "MixerClose";
    g_BreakFunctionName = true;
    _SEH2_TRY
    {
        err = mixerClose((HMIXER)(ULONG_PTR)0xdeadbeef);
    }
    _SEH2_EXCEPT(ExceptionFilter(_SEH2_GetExceptionInformation(), _SEH2_GetExceptionCode()))
    {
        err = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
    ok(err == MMSYSERR_INVALHANDLE, "Expected err to be MMSYSERR_INVALHANDLE, was 0x%lx\n", err);
    CheckDliDone();
    ok(g_BreakFunctionName == false, "Expected the functionname to be changed\n");
 
    /* Make the LoadLib fail, manually load the library in the Failure Hook,
    Respond to the dliNotePreGetProcAddress with an alternate function address */
    SetExpectedDli(g_sfc_key);
    BOOL ret = SfcIsKeyProtected(NULL, NULL, NULL);
    ok(ret == 12345, "Expected ret to be 12345, was %u\n", ret);    /* The original function returns FALSE! */
    CheckDliDone();
 
    /* Show that it works with the manually returned dll */
    SetExpectedDli(g_sfc_file);
    ret = SfcGetNextProtectedFile(NULL, NULL);
    ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret);
    CheckDliDone();
 
    /* Return a fake dll handle, so that we can see when it is being used, and manually return a function in the Failure Hook */
    SetExpectedDli(g_version_a);
    ret = GetFileVersionInfoA(NULL, NULL, NULL, NULL);
    ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret);
    CheckDliDone();
 
    /* Manually return a function in the failure hook, when the module is the previously set bad one */
    SetExpectedDli(g_version_w);
    ret = GetFileVersionInfoW(NULL, NULL, NULL, NULL);
    ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret);
    CheckDliDone();
 
    if (HIWORD(SymGetOptions) == NULL)
    {
        skip("SymGetOptions until CORE-6504 is fixed\n");
    }
    else
    {
        /* Completely bypass most hooks, by directly replying with a function address */
        SetExpectedDli(g_scard);
        g_BypassMost = true;
        DWORD opt = SymGetOptions();
        g_BypassMost = false;
        ok(opt == 123, "Expected opt to be 123, was %lu\n", opt);    /* The original function returns ERROR_INVALID_HANDLE */
        CheckDliDone();
    }
 
    /* Import by ordinal */
    g_ImportByName = false;
    SetExpectedDli(g_shlwapi);
    PARSEDURLA pua = { sizeof(pua), 0 };
    HRESULT hr = ParseURLA("", &pua);
    ok(hr == URL_E_INVALID_SYNTAX, "Expected tmp to be URL_E_INVALID_SYNTAX, was %lx\n", hr);
    CheckDliDone();
    g_ImportByName = true;
 
    /* Handle LoadLib failure with an exception handler */
    if (HIWORD(MapAndLoad) == NULL)
    {
        skip("MapAndLoad until CORE-6504 is fixed\n");
    }
    else
    {
        SetExpectedDli(g_imagehlp);
        LOADED_IMAGE img = {0};
        ret = 123;
        g_ExceptionIsModule = true;
        g_ExpectedDll = "xxxxxhlp.dll";
        g_ExpectedName = "MapAndLoad";
        _SEH2_TRY
        {
            ret = MapAndLoad("some_not_existing_file.aabbcc", NULL, &img, FALSE, TRUE);
        }
        _SEH2_EXCEPT(ExceptionFilter(_SEH2_GetExceptionInformation(), _SEH2_GetExceptionCode()))
        {
            ;
        }
        _SEH2_END;
        g_ExceptionIsModule = false;
        ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret);
        CheckDliDone();
    }
}

target()

char * target

(

PDelayLoadInfo

pdli

)

Definition at line 50 of file delayimp.cpp.

{
    if (g_Target[0] == '\0' && pdli)
    {
        if (pdli->dlp.fImportByName)
            sprintf(g_Target, "%s!%s", pdli->szDll, pdli->dlp.szProcName);
        else
            sprintf(g_Target, "%s!#%lu", pdli->szDll, pdli->dlp.dwOrdinal);
    }
    return g_Target;
}

Variable Documentation

__pfnDliNotifyHook2

PfnDliHook __pfnDliNotifyHook2

extern

Definition at line 80 of file delayimp.h.

Referenced by __delayLoadHelper2(), and START_TEST().

g_BreakFunctionName

bool g_BreakFunctionName = false

Definition at line 41 of file delayimp.cpp.

Referenced by DliHook(), and START_TEST().

g_BrokenFunctionName

bool g_BrokenFunctionName = false

Definition at line 42 of file delayimp.cpp.

Referenced by DliHook().

g_BypassMost

bool g_BypassMost = false

Definition at line 43 of file delayimp.cpp.

Referenced by DliHook(), and START_TEST().

g_DliHookExpected

unsigned* g_DliHookExpected = NULL

Definition at line 86 of file delayimp.cpp.

Referenced by CheckDli_imp(), CheckDliDone_imp(), and SetExpectedDli().

g_DliHookIndex

size_t g_DliHookIndex = 0

Definition at line 87 of file delayimp.cpp.

Referenced by CheckDli_imp(), CheckDliDone_imp(), and SetExpectedDli().

g_ExceptionIsModule

bool g_ExceptionIsModule = false

Definition at line 44 of file delayimp.cpp.

Referenced by ExceptionFilter(), and START_TEST().

g_ExpectedDll

const char* g_ExpectedDll = NULL

Definition at line 46 of file delayimp.cpp.

Referenced by DliHook(), ExceptionFilter(), and START_TEST().

g_ExpectedName

const char* g_ExpectedName = NULL

Definition at line 47 of file delayimp.cpp.

Referenced by DliHook(), ExceptionFilter(), and START_TEST().

g_imagehlp

unsigned g_imagehlp[] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, LAST_DLI }

Definition at line 398 of file delayimp.cpp.

Referenced by START_TEST().

g_ImportByName

bool g_ImportByName = true

Definition at line 45 of file delayimp.cpp.

Referenced by DliHook(), and START_TEST().

g_scard

unsigned g_scard[] = { dliStartProcessing, dliNoteEndProcessing, LAST_DLI }

Definition at line 396 of file delayimp.cpp.

Referenced by START_TEST().

g_sfc_file

unsigned g_sfc_file[] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }

Definition at line 393 of file delayimp.cpp.

Referenced by START_TEST().

g_sfc_key

unsigned g_sfc_key[] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }

Definition at line 392 of file delayimp.cpp.

Referenced by START_TEST().

g_shlwapi

unsigned g_shlwapi[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }

Definition at line 397 of file delayimp.cpp.

Referenced by START_TEST().

g_Target

char g_Target[100] = { 0 }

Definition at line 48 of file delayimp.cpp.

Referenced by CheckDliDone_imp(), SetExpectedDli(), and target().

g_UsePointers

bool g_UsePointers = false

Definition at line 377 of file delayimp.cpp.

Referenced by Rva2Addr().

g_version_a

unsigned g_version_a[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }

Definition at line 394 of file delayimp.cpp.

Referenced by START_TEST().

g_version_w

unsigned g_version_w[] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }

Definition at line 395 of file delayimp.cpp.

Referenced by START_TEST().

g_VersionDll

HMODULE g_VersionDll

static

Definition at line 144 of file delayimp.cpp.

Referenced by DliFailHook(), and DliHook().

g_winmm_get_cur_task

unsigned g_winmm_get_cur_task[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }

Definition at line 389 of file delayimp.cpp.

Referenced by START_TEST().

g_winmm_mide_in_close

unsigned g_winmm_mide_in_close[] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI }

Definition at line 391 of file delayimp.cpp.

Referenced by START_TEST().

g_winmm_midi_out_close

unsigned g_winmm_midi_out_close[] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI }

Definition at line 390 of file delayimp.cpp.

Referenced by START_TEST().