496 lines
12 KiB
C++
496 lines
12 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: libmain.cxx
|
|
//
|
|
// Contents: LibMain for oleds.dll
|
|
//
|
|
// Functions: LibMain, DllGetClassObject
|
|
//
|
|
// History: 25-Oct-94 KrishnaG Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include "winnt.hxx"
|
|
#pragma hdrstop
|
|
|
|
|
|
HINSTANCE g_hInst = NULL;
|
|
extern HMODULE g_hActiveDs;
|
|
WCHAR * szWinNTPrefix = L"@WinNT!";
|
|
HANDLE FpnwLoadLibSemaphore = NULL;
|
|
|
|
//
|
|
// Strings that are loaded depending on locality
|
|
//
|
|
WCHAR g_szBuiltin[100];
|
|
WCHAR g_szNT_Authority[100];
|
|
WCHAR g_szEveryone[100];
|
|
BOOL g_fStringsLoaded = FALSE;
|
|
|
|
//
|
|
// 3rd party extension
|
|
//
|
|
extern PCLASS_ENTRY gpClassHead;
|
|
extern CRITICAL_SECTION g_ExtCritSect;
|
|
|
|
extern CRITICAL_SECTION g_TypeInfoCritSect;
|
|
|
|
//
|
|
// Disabled as it causes link warnings
|
|
// extern CRITICAL_SECTION g_DispTypeInfoCritSect;
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
// ADs debug print, mem leak and object tracking-related stuff
|
|
//---------------------------------------------------------------------------
|
|
|
|
DECLARE_INFOLEVEL(ADs)
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ShutDown
|
|
//
|
|
// Synopsis: Function to handle printing out heap debugging display
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
inline VOID ShutDown()
|
|
{
|
|
#if DBG==1
|
|
#ifndef MSVC
|
|
DUMP_TRACKING_INFO_DELETE();
|
|
DeleteCriticalSection(&g_csOT);
|
|
#endif // ifndef MSVC
|
|
DeleteCriticalSection(&g_csDP);
|
|
#endif
|
|
}
|
|
|
|
extern "C" DWORD heapInfoLevel;
|
|
extern "C" DWORD OtInfoLevel;
|
|
extern "C" DWORD ADsInfoLevel;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetINIHeapInfoLevel
|
|
//
|
|
// Synopsis: Gets various infolevel values from win.ini
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
inline VOID GetINIHeapInfoLevel()
|
|
{
|
|
#if DBG==1
|
|
const INT MAXINFOLEN=11;
|
|
WCHAR awcs[MAXINFOLEN];
|
|
|
|
#ifndef MSVC
|
|
if (GetProfileString(L"winnt",L"heapInfoLevel", L"00000003", awcs,MAXINFOLEN))
|
|
heapInfoLevel = wcstoul(awcs, NULL, 16);
|
|
|
|
if (GetProfileString(L"winnt",L"Ot", L"00000003", awcs, MAXINFOLEN))
|
|
OtInfoLevel = wcstoul(awcs, NULL, 16);
|
|
|
|
#endif // MSVC
|
|
|
|
if (GetProfileString(L"winnt",L"ADsInfoLevel", L"00000003", awcs,MAXINFOLEN))
|
|
ADsInfoLevel = wcstoul(awcs, NULL, 16);
|
|
#endif
|
|
}
|
|
|
|
// Globals
|
|
|
|
|
|
ULONG g_ulObjCount = 0; // Number of objects alive in oleds.dll
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Macro that calculates the number of elements in a statically-defined
|
|
// array.
|
|
//
|
|
// Note - I swiped this from ADsary.cxx - A type-safe array class. Remember
|
|
// to swipe the whole thing as required.
|
|
//-------------------------------------------------------------------------
|
|
#define ARRAY_SIZE(_a) (sizeof(_a) / sizeof(_a[0]))
|
|
|
|
CWinNTProviderCF g_cfProvider;
|
|
CWinNTNamespaceCF g_cfNamespace;
|
|
CWinNTSystemInfoCF g_cfWinNTSystemInfo;
|
|
CUmiConnectionCF g_cfWinNTUmiConn;
|
|
//CWinNTDomainCF g_cfDomain;
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// oleds class factories
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
struct CLSCACHE
|
|
{
|
|
const CLSID * pclsid;
|
|
IClassFactory * pCF;
|
|
};
|
|
|
|
|
|
|
|
CLSCACHE g_aclscache[] =
|
|
{
|
|
&CLSID_WinNTProvider, &g_cfProvider,
|
|
&CLSID_WinNTNamespace, &g_cfNamespace,
|
|
&CLSID_WinNTSystemInfo, &g_cfWinNTSystemInfo,
|
|
&CLSID_WinNTConnectionObject, &g_cfWinNTUmiConn
|
|
};
|
|
|
|
|
|
//+---------------------------------------------------------------
|
|
//
|
|
// Function: DllGetClassObject
|
|
//
|
|
// Synopsis: Standard DLL entrypoint for locating class factories
|
|
//
|
|
//----------------------------------------------------------------
|
|
|
|
STDAPI
|
|
DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID FAR* ppv)
|
|
{
|
|
HRESULT hr;
|
|
size_t i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(g_aclscache); i++)
|
|
{
|
|
if (IsEqualCLSID(clsid, *g_aclscache[i].pclsid))
|
|
{
|
|
hr = g_aclscache[i].pCF->QueryInterface(iid, ppv);
|
|
RRETURN(hr);
|
|
}
|
|
}
|
|
|
|
*ppv = NULL;
|
|
|
|
//
|
|
// Add Debugging Code to indicate that the oleds.DllGetClassObject has been called with an unknown CLSID.
|
|
//
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------
|
|
//
|
|
// Function: DllCanUnloadNow
|
|
//
|
|
// Synopsis: Standard DLL entrypoint to determine if DLL can be unloaded
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
STDAPI
|
|
DllCanUnloadNow(void)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = S_FALSE;
|
|
|
|
if (AggregatorDllCanUnload() ) {
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
void LoadLocalizedStrings()
|
|
{
|
|
if (g_fStringsLoaded) {
|
|
return;
|
|
}
|
|
|
|
if (!LoadStringW(
|
|
g_hInst,
|
|
ADS_WINNT_BUILTIN,
|
|
g_szBuiltin,
|
|
sizeof( g_szBuiltin ) / sizeof( WCHAR )
|
|
)
|
|
) {
|
|
wcscpy(g_szBuiltin, L"BUILTIN");
|
|
}
|
|
|
|
if (!LoadStringW(
|
|
g_hInst,
|
|
ADS_WINNT_NT_AUTHORITY,
|
|
g_szNT_Authority,
|
|
sizeof( g_szNT_Authority ) / sizeof( WCHAR )
|
|
)
|
|
) {
|
|
wcscpy(g_szNT_Authority, L"NT AUTHORITY");
|
|
}
|
|
|
|
if (!LoadStringW(
|
|
g_hInst,
|
|
ADS_WINNT_EVERYONE,
|
|
g_szEveryone,
|
|
sizeof( g_szEveryone ) / sizeof( WCHAR )
|
|
)
|
|
) {
|
|
wcscpy(g_szEveryone, L"Everyone");
|
|
}
|
|
|
|
}
|
|
//+---------------------------------------------------------------
|
|
//
|
|
// Function: LibMain
|
|
//
|
|
// Synopsis: Standard DLL initialization entrypoint
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
EXTERN_C BOOL __cdecl
|
|
LibMain(HINSTANCE hInst, ULONG ulReason, LPVOID pvReserved)
|
|
{
|
|
HRESULT hr;
|
|
|
|
switch (ulReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
//
|
|
// Catch case of init crit sect failing.
|
|
//
|
|
__try {
|
|
|
|
DisableThreadLibraryCalls(hInst);
|
|
|
|
g_hInst = hInst;
|
|
|
|
g_hActiveDs = GetModuleHandle(TEXT("activeds.dll"));
|
|
|
|
#if DBG==1
|
|
#ifndef MSVC
|
|
InitializeCriticalSection(&g_csOT);
|
|
InitializeCriticalSection(&g_csMem);
|
|
#endif
|
|
InitializeCriticalSection(&g_csDP);
|
|
#endif
|
|
|
|
InitializeCriticalSection(&g_TypeInfoCritSect);
|
|
//
|
|
// Disabled to avoid linker warnings
|
|
// InitializeCriticalSection(&g_DispTypeInfoCritSect);
|
|
//
|
|
|
|
//
|
|
// for 3rd party extension
|
|
//
|
|
|
|
InitializeCriticalSection(&g_ExtCritSect);
|
|
|
|
//
|
|
// Initialize the loadlibs critsect.
|
|
//
|
|
InitializeCriticalSection(&g_csLoadLibs);
|
|
|
|
//
|
|
// Load up localized strings.
|
|
//
|
|
LoadLocalizedStrings();
|
|
|
|
gpClassHead = BuildClassesList();
|
|
|
|
//
|
|
// Build the global object class cache
|
|
//
|
|
|
|
hr = CObjNameCache::CreateClassCache(
|
|
&pgPDCNameCache
|
|
);
|
|
if (FAILED(hr)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// create semaphore used to protect global data (DLL handles and
|
|
// function pointers.
|
|
//
|
|
|
|
if ((FpnwLoadLibSemaphore = CreateSemaphore( NULL,1,1,NULL ))
|
|
== NULL)
|
|
{
|
|
return FALSE ;
|
|
}
|
|
|
|
g_pRtlEncryptMemory = (FRTLENCRYPTMEMORY) LoadAdvapi32Function(
|
|
STRINGIZE(RtlEncryptMemory));
|
|
g_pRtlDecryptMemory = (FRTLDECRYPTMEMORY) LoadAdvapi32Function(
|
|
STRINGIZE(RtlDecryptMemory));
|
|
|
|
if( (NULL == g_pRtlEncryptMemory) || (NULL == g_pRtlDecryptMemory) )
|
|
g_pRtlEncryptMemory = g_pRtlDecryptMemory = NULL;
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// Critical failure
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
|
|
//
|
|
// Release semaphor if applicable.
|
|
//
|
|
if (FpnwLoadLibSemaphore) {
|
|
CloseHandle(FpnwLoadLibSemaphore);
|
|
FpnwLoadLibSemaphore = NULL;
|
|
}
|
|
//
|
|
// Del the name cache - delte should handle NULL btw.
|
|
//
|
|
delete pgPDCNameCache;
|
|
//
|
|
// free global list of class entries for 3rd party ext
|
|
//
|
|
|
|
FreeClassesList(gpClassHead);
|
|
|
|
//
|
|
// Delete the critical sections
|
|
//
|
|
#if DBG==1
|
|
#ifndef MSVC
|
|
DeleteCriticalSection(&g_csOT);
|
|
DeleteCriticalSection(&g_csMem);
|
|
#endif
|
|
DeleteCriticalSection(&g_csDP);
|
|
#endif
|
|
|
|
DeleteCriticalSection(&g_TypeInfoCritSect);
|
|
//
|
|
// Causes link warnings if enabled
|
|
// DeleteCriticalSection(&g_DispTypeInfoCritSect);
|
|
//
|
|
DeleteCriticalSection(&g_ExtCritSect);
|
|
|
|
DeleteCriticalSection(&g_csLoadLibs);
|
|
|
|
//
|
|
// Free libs we may have loaded dynamically.
|
|
//
|
|
if (g_hDllNetapi32) {
|
|
FreeLibrary((HMODULE) g_hDllNetapi32);
|
|
g_hDllNetapi32 = NULL;
|
|
}
|
|
|
|
if (g_hDllAdvapi32) {
|
|
FreeLibrary((HMODULE) g_hDllAdvapi32);
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DllMain
|
|
//
|
|
// Synopsis: entry point for NT - post .546
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
|
|
{
|
|
return LibMain((HINSTANCE)hDll, dwReason, lpReserved);
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Function: GetCachedClsidIndex
|
|
//
|
|
// Synopsis: Returns the index of the given CLSID in the cache, or
|
|
// -1 if the CLSID is not present in the cache
|
|
//
|
|
// Arguments: [clsid]
|
|
//
|
|
// Returns: int
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
int
|
|
GetCachedClsidIndex(REFCLSID clsid)
|
|
{
|
|
int i;
|
|
CLSCACHE * pclscache;
|
|
|
|
for (i = 0, pclscache = g_aclscache;
|
|
i < ARRAY_SIZE(g_aclscache);
|
|
i ++, pclscache++)
|
|
{
|
|
if (IsEqualCLSID(*pclscache->pclsid, clsid))
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Function: GetCachedClassFactory
|
|
//
|
|
// Synopsis: Returns the cached class factory with the given index.
|
|
// The pointer returned has been AddRef'd.
|
|
//
|
|
// Arguments: [iclsid]
|
|
//
|
|
// Returns: IClassFactory *
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
IClassFactory *
|
|
GetCachedClassFactory(int iclsid)
|
|
{
|
|
IClassFactory * pCF;
|
|
|
|
// Assert(iclsid >= 0);
|
|
// Assert(iclsid < ARRAY_SIZE(g_aclscache));
|
|
|
|
pCF = g_aclscache[iclsid].pCF;
|
|
pCF->AddRef();
|
|
|
|
return pCF;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Function: GetCachedClsid
|
|
//
|
|
// Synopsis: Returns the CLSID corresponding to the given index.
|
|
// Normally, code should call GetCachedClassFactory to get
|
|
// the class factory directly.
|
|
//
|
|
// Arguments: [iclsid] -- Clsid index
|
|
// [pclsid] -- Matching clsid returned in *pclsid
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
void
|
|
GetCachedClsid(int iclsid, CLSID * pclsid)
|
|
{
|
|
// Assert(iclsid >= 0);
|
|
// Assert(iclsid < ARRAY_SIZE(g_aclscache));
|
|
|
|
*pclsid = *g_aclscache[iclsid].pclsid;
|
|
}
|