488 lines
15 KiB
C
488 lines
15 KiB
C
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
|
|
#include "copy.h"
|
|
|
|
#include "ovrlaymn.h"
|
|
#include "drives.h"
|
|
|
|
#include "unicpp\admovr2.h"
|
|
|
|
void FreeExtractIconInfo(int);
|
|
void DAD_ThreadDetach(void);
|
|
void DAD_ProcessDetach(void);
|
|
void TaskMem_MakeInvalid(void);
|
|
void UltRoot_Term(void);
|
|
void NetRoot_Terminate(void);
|
|
void FlushRunDlgMRU(void);
|
|
|
|
STDAPI_(BOOL) ATL_DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/);
|
|
|
|
// from mtpt.cpp
|
|
STDAPI_(void) CMtPt_FinalCleanUp();
|
|
STDAPI_(void) CMtPt_Initialize();
|
|
STDAPI_(void) CMtPt_FakeVolatileKeys();
|
|
// from rgsprtc.cpp
|
|
STDAPI_(void) CRegSupportCached_RSEnableKeyCaching(BOOL fEnable);
|
|
|
|
// Global data
|
|
|
|
BOOL g_bMirroredOS = FALSE; // Is Mirroring enabled
|
|
BOOL g_bBiDiPlatform = FALSE; // Is DATE_LTRREADING flag supported by GetDateFormat() API?
|
|
#ifdef WINDOWS_ME
|
|
// This is needed for BiDi localized win95 RTL stuff
|
|
BOOL g_bBiDiW95Loc = FALSE;
|
|
#endif // WINDOWS_ME
|
|
HINSTANCE g_hinst = NULL;
|
|
extern HANDLE g_hCounter; // Global count of mods to Special Folder cache.
|
|
extern HANDLE g_hRestrictions ; // Global count of mods to restriction cache.
|
|
extern HANDLE g_hSettings; // global count of mods to shellsettings cache
|
|
|
|
HKEY g_hkcrCLSID = NULL; // HKEY_CLASSES_ROOT\CLSID
|
|
HKEY g_hklmExplorer = NULL; // caching for HKEY_LOCAL_MACHINE\...\Explorer
|
|
|
|
|
|
#ifdef DEBUG
|
|
BOOL g_bInDllEntry = FALSE;
|
|
#endif
|
|
|
|
#pragma data_seg(DATASEG_SHARED)
|
|
|
|
// evil global global data on Win95 only. on NT these are regular per process
|
|
|
|
LONG g_cProcesses = 0;
|
|
CRITICAL_SECTION g_csDll = {0};
|
|
CRITICAL_SECTION g_csPrinters = {0};
|
|
|
|
|
|
// these will always be zero
|
|
const LARGE_INTEGER g_li0 = {0};
|
|
const ULARGE_INTEGER g_uli0 = {0};
|
|
|
|
#ifdef WINNT
|
|
BOOL g_bRunOnNT5 = FALSE;
|
|
#else
|
|
BOOL g_bRunOnMemphis = FALSE;
|
|
#endif
|
|
|
|
#pragma data_seg()
|
|
|
|
|
|
#ifdef DEBUG
|
|
// Undefine what shlwapi.h defined so our ordinal asserts map correctly
|
|
#undef PathAddBackslash
|
|
WINSHELLAPI LPTSTR WINAPI PathAddBackslash(LPTSTR lpszPath);
|
|
#undef PathMatchSpec
|
|
WINSHELLAPI BOOL WINAPI PathMatchSpec(LPCTSTR pszFile, LPCTSTR pszSpec);
|
|
#endif
|
|
|
|
BOOL _ProcessAttach(HINSTANCE hDll)
|
|
{
|
|
g_hinst = hDll;
|
|
|
|
g_uCodePage = GetACP();
|
|
|
|
#ifdef WINNT
|
|
InitializeCriticalSection(&g_csDll);
|
|
InitializeCriticalSection(&g_csPrinters);
|
|
#else
|
|
// these are in global global data, thus we need the "Re" version of these APIs
|
|
ReinitializeCriticalSection(&g_csPrinters);
|
|
ReinitializeCriticalSection(&g_csDll);
|
|
#endif
|
|
|
|
// Initialize the MountPoint stuff
|
|
CMtPt_Initialize();
|
|
|
|
// We need to disable HKEY caching for classes using CRegSupportCached in
|
|
// winlogon since it does not get unloaded. This must alos apply to the other
|
|
// services loading shell32.dllNot being unloaded the _ProcessDetach
|
|
// never gets called for shell32, and we never release the cached HKEYs. This
|
|
// prevents the user hives from being unloaded. SO we'll enable caching only
|
|
// for Explorer.exe. (stephstm, 08/20/99)
|
|
|
|
{
|
|
TCHAR szModulePath[MAX_PATH];
|
|
LPTSTR pszModuleName;
|
|
BOOL fEnable = FALSE;
|
|
|
|
GetModuleFileName(GetModuleHandle(NULL), szModulePath, ARRAYSIZE(szModulePath));
|
|
pszModuleName = PathFindFileName(szModulePath);
|
|
|
|
if (pszModuleName)
|
|
{
|
|
// Is this winlogon?
|
|
if (!lstrcmpi(TEXT("explorer.exe"), pszModuleName))
|
|
{
|
|
// No
|
|
fEnable = TRUE;
|
|
}
|
|
}
|
|
|
|
CRegSupportCached_RSEnableKeyCaching(fEnable);
|
|
}
|
|
|
|
|
|
// Check if the mirroring APIs exist on the current
|
|
// platform.
|
|
|
|
g_bMirroredOS = IS_MIRRORING_ENABLED();
|
|
|
|
#ifdef WINDOWS_ME
|
|
|
|
// Check to see if running on BiDi localized Win95
|
|
|
|
g_bBiDiW95Loc = IsBiDiLocalizedWin95(FALSE);
|
|
#endif // WINDOWS_ME
|
|
|
|
|
|
// globally useful registry keys
|
|
RegOpenKey(HKEY_CLASSES_ROOT, c_szCLSID, &g_hkcrCLSID);
|
|
RegCreateKey(HKEY_LOCAL_MACHINE, REGSTR_PATH_EXPLORER, &g_hklmExplorer);
|
|
|
|
InterlockedIncrement(&g_cProcesses);
|
|
|
|
#ifdef WINNT
|
|
g_bRunOnNT5 = IsOS(OS_NT5);
|
|
g_bBiDiPlatform = BOOLFROMPTR(GetModuleHandle(TEXT("LPK.DLL")));
|
|
#else
|
|
g_bRunOnMemphis = IsOS(OS_MEMPHIS);
|
|
g_bBiDiPlatform = ((g_uCodePage == CP_ARABIC) || (g_uCodePage == CP_HEBREW));
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
#define DEREFMACRO(x) x
|
|
#define ValidateORD(_name) ASSERT( _name == (LPVOID)GetProcAddress(hDll, (LPSTR)MAKEINTRESOURCE(DEREFMACRO(_name##ORD))) )
|
|
if (g_cProcesses==1) // no need to be in critical section (just debug)
|
|
{
|
|
ValidateORD(SHValidateUNC);
|
|
ValidateORD(SHChangeNotifyRegister);
|
|
ValidateORD(SHChangeNotifyDeregister);
|
|
ValidateORD(OleStrToStrN);
|
|
ValidateORD(SHCloneSpecialIDList);
|
|
ASSERT(DllGetClassObject==(LPVOID)GetProcAddress(hDll,(LPSTR)MAKEINTRESOURCE(SHDllGetClassObjectORD)));
|
|
ValidateORD(SHLogILFromFSIL);
|
|
ValidateORD(SHMapPIDLToSystemImageListIndex);
|
|
ValidateORD(SHShellFolderView_Message);
|
|
ValidateORD(Shell_GetImageLists);
|
|
ValidateORD(SHGetSpecialFolderPath);
|
|
ValidateORD(StrToOleStrN);
|
|
|
|
ValidateORD(ILClone);
|
|
ValidateORD(ILCloneFirst);
|
|
ValidateORD(ILCombine);
|
|
ValidateORD(ILCreateFromPath);
|
|
ValidateORD(ILFindChild);
|
|
ValidateORD(ILFree);
|
|
ValidateORD(ILGetNext);
|
|
ValidateORD(ILGetSize);
|
|
ValidateORD(ILIsEqual);
|
|
ValidateORD(ILRemoveLastID);
|
|
ValidateORD(PathAddBackslash);
|
|
ValidateORD(PathCombine);
|
|
ValidateORD(PathIsExe);
|
|
ValidateORD(PathMatchSpec);
|
|
ValidateORD(SHGetSetSettings);
|
|
ValidateORD(SHILCreateFromPath);
|
|
ValidateORD(SHFree);
|
|
|
|
ValidateORD(SHAddFromPropSheetExtArray);
|
|
ValidateORD(SHCreatePropSheetExtArray);
|
|
ValidateORD(SHDestroyPropSheetExtArray);
|
|
ValidateORD(SHReplaceFromPropSheetExtArray);
|
|
ValidateORD(SHCreateDefClassObject);
|
|
ValidateORD(SHGetNetResource);
|
|
}
|
|
#endif // DEBUG
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
extern LPMALLOC g_pmemTask;
|
|
AssertMsg(g_pmemTask == NULL, TEXT("Somebody called SHAlloc in DllEntry!"));
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if defined(WINNT) || defined(DEBUG)
|
|
|
|
// Table of all window classes we register so we can unregister them
|
|
// at DLL unload.
|
|
|
|
extern const TCHAR c_szDefViewClass[];
|
|
extern TCHAR const c_szFakeDesktopClass[];
|
|
extern const TCHAR c_szBackgroundPreview2[];
|
|
extern const TCHAR c_szComponentPreview[];
|
|
extern const TCHAR c_szWindowClassName[];
|
|
|
|
const LPCTSTR c_rgszClasses[] = {
|
|
c_szDefViewClass, // defview.cpp
|
|
TEXT("WOACnslWinPreview"), // lnkcon.c
|
|
TEXT("WOACnslFontPreview"), // lnkcon.c
|
|
TEXT("cpColor"), // lnkcon.c
|
|
TEXT("cpShowColor"), // lnkcon.c
|
|
c_szFakeDesktopClass, // restart.c
|
|
c_szStubWindowClass, // rundll32.c
|
|
c_szBackgroundPreview2, // unicpp\dbackp.cpp
|
|
c_szComponentPreview, // unicpp\dcompp.cpp
|
|
TEXT(STR_DESKTOPCLASS), // unicpp\desktop.cpp
|
|
TEXT("MSGlobalFolderOptionsStub"), // unicpp\options.cpp
|
|
c_szWindowClassName, // fsnotify.c
|
|
TEXT("DivWindow"), // fsrchdlg.h
|
|
LINKWINDOW_CLASS, // linkwnd.cpp
|
|
TEXT("ATL Shell Embedding"), // unicpp\dvoc.h
|
|
TEXT("ShellFileSearchControl"), // fsearch.h
|
|
TEXT("GroupButton"), // fsearch
|
|
TEXT("ATL:STATIC"), // unicpp\deskmovr.cpp
|
|
TEXT("DeskMover"), // unicpp\deskmovr.cpp
|
|
};
|
|
|
|
#endif
|
|
|
|
#ifdef WINNT
|
|
#define UnregisterWindowClasses() \
|
|
SHUnregisterClasses(HINST_THISDLL, c_rgszClasses, ARRAYSIZE(c_rgszClasses))
|
|
#else
|
|
// Win95 automatically unregisters classes when a DLL unloads
|
|
#define UnregisterWindowClasses()
|
|
#endif
|
|
|
|
void _ProcessDetach(BOOL bProcessShutdown)
|
|
{
|
|
#ifdef DEBUG
|
|
if (bProcessShutdown)
|
|
{
|
|
// to catch bugs where people use the task allocator at process
|
|
// detatch time (this is a problem becuase OLE32.DLL could be unloaded)
|
|
TaskMem_MakeInvalid();
|
|
}
|
|
#endif
|
|
|
|
FlushRunDlgMRU();
|
|
|
|
// Flush the file class before we free any DLLs, to work around a possible
|
|
// Windows 95 loader bug. The scenario is:
|
|
|
|
// MPRSERV.DLL loads SYNCENG to do some user profile file copying. SYNCENG
|
|
// in turn links to LINKINFO which links to MPR; it also links to SHELL32,
|
|
// which links to COMCTL32 and delay-links to MPR as well. When SYNCENG
|
|
// is unloaded, the loader sends process detach notifications to the entire
|
|
// DLL tree. When we unload our reference to MPR here, that sometimes
|
|
// seems to cause the loader to continue with its process detach messages
|
|
// to more DLLs in the tree, including COMCTL32. COMCTL32 responds to this
|
|
// by destroying the shared heap. Unfortunately we then return back to
|
|
// this chunk of code (we're in SHELL32, remember), and call FlushFileClass.
|
|
// That tries to access COMCTL32's shared heap and faults.
|
|
|
|
// Since this is really a bug in the Windows 95 loader, we work around it
|
|
// here, by calling FlushFileClass (and anything else that references the
|
|
// shared heap) before any FreeLibrary calls.
|
|
|
|
// Do not reference the shared heap after the block of Xxxx_Term() calls
|
|
// below.
|
|
// -- gregj, 03/26/97
|
|
|
|
// Flush the file class cache, some app may have changed associations
|
|
// BUGBUG is this too often?
|
|
FlushFileClass();
|
|
|
|
|
|
// All the per-instance terminate code should be done here.
|
|
// WARNING: Do not touch the shared heap below this point!
|
|
|
|
|
|
if (!bProcessShutdown)
|
|
{
|
|
// some of these may use the task allocator. we can only do
|
|
// this when we our DLL is being unloaded in a process, not
|
|
// at process term since OLE32 might not be around to be called
|
|
// at process shutdown time this memory will be freed as a result
|
|
// of the process address space going away.
|
|
|
|
SpecialFolderIDTerminate();
|
|
BitBucket_Terminate();
|
|
|
|
UltRoot_Term();
|
|
RLTerminate(); // close our use of the Registry list...
|
|
DAD_ProcessDetach();
|
|
|
|
CDrives_Terminate();
|
|
NetRoot_Terminate();
|
|
CopyHooksTerminate();
|
|
IconOverlayManagerTerminate();
|
|
|
|
// being unloaded via FreeLibrary, then do some more stuff.
|
|
// Don't need to do this on process terminate.
|
|
UnregisterWindowClasses();
|
|
FreeExtractIconInfo(-1);
|
|
}
|
|
|
|
if (InterlockedDecrement(&g_cProcesses) == 0)
|
|
{
|
|
// On Win95 where we have global global data only do
|
|
// this on the very last proces detatch. g_cProcesses
|
|
// is a global global variable that tells how many process are
|
|
// using shell32.dll
|
|
|
|
// on NT this is value is always not global so we always execute this code
|
|
|
|
DestroyHashItemTable(NULL);
|
|
FileIconTerm();
|
|
SHChangeNotifyTerminate(TRUE);
|
|
|
|
#ifndef WINNT
|
|
CMtPt_FakeVolatileKeys();
|
|
#endif
|
|
}
|
|
else
|
|
SHChangeNotifyTerminate(FALSE); // still some clients out there
|
|
|
|
// global resources that we need to free in all cases
|
|
|
|
CMtPt_FinalCleanUp();
|
|
|
|
if (g_hkcrCLSID)
|
|
RegCloseKey(g_hkcrCLSID);
|
|
if (g_hklmExplorer)
|
|
RegCloseKey(g_hklmExplorer);
|
|
|
|
SHDestroyCachedGlobalCounter(&g_hCounter);
|
|
SHDestroyCachedGlobalCounter(&g_hRestrictions);
|
|
SHDestroyCachedGlobalCounter(&g_hSettings);
|
|
|
|
#ifdef WINNT
|
|
if (g_hklmApprovedExt && g_hklmApprovedExt != INVALID_HANDLE_VALUE)
|
|
RegCloseKey(g_hklmApprovedExt);
|
|
|
|
DeleteCriticalSection(&g_csDll);
|
|
DeleteCriticalSection(&g_csPrinters);
|
|
#endif
|
|
}
|
|
|
|
BOOL _ThreadDetach()
|
|
{
|
|
ASSERTNONCRITICAL // Thread shouldn't term while holding CS
|
|
DAD_ThreadDetach();
|
|
return TRUE;
|
|
}
|
|
|
|
#ifndef WINNT
|
|
// created by the thunk scripts
|
|
BOOL WINAPI Shl3216_ThunkConnect32(LPCTSTR pszDll16, LPCTSTR pszDll32, HANDLE hIinst, DWORD dwReason);
|
|
BOOL WINAPI Shl1632_ThunkConnect32(LPCTSTR pszDll16, LPCTSTR pszDll32, HANDLE hIinst, DWORD dwReason);
|
|
#endif
|
|
|
|
// ccover uses c run time, so we need to have entry point called DllMain
|
|
#if defined(CCOVER) || defined(_WIN64)
|
|
#define DllEntry DllMain
|
|
#endif
|
|
|
|
STDAPI_(BOOL) DllEntry(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
|
|
{
|
|
#ifndef WINNT
|
|
if (!Shl3216_ThunkConnect32(c_szShell16Dll, c_szShell32Dll, hDll, dwReason))
|
|
return FALSE;
|
|
|
|
if (!Shl1632_ThunkConnect32(c_szShell16Dll, c_szShell32Dll, hDll, dwReason))
|
|
return FALSE;
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
g_bInDllEntry = TRUE;
|
|
#endif
|
|
|
|
switch(dwReason) {
|
|
case DLL_PROCESS_ATTACH:
|
|
CcshellGetDebugFlags(); // Don't put this line under #ifdef
|
|
_ProcessAttach(hDll);
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
_ProcessDetach(lpReserved != NULL);
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
_ThreadDetach();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ATL_DllMain(hDll, dwReason, lpReserved);
|
|
|
|
#ifdef DEBUG
|
|
g_bInDllEntry = FALSE;
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
LRESULT WINAPI SendMessageD( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERTNONCRITICAL;
|
|
#ifdef UNICODE
|
|
return SendMessageW(hWnd, Msg, wParam, lParam);
|
|
#else
|
|
return SendMessageA(hWnd, Msg, wParam, lParam);
|
|
#endif
|
|
}
|
|
|
|
|
|
// In DEBUG, make sure every class we register lives in the c_rgszClasses
|
|
// table so we can clean up properly at DLL unload. NT does not automatically
|
|
// unregister classes when a DLL unloads, so we have to do it manually.
|
|
|
|
ATOM WINAPI RegisterClassD(CONST WNDCLASS *pwc)
|
|
{
|
|
int i;
|
|
for (i = 0; i < ARRAYSIZE(c_rgszClasses); i++) {
|
|
if (lstrcmpi(c_rgszClasses[i], pwc->lpszClassName) == 0) {
|
|
return RealRegisterClass(pwc);
|
|
}
|
|
}
|
|
AssertMsg(0, TEXT("Class %s needs to be added to the c_rgszClasses list"), pwc->lpszClassName);
|
|
return 0;
|
|
}
|
|
|
|
ATOM WINAPI RegisterClassExD(CONST WNDCLASSEX *pwc)
|
|
{
|
|
int i;
|
|
for (i = 0; i < ARRAYSIZE(c_rgszClasses); i++) {
|
|
if (lstrcmpi(c_rgszClasses[i], pwc->lpszClassName) == 0) {
|
|
return RealRegisterClassEx(pwc);
|
|
}
|
|
}
|
|
AssertMsg(0, TEXT("Class %s needs to be added to the c_rgszClasses list"), pwc->lpszClassName);
|
|
return 0;
|
|
}
|
|
|
|
|
|
// In DEBUG, send FindWindow through a wrapper that ensures that the
|
|
// critical section is not taken. FindWindow'ing for a window title
|
|
// sends inter-thread WM_GETTEXT messages, which is not obvious.
|
|
|
|
STDAPI_(HWND) FindWindowD(LPCTSTR lpClassName, LPCTSTR lpWindowName)
|
|
{
|
|
return FindWindowExD(NULL, NULL, lpClassName, lpWindowName);
|
|
}
|
|
|
|
STDAPI_(HWND) FindWindowExD(HWND hwndParent, HWND hwndChildAfter, LPCTSTR lpClassName, LPCTSTR lpWindowName)
|
|
{
|
|
if (lpWindowName) {
|
|
ASSERTNONCRITICAL;
|
|
}
|
|
return RealFindWindowEx(hwndParent, hwndChildAfter, lpClassName, lpWindowName);
|
|
}
|
|
|
|
#endif // DEBUG
|
|
|
|
STDAPI DllCanUnloadNow()
|
|
{
|
|
// shell32 won't be able to be unloaded since there are lots of APIs and
|
|
// other non COM things that will need to keep it loaded
|
|
return S_FALSE;
|
|
}
|