/*++
Copyright (c) 1995-1997 Microsoft Corporation
Module Name :
wam.cpp
Abstract:
This module implements the exported routines for WAM object
Author:
David Kaplan ( DaveK ) 26-Feb-1997
Environment:
User Mode - Win32
Project:
Wam DLL
--*/
//
// Following are the notes from the original MSDEV generated file
// Note: Proxy/Stub Information
// To merge the proxy/stub code into the object DLL, add the file
// dlldatax.c to the project. Make sure precompiled headers
// are turned off for this file, and add _MERGE_PROXYSTUB to the
// defines for the project.
//
// If you are not running WinNT4.0 or Win95 with DCOM, then you
// need to remove the following define from dlldatax.c
// #define _WIN32_WINNT 0x0400
//
// Further, if you are running MIDL without /Oicf switch, you also
// need to remove the following define from dlldatax.c.
// #define USE_STUBLESS_PROXY
//
// Modify the custom build rule for Wam.idl by adding the following
// files to the Outputs.
// Wam_p.c
// dlldata.c
// To build a separate proxy/stub DLL,
// run nmake -f Wamps.mk in the project directory.
// BEGIN mods
// Post-wizard mods appear within BEGIN mods ... END mods
// END mods
#include <isapip.hxx>
#include "pudebug.h"
#include "resource.h"
#include "initguid.h"
#include "wamobj.hxx"
#include "Wam_i.c"
// BEGIN mods
#include <irtldbg.h>
#include "setable.hxx"
#include "wamccf.hxx"
#include <ooptoken.h>
#ifdef _ATL_STATIC_REGISTRY
#include <statreg.h>
#include <statreg.cpp>
#endif
#include <atlimpl.cpp>
// END mods
/************************************************************
* Global Variables
************************************************************/
const CHAR g_pszModuleName[] = "WAM";
const CHAR g_pszWamRegLocation[] =
"System\\CurrentControlSet\\Services\\W3Svc\\WAM";
#ifdef _MERGE_PROXYSTUB
extern "C" HINSTANCE hProxyDll;
#endif
CWamModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_Wam, WAM)
END_OBJECT_MAP()
// BEGIN mods
WAM_CCF_MODULE _WAMCCFModule; // Custom Class Factory Module
DECLARE_PLATFORM_TYPE();
#ifndef _NO_TRACING_
#include <initguid.h>
DEFINE_GUID(IisWamObjectGuid,
0x784d8909, 0xaa8c, 0x11d2, 0x92, 0x5e, 0x00, 0xc0, 0x4f, 0x72, 0xd9, 0x0e);
#else
DECLARE_DEBUG_VARIABLE();
#endif
DECLARE_DEBUG_PRINTS_OBJECT();
BOOL g_fGlobalInitDone = FALSE;
CRITICAL_SECTION g_csGlobalLock;
BOOL g_fEnableTryExcept = TRUE;
// WAM needs to ensure that IISRTL is fully initialized. This happens
// automatically in infocomm when running in-process, but the following
// hack is needed for OOP apps. InitializeIISRTL and TerminateIISRTL
// use an internal refcount, so tying the initialization/termination to
// _Module.GetLockCount works.
LONG CWamModule::Lock()
{
IF_DEBUG( WAM_REFCOUNTS)
DBGPRINTF((DBG_CONTEXT, "WamModule::Lock(%d)\n", GetLockCount()));
InitializeIISRTL();
AtqInitialize(0);
return CComModule::Lock();
}
LONG CWamModule::Unlock()
{
IF_DEBUG( WAM_REFCOUNTS)
DBGPRINTF((DBG_CONTEXT, "WamModule::Unlock(%d)\n", GetLockCount()));
AtqTerminate();
TerminateIISRTL();
return CComModule::Unlock();
}
/************************************************************
* Local Functions
************************************************************/
static void
WAMLoadNTApis(VOID);
static void
WAMUnloadNTApis(VOID);
PFN_INTERLOCKED_COMPARE_EXCHANGE g_pfnInterlockedCompareExchange = NULL;
// END mods
/////////////////////////////////////////////////////////////////////////////
// DLL Entry Point
extern "C"
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
DWORD dwErr = NO_ERROR;
#ifdef _MERGE_PROXYSTUB
if (!PrxDllMain(hInstance, dwReason, lpReserved))
return FALSE;
#endif
if (dwReason == DLL_PROCESS_ATTACH) {
//
// BEGIN mods
//
#ifdef _NO_TRACING_
CREATE_DEBUG_PRINT_OBJECT( g_pszModuleName);
#else
CREATE_DEBUG_PRINT_OBJECT( g_pszModuleName, IisWamObjectGuid);
#endif
if ( !VALID_DEBUG_PRINT_OBJECT()) {
return ( FALSE);
}
(VOID)IISGetPlatformType();
#ifdef _NO_TRACING_
LOAD_DEBUG_FLAGS_FROM_REG_STR( g_pszWamRegLocation,
(DEBUG_ERROR | DEBUG_IID) );
#endif
INITIALIZE_PLATFORM_TYPE();
DBG_ASSERT( IISIsValidPlatform());
INITIALIZE_CRITICAL_SECTION( &g_csGlobalLock);
WAMLoadNTApis();
DBG_REQUIRE( WAM_EXEC_INFO::InitClass());
dwErr = InitializeHseExtensions();
if ( NOERROR == dwErr ) {
IF_DEBUG( INIT_CLEAN) {
DBGPRINTF((DBG_CONTEXT,
" InitializeHseExtensions succeeded.\n" ) );
}
// From ATL generated
_Module.Init(ObjectMap, hInstance);
DisableThreadLibraryCalls(hInstance);
// End of ATL generated
_WAMCCFModule.Init(); // must be after _Module.Init()
}
else {
dwErr = GetLastError();
IF_DEBUG( ERROR ) {
DBGPRINTF((DBG_CONTEXT,
" InitializeHseExtensions failed. Error=%d.\n",
dwErr) );
}
}
// END mods
} else if (dwReason == DLL_PROCESS_DETACH) {
DBGPRINTF( (DBG_CONTEXT,
" Termination of WAM.dll called with lpvReserved=%08x\n",
lpReserved) );
if ( NULL != lpReserved ) {
//
// Only cleanup if there is a FreeLibrary() call
//
return ( TRUE);
}
// BEGIN mods
_WAMCCFModule.Term(); // must be before _Module.Term()
// END mods
_Module.Term();
// BEGIN mods
CleanupHseExtensions();
WAM_EXEC_INFO::CleanupClass();
DoGlobalCleanup();
DeleteCriticalSection( &g_csGlobalLock);
WAMUnloadNTApis();
DELETE_DEBUG_PRINT_OBJECT();
// END mods
}
return (dwErr == NO_ERROR);
} // DllMain()
/////////////////////////////////////////////////////////////////////////////
// Used to determine whether the DLL can be unloaded by OLE
STDAPI DllCanUnloadNow(void)
{
#ifdef _MERGE_PROXYSTUB
if (PrxDllCanUnloadNow() != S_OK)
return S_FALSE;
#endif
return (_Module.GetLockCount()==0) ? S_OK : S_FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// Returns a class factory to create an object of the requested type
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
HRESULT hr;
if (ppv == NULL) {
return ( NULL);
}
*ppv = NULL; // reset the value before getting inside.
IF_DEBUG( IID)
{
DBGPRINTF(( DBG_CONTEXT,
"GetClassObject( " GUID_FORMAT "," GUID_FORMAT ", %08x)\n",
GUID_EXPAND( &rclsid),
GUID_EXPAND( &riid),
ppv));
}
if (ppv == NULL) {
return ( E_POINTER);
}
*ppv = NULL; // set the incoming value to be invalid entry
#ifdef _MERGE_PROXYSTUB
if (PrxDllGetClassObject(rclsid, riid, ppv) == S_OK)
return S_OK;
#endif
hr = _Module.GetClassObject(rclsid, riid, ppv);
// BEGIN mods
if (hr == CLASS_E_CLASSNOTAVAILABLE) {
// If request for standard CF failed -> try custom
IF_DEBUG( IID){
DBGPRINTF(( DBG_CONTEXT, "Trying Custom CF GetClassObject()\n"));
}
#ifdef USE_DEFAULT_CF
hr = _Module.GetClassObject(CLSID_Wam, riid, ppv);
#else
hr = _WAMCCFModule.GetClassObject(rclsid, riid, ppv);
#endif
}
IF_DEBUG( IID)
{
DBGPRINTF(( DBG_CONTEXT,
"GetClassObject() returns %08x. (*ppv=%08x)\n",
hr, *ppv));
}
// END mods
return ( hr);
} // DllGetClassObject()
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer - Adds entries to the system registry
STDAPI DllRegisterServer(void)
{
#ifdef _MERGE_PROXYSTUB
HRESULT hRes = PrxDllRegisterServer();
if (FAILED(hRes))
return hRes;
#endif
// registers object, typelib and all interfaces in typelib
return _Module.RegisterServer(TRUE);
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
#ifdef _MERGE_PROXYSTUB
PrxDllUnregisterServer();
#endif
_Module.UnregisterServer();
return S_OK;
}
/************************************************************
* Global Init/Cleanup functions
************************************************************/
HRESULT
DoGlobalInitializations(IN BOOL fInProc, IN BOOL fEnableTryExcept)
/*++
Description:
This function is used to initialize the global state of various
variable in use. RPC runtime runs into deadlocks with respect to the
NT DLL loader lock. Eventlog for one uses RPC to establish the connections.
Hence, we use this separate global initialize function to setup state
outside the NT DLL loader lock boundary (outside the DllMain())
Arguments:
fInProc - Is this WAM instance running InProc?
fEnableTryExcept - Catch exceptions in ISAPIs?
Returns:
HRESULT - NOERROR means success; otherwise returns custom error.
--*/
{
HRESULT hr = NOERROR;
//
// Use Locks to ensure that only one guy is initializing the data
//
EnterCriticalSection( &g_csGlobalLock);
if ( !g_fGlobalInitDone) {
// remember fEnableTryExcept flag
g_fEnableTryExcept = fEnableTryExcept;
if( !fInProc )
{
hr = CWamOopTokenInfo::Create();
DBG_ASSERT( SUCCEEDED(hr) );
if( WAM_EXEC_INFO::sm_pSVCacheMap == NULL )
{
WAM_EXEC_INFO::sm_pSVCacheMap = new SV_CACHE_MAP();
DBG_ASSERT( WAM_EXEC_INFO::sm_pSVCacheMap != NULL );
if( WAM_EXEC_INFO::sm_pSVCacheMap != NULL )
{
DBG_REQUIRE( WAM_EXEC_INFO::sm_pSVCacheMap->Initialize() );
}
}
}
#ifndef _NO_TRACING_
CREATE_INITIALIZE_DEBUG();
#endif
g_fGlobalInitDone = TRUE;
}
LeaveCriticalSection( &g_csGlobalLock);
IF_DEBUG( INIT_CLEAN) {
DBGPRINTF(( DBG_CONTEXT,
" DoGlobalInitializations() returns hr = %08x\n",
hr));
}
return ( hr);
} // DoGlobalInitializations()
HRESULT DoGlobalCleanup(VOID)
{
HRESULT hr = NOERROR;
if ( !g_fGlobalInitDone) {
return ( hr);
}
EnterCriticalSection( &g_csGlobalLock);
if( CWamOopTokenInfo::HasInstance() )
{
CWamOopTokenInfo::Destroy();
}
delete WAM_EXEC_INFO::sm_pSVCacheMap;
WAM_EXEC_INFO::sm_pSVCacheMap = NULL;
g_fGlobalInitDone = FALSE;
LeaveCriticalSection( &g_csGlobalLock);
return ( hr);
} // DoGlobalCleanup()
/************************************************************
* Thunks for Fake NT APIs
************************************************************/
CRITICAL_SECTION g_csNonNTAPIs;
LONG
FakeInterlockedCompareExchange(
LONG *Destination,
LONG Exchange,
LONG Comperand
)
/*++
Description:
This function fakes the interlocked compare exchange operation for non NT platforms
See WAMLoadNTApis() for details
Returns:
returns the old value at Destination
--*/
{
LONG oldValue;
EnterCriticalSection( &g_csNonNTAPIs);
oldValue = *Destination;
if ( oldValue == Comperand ) {
*Destination = Exchange;
}
LeaveCriticalSection( &g_csNonNTAPIs);
return( oldValue);
} // FakeInterlockedCompareExchange()
static VOID
WAMLoadNTApis(VOID)
/*++
Description:
This function loads the entry point for functions from
Kernel32.dll. If the entry point is missing, the function
pointer will point to a fake routine which does nothing. Otherwise,
it will point to the real function.
It dynamically loads the kernel32.dll to find the entry ponit and then
unloads it after getting the address. For the resulting function
pointer to work correctly one has to ensure that the kernel32.dll is
linked with the dll/exe which links to this file.
--*/
{
// Initialize the critical section for non NT API support, in case if we need this
INITIALIZE_CRITICAL_SECTION( &g_csNonNTAPIs);
if ( g_pfnInterlockedCompareExchange == NULL ) {
HINSTANCE tmpInstance;
//
// load kernel32 and get NT specific entry points
//
tmpInstance = LoadLibrary("kernel32.dll");
if ( tmpInstance != NULL ) {
// For some reason the original function is _InterlockedCompareExchange!
g_pfnInterlockedCompareExchange = (PFN_INTERLOCKED_COMPARE_EXCHANGE )
GetProcAddress( tmpInstance, "InterlockedCompareExchange");
if ( g_pfnInterlockedCompareExchange == NULL ) {
// the function is not available
// Just thunk it.
g_pfnInterlockedCompareExchange = FakeInterlockedCompareExchange;
}
//
// We can free this because we are statically linked to it
//
FreeLibrary(tmpInstance);
}
}
return;
} // WAMLoadNTApis()
static void
WAMUnloadNTApis(VOID)
{
DeleteCriticalSection( &g_csNonNTAPIs);
return;
} // WAMUnloadNTApis()