archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/multimedia/directx/dinput/dx8/dll/dinput.c

1361 lines
39 KiB
Raw Blame History

/*****************************************************************************
*
* DInput.c
*
* Copyright (c) 1996 - 2000 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
*
*
*
* Contents:
*
* DirectInput8Create()
* DllGetClassObject()
* DllCanUnloadNow()
* DllMain()
*
*****************************************************************************/
#include "dinputpr.h"
/*****************************************************************************
*
* The sqiffle for this file.
*
*****************************************************************************/
#define sqfl sqflDll
/***************************************************************************
*
* @doc INTERNAL
*
* @topic The DirectInput synchronization hierarchy |
*
* Extreme caution must be exercised to ensure that the synchronization
* hierarchy is preserved. Failure to observe these rules will result
* in a deadlock.
*
* @ex
*
* In the following list, locks must be taken in the order specified.
* Furthermore, the Dll critical section and the cross-process mutexes
* may never be taken simultaneously. (They should be considered
* to be at the bottom of the hierarchy.)
*
* |
*
* DirectInputEffect
* DirectInputDevice
* Dll critical section
* The cross-process global mutex
* The cross-process joystick mutex
*
***************************************************************************/
/*****************************************************************************
*
* @doc INTERNAL
*
* @global DWORD | g_cRef |
*
* DLL reference count.
*
* @global HINSTANCE | g_hinst |
*
* DLL instance handle.
*
* @global LONG | g_lLoadLibrary |
*
* Number of times we have been artificially <f LoadLibrary>'d
* to prevent ourselves from being unloaded by a non-OLE
* application. Actually, it's the number of times minus one,
* so we can use the interlocked functions to tell whether
* the first <f LoadLibrary> is happening or the last
* <f FreeLibrary> is happening.
*
* We perform a physical <f LoadLibrary> or <f FreeLibrary>
* only on the transition, so as to avoid overflowing the
* counter in KERNEL32.
*
* @global HANDLE | g_hVxD |
*
* Handle to VxD, if available. Win9x only!
*
* @global OPENVXDHANDLE | OpenVxDHandle |
*
* Address of Win9x-only KERNEL32 entry point to convert
* a process handle into a VxD handle. Win9x only!
*
* @global DWORD | g_dwLastBonusPoll |
*
* Last time a bonus poll was made to tickle the SideWinder
* drivers. Win9x only!
*
* @global CRITICAL_SECTION | g_crstDll |
*
* Per-process critical section to protect process-global
* variables.
*
* @global DWORD | g_flEmulation |
*
* Flags that describe what levels of forced emulation are
* active.
*
* @global HHOOK | g_hhkLLHookCheck |
*
* Used only temporarily to test whether low-level hooks
* are supported on the system.
*
* @global HANDLE | g_hmtxGlobal |
*
* System-global mutex that protects shared memory blocks
* which describe device exclusive acquisition information.
*
* @global HANDLE | g_hfm |
*
* Handle to the file mapping that describes the shared
* memory block. NT requires us to keep the handle open
* so that the associated name remains in the namespace.
*
* @global PSHAREDOBJECTPAGE | g_psop |
*
* Pointer to the shared memory block itself.
*
* @global HANDLE | g_hmtxJoy |
*
* System-global mutex that protects shared memory blocks
* which describe joystick effects.
*
* @global UINT | g_wmJoyChanged |
*
* Registered window message which is broadcast when joysticks
* are reconfigured.
*
* @global LONG | g_lWheelGranularity |
*
* The wheel granularity. One hardware "click" of the mouse
* wheel results in this much reported motion.
*
* @global int | g_cdtoMax |
*
* Total number of elements in the g_pdto array.
*
* @global int | g_cdto |
*
* Number of occupied elements in the g_pdto array.
*
* @global PDWORD | g_rgdwCRCTable |
*
* Pointer to the array of values used for CRC generation.
*
* @global PDEVICETOUSER | g_pdto |
*
* Pointer to the device to owner array.
*
* @global BOOL | g_fCritInited |
*
* True if g_crstDll has been initialized.
*
* @global DIAPPHACKS | g_AppHacks |
*
* Application hacks. Initialized to:
* fReacquire FALSE
* fNoSubClass FALSE
* nMaxDeviceNameLength MAX_PATH
*
* @global DWORD | g_dwAppDate |
*
* Application link date stamp, used in generating application ID
*
* @global DWORD | g_dwAppFileLen |
*
* Application file length, used in generating application ID
*
* @global DWORD | g_dwLastMsgSent |
*
* Last message WPARAM broadcast in a g_wmDInputNotify message.
* This is one of the DIMSGWP_* values or zero if no message has yet
* been broadcast. This value only ever increases as applications
* cannot become less identifed as they proceed. This value is used
* as a test of
*
* @global UINT | g_wmDInputNotify |
*
* Registered window message which is broadcast when a change of
* application status is detected.
*
*
*****************************************************************************/
DWORD g_cRef;
HINSTANCE g_hinst;
HINSTANCE g_hinstDbg;
LONG g_lLoadLibrary = -1;
#ifndef WINNT
HANDLE g_hVxD = INVALID_HANDLE_VALUE;
OPENVXDHANDLE _OpenVxDHandle;
DWORD g_dwLastBonusPoll;
#endif
CRITICAL_SECTION g_crstDll;
DWORD g_flEmulation;
LPDWORD g_pdwSequence;
#ifdef USE_SLOW_LL_HOOKS
HHOOK g_hhkLLHookCheck;
#endif
HANDLE g_hmtxGlobal;
HANDLE g_hfm;
struct SHAREDOBJECTPAGE *g_psop;
HANDLE g_hmtxJoy;
UINT g_wmJoyChanged;
LONG g_lWheelGranularity;
int g_cdtoMax;
int g_cdto;
struct _DEVICETOUSER *g_pdto;
PDWORD g_rgdwCRCTable;
BOOL g_fCritInited;
#ifdef WORKER_THREAD
MSGWAITFORMULTIPLEOBJECTSEX _MsgWaitForMultipleObjectsEx =
FakeMsgWaitForMultipleObjectsEx;
#endif
CANCELIO _CancelIO = FakeCancelIO;
#ifdef XDEBUG
TRYENTERCRITICALSECTION _TryEnterCritSec = FakeTryEnterCriticalSection;
int g_cCrit = -1;
UINT g_thidCrit;
HANDLE g_thhandleCrit;
#endif
#ifdef DEBUG
TCHAR g_tszLogFile[MAX_PATH];
#endif
DIAPPHACKS g_AppHacks = {FALSE,FALSE,MAX_PATH};
DWORD g_dwAppDate;
DWORD g_dwAppFileLen;
DWORD g_dwLastMsgSent;
UINT g_wmDInputNotify;
BOOL g_fRawInput;
#ifdef USE_WM_INPUT
HWND g_hwndThread;
HANDLE g_hEventAcquire;
HANDLE g_hEventThread;
HANDLE g_hEventHid;
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllEnterCrit |
*
* Take the DLL critical section.
*
* The DLL critical section is the lowest level critical section.
* You may not attempt to acquire any other critical sections or
* yield while the DLL critical section is held. Failure to
* comply is a violation of the semaphore hierarchy and will
* lead to deadlocks.
*
*****************************************************************************/
void EXTERNAL
DllEnterCrit_(LPCTSTR lptszFile, UINT line)
{
#ifdef XDEBUG
if ( ! _TryEnterCritSec(&g_crstDll) )
{
SquirtSqflPtszV(sqflCrit, TEXT("Dll CritSec blocked @%s,%d"), lptszFile, line);
EnterCriticalSection(&g_crstDll);
}
if (++g_cCrit == 0)
{
g_thidCrit = GetCurrentThreadId();
g_thhandleCrit = GetCurrentThread();
SquirtSqflPtszV(sqflCrit, TEXT("Dll CritSec Entered @%s,%d"), lptszFile, line);
}
AssertF(g_thidCrit == GetCurrentThreadId());
#else
EnterCriticalSection(&g_crstDll);
#endif
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | IsThreadActive |
*
* Check if the thread is still active.
*
*****************************************************************************/
BOOL IsThreadActive( HANDLE hThread )
{
DWORD dwExitCode = 0;
return (NULL != hThread
&& GetExitCodeThread(hThread, &dwExitCode)
&& STILL_ACTIVE == dwExitCode
);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllLeaveCrit |
*
* Leave the DLL critical section.
*
*****************************************************************************/
void EXTERNAL
DllLeaveCrit_(LPCTSTR lptszFile, UINT line)
{
#ifdef XDEBUG
if( IsThreadActive(g_thhandleCrit) ) {
AssertF(g_thidCrit == GetCurrentThreadId());
} else {
SquirtSqflPtszV(sqflCrit, TEXT("Current thread has died."));
}
AssertF(g_cCrit >= 0);
if (--g_cCrit < 0)
{
g_thidCrit = 0;
}
SquirtSqflPtszV(sqflCrit, TEXT("Dll CritSec Leaving @%s,%d"), lptszFile, line);
#endif
LeaveCriticalSection(&g_crstDll);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllInCrit |
*
* Nonzero if we are in the DLL critical section.
*
*****************************************************************************/
#ifdef XDEBUG
BOOL INTERNAL
DllInCrit(void)
{
return g_cCrit >= 0 && g_thidCrit == GetCurrentThreadId();
}
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllAddRef |
*
* Increment the reference count on the DLL.
*
*****************************************************************************/
void EXTERNAL
DllAddRef(void)
{
InterlockedIncrement((LPLONG)&g_cRef);
SquirtSqflPtszV(sqfl, TEXT("DllAddRef -> %d"), g_cRef);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllRelease |
*
* Decrement the reference count on the DLL.
*
*****************************************************************************/
void EXTERNAL
DllRelease(void)
{
InterlockedDecrement((LPLONG)&g_cRef);
SquirtSqflPtszV(sqfl, TEXT("DllRelease -> %d"), g_cRef);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | DllLoadLibrary |
*
* Increment the DLL load count.
*
* This is to prevent a non-OLE application from unloading us
* while we still have windows subclassed.
*
*****************************************************************************/
BOOL EXTERNAL
DllLoadLibrary(void)
{
BOOL fRes = TRUE;
AssertF(InCrit());
if (InterlockedIncrement(&g_lLoadLibrary) == 0)
{
TCHAR tsz[MAX_PATH - 1];
/*
* See hresValidInstanceVer_ for an explanation of why
* we need to pass cA() - 1 instead of cA().
*/
if ( !GetModuleFileName(g_hinst, tsz, cA(tsz) - 1)
|| !LoadLibrary(tsz) )
{
/*
* Restore the refcount.
* There is no race condition here because we are always called
* InCrit so the refcount after the restore can only be the same
* as it was when we entered. If this should change, we would
* need to take extra precautions as two threads could try to
* LoadLibrary at the same time. As only one would do the
* physical load, there is no way to let the other know if the
* load failed.
*/
InterlockedDecrement(&g_lLoadLibrary);
fRes = FALSE;
RPF( "LoadLibrary( self ) failed!, le = %d", GetLastError() );
}
}
SquirtSqflPtszV(sqfl, TEXT("DllLoadLibrary -> %d"), g_lLoadLibrary);
return fRes;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllFreeLibraryAndExitThread |
*
* Worker thread which frees the library in a less dangerous
* (I'm loathe to say "safe") manner.
*
* ThreadProcs are prototyped to return a void but since the return
* would follow some form of ExitThread, it will never be reached so
* this function is declared to return void and cast.
*
* @parm LPVOID | pvContext |
*
* Unused context information.
*
*****************************************************************************/
void INTERNAL
DllFreeLibraryAndExitThread(LPVOID pvContext)
{
/*
* Sleep for one extra second to make extra sure that the
* DllFreeLibrary thread is out and gone.
*/
SleepEx(1000, FALSE);
FreeLibraryAndExitThread(g_hinst, 0);
/*NOTREACHED*/
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllFreeLibrary |
*
* Decrement the DLL load count.
*
* This undoes a previous <f DllLoadLibrary>.
*
* We can't blindly do a <f FreeLibrary>, because we might
* be freeing our last reference, and then we will die because
* we won't exist when the <f FreeLibrary> returns.
*
* If we are in the wacky case, then we spin a low-priority
* thread whose job is to free us. We create it at low priority
* so it will lose the race with this thread, which is busy
* getting out of the way.
*
*****************************************************************************/
void EXTERNAL
DllFreeLibrary(void)
{
if (InterlockedDecrement(&g_lLoadLibrary) < 0)
{
if (g_cRef)
{
/*
* There are other references to us, so we can just
* go away quietly.
*/
FreeLibrary(g_hinst);
} else
{
/*
* This is the last reference, so we need to create a
* worker thread which will call <f FreeLibraryAndExitThread>.
*/
DWORD thid;
HANDLE hth;
hth = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)DllFreeLibraryAndExitThread,
0, CREATE_SUSPENDED, &thid);
if (hth)
{
SetThreadPriority(hth, THREAD_PRIORITY_IDLE);
ResumeThread(hth);
CloseHandle(hth);
}
}
}
SquirtSqflPtszV(sqfl, TEXT("DllFreeLibrary -> %d"), g_lLoadLibrary);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DllGetClassObject |
*
* Create an <i IClassFactory> instance for this DLL.
*
* @parm REFCLSID | rclsid |
*
* The object being requested.
*
* @parm RIID | riid |
*
* The desired interface on the object.
*
* @parm PPV | ppvOut |
*
* Output pointer.
*
* @comm
* The artificial refcount inside <f DllClassObject> helps
* to avoid the race condition described in <f DllCanUnloadNow>.
* It's not perfect, but it makes the race window smaller.
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
#ifdef DEMONSTRATION_FFDRIVER
/*
* Build the fake force feedback driver for internal testing.
*/
GUID CLSID_EffectDriver = {
0x25E609E2,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00
};
#endif
CLSIDMAP c_rgclsidmap[cclsidmap] = {
{ &CLSID_DirectInput8, CDIObj_New, IDS_DIRECTINPUT8,},
{ &CLSID_DirectInputDevice8, CDIDev_New, IDS_DIRECTINPUTDEVICE8,},
#ifdef DEMONSTRATION_FFDRIVER
{ &CLSID_EffectDriver, CJoyEff_New, 0,},
#endif
};
#pragma END_CONST_DATA
STDAPI
DllGetClassObject(REFCLSID rclsid, RIID riid, PPV ppvObj)
{
HRESULT hres;
UINT iclsidmap;
EnterProcR(DllGetClassObject, (_ "G", rclsid));
if ( g_fCritInited )
{
DllAddRef();
for (iclsidmap = 0; iclsidmap < cA(c_rgclsidmap); iclsidmap++)
{
if (IsEqualIID(rclsid, c_rgclsidmap[iclsidmap].rclsid))
{
hres = CDIFactory_New(c_rgclsidmap[iclsidmap].pfnCreate,
riid, ppvObj);
goto done;
}
}
SquirtSqflPtszV(sqfl | sqflError, TEXT("%S: Wrong CLSID"), s_szProc);
*ppvObj = 0;
hres = CLASS_E_CLASSNOTAVAILABLE;
done:;
ExitOleProcPpv(ppvObj);
DllRelease();
} else
{
hres = E_OUTOFMEMORY;
RPF( "Failing DllGetClassObject due to lack of DLL critical section" );
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DllCanUnloadNow |
*
* Determine whether the DLL has any outstanding interfaces.
*
* There is an unavoidable race condition between
* <f DllCanUnloadNow> and the creation of a new
* <i IClassFactory>: Between the time we return from
* <f DllCanUnloaDNow> and the caller inspects the value,
* another thread in the same process may decide to call
* <f DllGetClassObject>, thus suddenly creating an object
* in this DLL when there previously was none.
*
* It is the caller's responsibility to prepare for this
* possibility; there is nothing we can do about it.
*
* @returns
*
* Returns <c S_OK> if the DLL can unload, <c S_FALSE> if
* it is not safe to unload.
*
*****************************************************************************/
STDMETHODIMP
DllCanUnloadNow(void)
{
HRESULT hres;
#ifdef DEBUG
if (IsSqflSet(sqfl))
{
SquirtSqflPtszV(sqfl, TEXT("DllCanUnloadNow() - g_cRef = %d"), g_cRef);
Common_DumpObjects();
}
#endif
hres = g_cRef ? S_FALSE : S_OK;
return hres;
}
#ifdef USE_SLOW_LL_HOOKS
/*****************************************************************************
*
* @doc INTERNAL
*
* @func LRESULT | DllLlHookTest |
*
* Tiny hook procedure used to test whether LL hooks are
* supported by the operating system.
*
* This function is almost never called. We install the
* hook and immediately remove it. The only time it
* manages to get called is if the user moves the mouse
* or presses a key during the microsecond that we exist.
*
* Wait! In fact, this function is *never* called. We
* do not process messages at any point the hook is installed,
* so in fact nothing happens at all.
*
* @parm int | nCode |
*
* Hook code.
*
* @parm WPARAM | wp |
*
* Hook-specific code.
*
* @parm LPARAM | lp |
*
* Hook-specific code.
*
* @returns
*
* Always chains to previous hook.
*
*****************************************************************************/
LRESULT CALLBACK
DllLlHookTest(int nCode, WPARAM wp, LPARAM lp)
{
/*
* Note that there is not actually anything wrong here,
* but it is a theoretically impossible condition, so I want to
* know when it happens.
*/
AssertF(!TEXT("DllLlHookTest - Unexpected hook"));
return CallNextHookEx(g_hhkLLHookCheck, nCode, wp, lp);
}
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllProcessAttach |
*
* Called when the DLL is loaded.
*
* We are not interested in thread attaches and detaches,
* so we disable thread notifications for performance reasons.
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
TCHAR c_tszKernel32[] = TEXT("KERNEL32");
#ifndef WINNT
char c_szOpenVxDHandle[] = "OpenVxDHandle";
#endif
void INTERNAL
DllProcessAttach(void)
{
HINSTANCE hinstK32;
#ifdef DEBUG
WriteProfileString(0, 0, 0); /* Flush the win.ini cache */
Sqfl_Init();
GetProfileString(TEXT("DEBUG"), TEXT("LogFile"), TEXT(""),
g_tszLogFile, cA(g_tszLogFile));
SquirtSqflPtszV(sqfl, TEXT("LoadDll - DInput"));
SquirtSqflPtszV(sqfl, TEXT("Version %x"), DIRECTINPUT_VERSION );
SquirtSqflPtszV(sqfl, TEXT("Built %s at %s\n"), TEXT(__DATE__), TEXT(__TIME__) );
#endif
/*
* Disabling thread library calls is important so that
* we don't deadlock with ourselves over the critical
* section when we spin up the worker thread to handle
* low-level hooks.
*/
DisableThreadLibraryCalls(g_hinst);
g_fCritInited = fInitializeCriticalSection(&g_crstDll);
if ( !g_fCritInited )
{
RPF( "Failed to initialize DLL critical section" );
}
hinstK32 = GetModuleHandle( c_tszKernel32 );
{
CANCELIO tmp;
tmp = (CANCELIO)GetProcAddress(hinstK32, "CancelIo");
if (tmp)
{
_CancelIO = tmp;
} else
{
AssertF(_CancelIO == FakeCancelIO);
}
}
#ifdef WINNT
/*
* For now, only look for TryEnterCriticalSection on NT as it is not
* implemented on 9x but the stub is annoying on 98 with dbg kernels.
*/
{
#ifdef XDEBUG
TRYENTERCRITICALSECTION tmpCrt;
tmpCrt = (TRYENTERCRITICALSECTION)GetProcAddress(hinstK32, "TryEnterCriticalSection");
if (tmpCrt)
{
_TryEnterCritSec = tmpCrt;
} else
{
AssertF(_TryEnterCritSec == FakeTryEnterCriticalSection);
}
#endif
}
#else
_OpenVxDHandle = (OPENVXDHANDLE)GetProcAddress(hinstK32, c_szOpenVxDHandle);
#endif
#ifdef WORKER_THREAD
{
MSGWAITFORMULTIPLEOBJECTSEX tmp;
tmp = (MSGWAITFORMULTIPLEOBJECTSEX)
GetProcAddress(GetModuleHandle(TEXT("USER32")),
"MsgWaitForMultipleObjectsEx");
if (tmp)
{
_MsgWaitForMultipleObjectsEx = tmp;
} else
{
AssertF(_MsgWaitForMultipleObjectsEx ==
FakeMsgWaitForMultipleObjectsEx);
}
}
/*
* We cannot initialize g_hmtxGlobal here, because we
* have no way to report the error back to the caller.
*/
#endif
#ifdef USE_SLOW_LL_HOOKS
/*
* Determine whether low-level input hooks are supported.
*/
g_hhkLLHookCheck = SetWindowsHookEx(WH_MOUSE_LL, DllLlHookTest,
g_hinst, 0);
if (g_hhkLLHookCheck)
{
UnhookWindowsHookEx(g_hhkLLHookCheck);
}
#endif
/*
* Warning! Do not call ExtDll_Init during PROCESS_ATTACH!
*/
g_wmJoyChanged = RegisterWindowMessage(MSGSTR_JOYCHANGED);
g_wmDInputNotify = RegisterWindowMessage(DIRECTINPUT_NOTIFICATION_MSGSTRING);
#ifdef USE_WM_INPUT
g_fRawInput = (DIGetOSVersion() == WINWH_OS);
if( g_fRawInput ) {
g_hEventAcquire = CreateEvent(0x0, 0, 0, 0x0);
g_hEventThread = CreateEvent(0x0, 0, 0, 0x0);
g_hEventHid = CreateEvent(0x0, 0, 0, 0x0);
}
#endif
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DllProcessDetach |
*
* Called when the DLL is unloaded.
*
*****************************************************************************/
void INTERNAL
DllProcessDetach(void)
{
extern PLLTHREADSTATE g_plts;
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("DINPUT8: ProcessDetach. PID:%08x, TID:%08x."),
GetCurrentProcessId(), GetCurrentThreadId() );
#ifdef USE_WM_INPUT
if (g_hEventAcquire)
{
CloseHandle(g_hEventAcquire);
}
if (g_hEventThread)
{
CloseHandle(g_hEventThread);
}
if (g_hEventHid)
{
CloseHandle(g_hEventHid);
}
#endif
#ifndef WINNT
if (g_hVxD != INVALID_HANDLE_VALUE)
{
CloseHandle(g_hVxD);
}
#endif
if (g_psop)
{
UnmapViewOfFile(g_psop);
}
if (g_hfm)
{
CloseHandle(g_hfm);
}
if (g_hmtxGlobal)
{
CloseHandle(g_hmtxGlobal);
}
if (g_hmtxJoy)
{
CloseHandle(g_hmtxJoy);
}
FreePpv( &g_pdto );
FreePpv( &g_rgdwCRCTable );
ExtDll_Term();
if ( g_fCritInited )
{
DeleteCriticalSection(&g_crstDll);
}
if ( g_hinstDbg )
{
FreeLibrary(g_hinstDbg);
}
/*
* Output message last so that anything that follows is known to be bad.
*/
if (g_cRef )
{
RPF("unloaded before all objects released. (cRef:%d)\r\n", g_cRef);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | DllMain |
*
* Called to notify the DLL about various things that can happen.
*
* @parm HINSTANCE | hinst |
*
* The instance handle of this DLL.
*
* @parm DWORD | dwReason |
*
* Notification code.
*
* @parm LPVOID | lpReserved |
*
* Not used.
*
* @returns
*
* Returns <c TRUE> to allow the DLL to load.
*
*****************************************************************************/
BOOL APIENTRY
DllMain(HINSTANCE hinst, DWORD dwReason, LPVOID lpReserved)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
g_hinst = hinst;
DllProcessAttach();
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("DINPUT8: DLL_PROCESS_ATTACH hinst=0x%p, lpReserved=0x%p"),
hinst, lpReserved );
break;
case DLL_PROCESS_DETACH:
DllProcessDetach();
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("DINPUT8: DLL_PROCESS_DETACH hinst=0x%p, lpReserved=0x%p"),
hinst, lpReserved );
break;
}
return 1;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @topic Definitions and Ground Rules |
*
* The phrase "undefined behavior" refers to behavior which is not
* covered by this specification due to violations of a constraint.
* No constraint is imposed by the specification as to the result of
* undefined behavior. It may range from silently ignoring the
* situation to a complete system crash.
*
* If this specification does not prescribe a behavior for a particular
* situation, the behavior is "undefined".
*
* The phrase "It is an error" indicates that failure to comply
* is a violation of the DirectInput specification and results
* in "undefined behavior".
*
* The word "shall" is to be interpreted as a
* requirement on an application; conversely, "shall not" is to be
* interpreted as a prohibition. Violation of a requirement or
* prohibition "is an error".
*
* The word "may" indicates that the indicated behavior is possible
* but is not required.
*
* The word "should" indicates a strong suggestion.
* If the application violates a "should" requirement, then DirectInput
* "may" fail the operation.
*
* Pointer parameters to functions "shall not" be NULL unless explicitly
* documented as OPTIONAL. "It is an error" to pass a pointer to an object
* of the wrong type, to an object which is not allocated, or to an
* object which has been freed or <f Release>d.
*
* Unless indicated otherwise,
* an object pointed to by a pointer parameter documented as an
* IN parameter "shall not" be modified by the called procedure.
* Conversely, a pointer parameter documented
* as an OUT parameter "shall" point to a modifiable object.
*
* When a bitmask of flags is defined, all bits not defined by this
* specification are reserved. Applications "shall not" set reserved
* bits and "shall" ignore reserved bits should they be received.
*
*****************************************************************************/
/*****************************************************************************
*
* @doc EXTERNAL
*
* @topic Initialization and Versions |
*
* In several places, DirectInput requires you to pass an instance
* handle and a version number.
*
* The instance handle must correspond to the application or
* DLL that is initializing the DirectInput object.
*
* DirectInput uses this value to determine whether the
* application or DLL has been certified and to establish
* any special behaviors that may be necessary for
* backwards-compatibility.
*
* It is an error for a DLL to pass the handle of the
* parent application. For example, an ActiveX control
* embedded in a web page which uses DirectInput must
* pass its own instance handle and not the handle of the
* web browser. This ensures that DirectInput recognizes
* the control and can enable any special behaviors
* for the control the behave properly.
*
* The version number parameter specifies which version of
* DirectInput the DirectInput subsystem should emulate.
*
* Applications designed for the latest version of DirectInput
* should pass the value <c DIRECTINPUT_VERSION> as defined
* in dinput.h.
*
* Applications designed for previous versions of DirectInput
* should pass a value corresponding to the version of
* DirectInput they were designed for. For example, an
* application that was designed to run on DirectInput 3.0
* should pass a value of 0x0300.
*
* If you #define <c DIRECTINPUT_VERSION> to 0x0300 before
* including the dinput.h header file, then the dinput.h
* header file will generate DirectInput 3.0-compatible
* structure definitions.
*
*****************************************************************************/
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DirectInputCreateHelper |
*
* This function creates a new DirectInput object
* which supports the <i IDirectInput> COM interface.
*
* On success, the function returns a pointer to the new object in
* *<p lplpDirectInput>.
*
* @parm IN HINSTANCE | hinst |
*
* Instance handle of the application or DLL that is creating
* the DirectInput object.
*
* @parm DWORD | dwVersion |
*
* Version number of the dinput.h header file that was used.
*
* @parm OUT PPV | ppvObj |
* Points to where to return
* the pointer to the <i IDirectInput> interface, if successful.
*
* @parm IN LPUNKNOWN | punkOuter | Pointer to controlling unknown.
*
* @parm RIID | riid |
*
* The interface the application wants to create. This will
* be either <i IDirectInputA> or <i IDirectInputW>.
* If the object is aggregated, then this parameter is ignored.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_INVALIDPARAM>
*
* <c DIERR_OUTOFMEMORY> = <c E_OUTOFMEMORY>:
* Out of memory.
*
*****************************************************************************/
STDMETHODIMP
DirectInputCreateHelper(HINSTANCE hinst, DWORD dwVer,
PPV ppvObj, PUNK punkOuter, RIID riid)
{
HRESULT hres;
EnterProc(DirectInputCreateHelper,
(_ "xxxG", hinst, dwVer, punkOuter, riid));
if (SUCCEEDED(hres = hresFullValidPcbOut(ppvObj, cbX(*ppvObj), 3)))
{
if( g_fCritInited )
{
LPVOID pvTry = NULL;
hres = CDIObj_New(punkOuter,
punkOuter ? &IID_IUnknown : riid, &pvTry);
if( SUCCEEDED( hres ) )
{
AhAppRegister( dwVer, 0x0 );
}
if (SUCCEEDED(hres) && punkOuter == 0)
{
LPDIRECTINPUT pdi = pvTry;
hres = pdi->lpVtbl->Initialize(pdi, hinst, dwVer);
if (SUCCEEDED(hres))
{
*ppvObj = pvTry;
} else
{
Invoke_Release(&pvTry);
*ppvObj = NULL;
}
}
} else
{
RPF( "Failing DirectInputCreate due to lack of DLL critical section" );
hres = E_OUTOFMEMORY;
}
}
ExitOleProcPpv(ppvObj);
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @func HRESULT | DirectInput8Create |
*
* <bnew> This function creates a new DirectInput8 object
* which supports the <i IDirectInput8> COM interfaces. This function
* allows the app to pass an IID so it does not have to do an extra
* QI off some initial interface in order to obtain the one it
* really wanted.
*
* On success, the function returns a pointer to the new object in
* *<p ppvOut>.
* <enew>
*
* @parm IN HINSTANCE | hinst |
*
* Instance handle of the application or DLL that is creating
* the DirectInput object.
*
* See the section titled "Initialization and Versions"
* for more information.
*
* @parm DWORD | dwVersion |
*
* Version number of the dinput.h header file that was used.
*
* See the section titled "Initialization and Versions"
* for more information.
*
* @parm REFIID | riidtlf |
*
* The desired interface interface. Currently, valid values are
* IID_IDirectInput8A and IID_IDirectInput8W.
*
* @parm OUT LPVOID | *ppvOut |
*
* Points to where to return
* the pointer to the <i IDirectInput8> interface, if successful.
*
* @parm IN LPUNKNOWN | punkOuter | Pointer to controlling unknown
* for OLE aggregation, or 0 if the interface is not aggregated.
* Most callers will pass 0.
*
* Note that if aggregation is requested, the object returned
* in *<p lplpDirectInput> will be a pointer to an
* <i IUnknown> rather than an <i IDirectInput8>, as required
* by OLE aggregation.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p lplpDirectInput> parameter is not a valid pointer.
*
* <c DIERR_OUTOFMEMORY> = <c E_OUTOFMEMORY>:
* Out of memory.
*
* <c DIERR_DIERR_OLDDIRECTINPUTVERSION>: The application
* requires a newer version of DirectInput.
*
* <c DIERR_DIERR_BETADIRECTINPUTVERSION>: The application
* was written for an unsupported prerelease version
* of DirectInput.
*
* @comm Calling this function with <p punkOuter> = NULL
* is equivalent to creating the object via
* <f CoCreateInstance>(&CLSID_DirectInput8, <p punkOuter>,
* CLSCTX_INPROC_SERVER, <p refiid>, <p lplpDirectInput>);
* then initializing it with <f Initialize>.
*
* Calling this function with <p punkOuter> != NULL
* is equivalent to creating the object via
* <f CoCreateInstance>(&CLSID_DirectInput8, <p punkOuter>,
* CLSCTX_INPROC_SERVER, &IID_IUnknown, <p lplpDirectInput>).
* The aggregated object must be initialized manually.
*
* Since the IID is passed, there is no need for separate ANSI and
* UNICODE versions of this service however as with other system
* services which are sensitive to character set issues,
* macros in the header file map a generic version of the IID name
* to the appropriate IID for the character set variation.
*
*****************************************************************************/
STDMETHODIMP
DirectInput8Create(HINSTANCE hinst, DWORD dwVer, REFIID riidltf, LPVOID *ppvOut, LPUNKNOWN punkOuter)
{
HRESULT hres = E_NOINTERFACE;
#ifndef XDEBUG
TCHAR tszGuid[ctchNameGuid];
TCHAR tszKey[ctchGuid + 40]; /* 40 is more than enough */
ULONG lRc;
HKEY hk;
#endif
EnterProc(DirectInput8Create, (_ "xxGx", hinst, dwVer, riidltf, ppvOut, punkOuter));
/* Need to maintain a refcount to keep the Dll Around */
DllAddRef();
#ifndef XDEBUG
/*
* To provide the Dx CPL with a mechanism to allow developers to hot swap dinput8
* retail and debug bits
* In the retail version, we will check the CLSID//"CLSID_DirectInput8"/InProcServer32
* If it is found that the last n characters of the Dll name matches "Dinput8D.dll" then
* we will LoadLibrary Dinput8.dll and call the DirectInput8Create function in dinput8d.dll
*
*/
// Convert guid to name
NameFromGUID(tszGuid, &CLSID_DirectInput8);
// The NameFromGUID function adds a prefix, which is easily gotten rid of
wsprintf(tszKey, TEXT("CLSID\\%s\\InProcServer32"), tszGuid+ctchNamePrefix);
// Open the CLSID registry key
lRc = RegOpenKeyEx(HKEY_CLASSES_ROOT, tszKey, 0,
KEY_QUERY_VALUE, &hk);
if (lRc == ERROR_SUCCESS)
{
TCHAR tszDll[MAX_PATH];
int cb;
cb = cbX(tszDll);
lRc = RegQueryValue(hk, 0, tszDll, &cb);
if (lRc == ERROR_SUCCESS)
{
// We are only interested in the last few TCHARs for our comparison
cb = lstrlen(tszDll ) - lstrlen(TEXT("dinput8d.dll"));
if ( ( cb >= 0x0 ) &&
( 0x0 == lstrcmpi(TEXT("dinput8d.dll"), &tszDll[cb])) )
{
// We should use the debug binary
g_hinstDbg = LoadLibrary(tszDll);
if (g_hinstDbg)
{
typedef HRESULT ( WINAPI * DIRECTINPUTCREATE8) ( HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID *ppvOut, LPUNKNOWN punkOuter);
DIRECTINPUTCREATE8 _DirectInputCreate8;
AssertF(g_hinstDbg != g_hinst );
_DirectInputCreate8 = (DIRECTINPUTCREATE8)GetProcAddress( g_hinstDbg, "DirectInput8Create");
if ( _DirectInputCreate8 &&
g_hinstDbg != g_hinst )
{
hres = _DirectInputCreate8(hinst, dwVer, riidltf, ppvOut, punkOuter);
}
}
}
}
RegCloseKey(hk);
}
if( hres == E_NOINTERFACE)
#endif /* XDEBUG */
//Can't create an IDirectInputJoyConfig8 interface through this mechanism, only IDirectInput8 interface!
if (!IsEqualIID(riidltf, &IID_IDirectInputJoyConfig8))
{
hres = DirectInputCreateHelper(hinst, dwVer, ppvOut, punkOuter,
riidltf);
}
DllRelease();
ExitOleProcPpv(ppvOut);
return hres;
}