//+--------------------------------------------------------------------------- // // 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; }