able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shell32/dll.cpp

1931 lines
71 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/***************************************************************************
* dll.c
*
* Standard DLL entry-point functions
*
***************************************************************************/
#include "shellprv.h"
#include <ntpsapi.h> // for NtQuery
#include <ntverp.h>
#include <advpub.h> // For REGINSTALL
#include "fstreex.h"
#include "ids.h"
#include "filefldr.h"
#include "uemapp.h"
#include <xpsp1res.h>
#define DECL_CRTFREE
#include <crtfree.h>
#define INSTALL_MSI 1
#include <msi.h> // For MSI_Install()
void MSI_Install(LPTSTR pszMSIFile);
void DoFusion();
STDAPI_(void) Control_FillCache_RunDLL( HWND hwndStub, HINSTANCE hAppInstance, LPSTR pszCmdLine, int nCmdShow );
BOOL CopyRegistryValues (HKEY hKeyBaseSource, LPCTSTR pszSource, HKEY hKeyBaseTarget, LPCTSTR pszTarget);
// DllGetVersion - New for IE 4.0 shell integrated mode
//
// All we have to do is declare this puppy and CCDllGetVersion does the rest
//
DLLVER_DUALBINARY(VER_PRODUCTVERSION_DW, VER_PRODUCTBUILD_QFE);
HRESULT CallRegInstall(LPCSTR szSection)
{
HRESULT hr = E_FAIL;
HINSTANCE hinstAdvPack = LoadLibrary(TEXT("ADVPACK.DLL"));
if (hinstAdvPack)
{
REGINSTALL pfnri = (REGINSTALL)GetProcAddress(hinstAdvPack, "RegInstall");
if (pfnri)
{
char szShdocvwPath[MAX_PATH];
STRENTRY seReg[] = {
{ "SHDOCVW_PATH", szShdocvwPath },
{ "25", "%SystemRoot%" },
{ "11", "%SystemRoot%\\system32" },
};
STRTABLE stReg = { ARRAYSIZE(seReg), seReg };
// Get the location of shdocvw.dll
lstrcpyA(szShdocvwPath, "%SystemRoot%\\system32");
PathAppendA(szShdocvwPath, "shdocvw.dll");
hr = pfnri(g_hinst, szSection, &stReg);
}
// since we only do this from DllInstall() don't load and unload advpack over and over
// FreeLibrary(hinstAdvPack);
}
return hr;
}
BOOL UnregisterTypeLibrary(const CLSID* piidLibrary)
{
TCHAR szScratch[GUIDSTR_MAX];
HKEY hk;
BOOL f = FALSE;
// convert the libid into a string.
//
SHStringFromGUID(*piidLibrary, szScratch, ARRAYSIZE(szScratch));
if (RegOpenKey(HKEY_CLASSES_ROOT, TEXT("TypeLib"), &hk) == ERROR_SUCCESS)
{
f = RegDeleteKey(hk, szScratch);
RegCloseKey(hk);
}
return f;
}
HRESULT Shell32RegTypeLib(void)
{
TCHAR szPath[MAX_PATH];
WCHAR wszPath[MAX_PATH];
// Load and register our type library.
//
GetModuleFileName(HINST_THISDLL, szPath, ARRAYSIZE(szPath));
SHTCharToUnicode(szPath, wszPath, ARRAYSIZE(wszPath));
ITypeLib *pTypeLib;
HRESULT hr = LoadTypeLib(wszPath, &pTypeLib);
if (SUCCEEDED(hr))
{
// call the unregister type library as we had some old junk that
// was registered by a previous version of OleAut32, which is now causing
// the current version to not work on NT...
UnregisterTypeLibrary(&LIBID_Shell32);
hr = RegisterTypeLib(pTypeLib, wszPath, NULL);
if (FAILED(hr))
{
TraceMsg(TF_WARNING, "SHELL32: RegisterTypeLib failed (%x)", hr);
}
pTypeLib->Release();
}
else
{
TraceMsg(TF_WARNING, "SHELL32: LoadTypeLib failed (%x)", hr);
}
return hr;
}
STDAPI CreateShowDesktopOnQuickLaunch()
{
// delete the "_Current Item" key used for tip rotation in welcome.exe on every upgrade
HKEY hkey;
if ( ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Setup\\Welcome"), 0, MAXIMUM_ALLOWED, &hkey ) )
{
RegDeleteValue(hkey, TEXT("_Current Item"));
RegCloseKey(hkey);
}
// create the "Show Desktop" icon in the quick launch tray
TCHAR szPath[MAX_PATH];
if ( SHGetSpecialFolderPath(NULL, szPath, CSIDL_APPDATA, TRUE) )
{
TCHAR szQuickLaunch[MAX_PATH];
LoadString(g_hinst, IDS_QUICKLAUNCH, szQuickLaunch, ARRAYSIZE(szQuickLaunch));
if ( PathAppend( szPath, szQuickLaunch ) )
{
WritePrivateProfileSection( TEXT("Shell"), TEXT("Command=2\0IconFile=explorer.exe,3\0"), szPath );
WritePrivateProfileSection( TEXT("Taskbar"), TEXT("Command=ToggleDesktop\0"), szPath );
return S_OK;
}
}
return E_FAIL;
}
void _DoMyDocsPerUserInit(void)
{
// mydocs!PerUserInit is invoked to setup the desktop.ini and do all the other work
// required to make this correct.
HINSTANCE hInstMyDocs = LoadLibrary(TEXT("mydocs.dll"));
if (hInstMyDocs != NULL)
{
typedef void (*PFNPerUserInit)(void);
PFNPerUserInit pfnPerUserInit = (PFNPerUserInit)GetProcAddress(hInstMyDocs, "PerUserInit");
if (pfnPerUserInit)
{
pfnPerUserInit();
}
FreeLibrary(hInstMyDocs);
}
}
void _NoDriveAutorunTweak()
{
HKEY hkey;
DWORD dwDisp;
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER,
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"),
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisp))
{
DWORD dwRest;
DWORD cbSize = sizeof(dwRest);
if (ERROR_SUCCESS != RegQueryValueEx(hkey, TEXT("NoDriveTypeAutoRun"), NULL, NULL,
(PBYTE)&dwRest, &cbSize))
{
dwRest = 0;
}
if ((0x95 == dwRest) || (0 == dwRest))
{
// Did not change or is not there, let's put 0x91
dwRest = 0x91;
RegSetValueEx(hkey, TEXT("NoDriveTypeAutoRun"), 0, REG_DWORD, (PBYTE)&dwRest, sizeof(dwRest));
}
else
{
// Did change, leave it as is
}
RegCloseKey(hkey);
}
}
// code moved from grpconv.exe
// we'd much rather have new firm links than old floppy ones
// clear out any old ones made by previous runs of setup
void _DeleteOldFloppyLinks(LPITEMIDLIST pidlSendTo, IPersistFile *ppf, IShellLink *psl)
{
IShellFolder *psfSendTo;
if (SUCCEEDED(SHBindToObjectEx(NULL, pidlSendTo, NULL, IID_PPV_ARG(IShellFolder, &psfSendTo))))
{
IEnumIDList *penum;
if (SUCCEEDED(psfSendTo->EnumObjects(NULL, SHCONTF_NONFOLDERS, &penum)))
{
LPITEMIDLIST pidl;
ULONG celt;
while (penum->Next(1, &pidl, &celt) == S_OK)
{
// is it a link???
if (SHGetAttributes(psfSendTo, pidl, SFGAO_LINK))
{
// get the target
LPITEMIDLIST pidlFullPath = ILCombine(pidlSendTo, pidl);
if (pidlFullPath)
{
WCHAR szPath[MAX_PATH];
if (SHGetPathFromIDList(pidlFullPath, szPath) &&
SUCCEEDED(ppf->Load(szPath, 0)))
{
LPITEMIDLIST pidlTarget;
if (SUCCEEDED(psl->GetIDList(&pidlTarget)))
{
TCHAR szTargetPath[MAX_PATH];
// its possible for the old drive letters to have changed. for example if you
// move a removable drive from M:\ to N:\, the shortcut will be invalid, so
// we check against DRIVE_NO_ROOT_DIR.
// unfortunately we can't tell if we should remove it if they used to have a zip
// drive on D:\, and then upgraded and it turned into a hard drive on D:\. the
// shortcut will resolve as DRIVE_FIXED and we dont remove it because they might
// have created a shortcut to the fixed drive before the upgrade.
if (SHGetPathFromIDList(pidlTarget, szTargetPath) &&
PathIsRoot(szTargetPath) &&
((DriveType(PathGetDriveNumber(szTargetPath)) == DRIVE_REMOVABLE) ||
(DriveType(PathGetDriveNumber(szTargetPath)) == DRIVE_NO_ROOT_DIR)))
{
Win32DeleteFile(szPath);
}
ILFree(pidlTarget);
}
}
ILFree(pidlFullPath);
}
}
ILFree(pidl);
}
penum->Release();
}
psfSendTo->Release();
}
}
void _DeleteOldRemovableLinks()
{
IShellLink *psl;
if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLink, &psl))))
{
IPersistFile *ppf;
if (SUCCEEDED(psl->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf))) )
{
LPITEMIDLIST pidlSendTo = SHCloneSpecialIDList(NULL, CSIDL_SENDTO, TRUE);
if (pidlSendTo)
{
// we no longer build a list of removable drives here, since that's done on the fly
// by the sendto menu. just delete any links that we owned before.
_DeleteOldFloppyLinks(pidlSendTo, ppf, psl);
ILFree(pidlSendTo);
}
ppf->Release();
}
psl->Release();
}
}
static const struct
{
PCWSTR pszExt;
}
_DeleteSendToList[] =
{
// make sure these extensions are definitely owned by us, since we're deleting all of them.
{ L".cdburn" }, // clean up after XP beta2 upgrade
{ L".publishwizard" } // clean up after XP beta1 upgrade
};
void _DeleteSendToEntries()
{
TCHAR szSendTo[MAX_PATH];
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_SENDTO, NULL, 0, szSendTo)))
{
for (int i = 0; i < ARRAYSIZE(_DeleteSendToList); i++)
{
TCHAR szSearch[MAX_PATH];
StrCpyN(szSearch, szSendTo, ARRAYSIZE(szSearch));
PathAppend(szSearch, TEXT("*"));
StrCatBuff(szSearch, _DeleteSendToList[i].pszExt, ARRAYSIZE(szSearch));
WIN32_FIND_DATA fd;
HANDLE hfind = FindFirstFile(szSearch, &fd);
if (hfind != INVALID_HANDLE_VALUE)
{
do
{
TCHAR szFile[MAX_PATH];
StrCpyN(szFile, szSendTo, ARRAYSIZE(szFile));
PathAppend(szFile, fd.cFileName);
DeleteFile(szFile);
} while (FindNextFile(hfind, &fd));
FindClose(hfind);
}
}
}
// next kill old removable drives
_DeleteOldRemovableLinks();
}
DWORD _GetProcessorSpeed() // in MHz
{
static DWORD s_dwSpeed = 0;
if (s_dwSpeed == 0)
{
DWORD cb = sizeof(s_dwSpeed);
SHGetValue(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
TEXT("~MHz"), NULL, &s_dwSpeed, &cb);
s_dwSpeed += 1; // fudge factor, my 400 Mhz machine reports 399
}
return s_dwSpeed;
}
DWORD _GetPhysicalMemory() // in MBs
{
NTSTATUS Status;
SYSTEM_BASIC_INFORMATION BasicInfo;
Status = NtQuerySystemInformation(
SystemBasicInformation,
&BasicInfo,
sizeof(BasicInfo),
NULL
);
if (NT_SUCCESS(Status))
{
return ((BasicInfo.NumberOfPhysicalPages * BasicInfo.PageSize) / (1024 * 1024)) + 1; // fudge factor, my 256 Meg machine reports 255
}
else
{
return 64; // Default to 64 Meg (something lame, so that we turn a bunch of stuff off)
}
}
const TCHAR g_cszLetters[] = TEXT("The Quick Brown Fox Jumped Over The Lazy Dog");
BOOL _PerfTestSmoothFonts(void)
{
int cchLength = lstrlen(g_cszLetters);
HDC hdc;
LOGFONT lf;
HFONT hfont;
HFONT hfontOld;
int bkmodeOld;
int iIter;
int iIter2;
int iIter3;
LARGE_INTEGER liFrequency;
LARGE_INTEGER liStart;
LARGE_INTEGER liStop;
LARGE_INTEGER liTotal;
COLORREF colorref;
SIZE size;
DOUBLE eTime[2];
BYTE lfQuality[2];
HDC hdcScreen = GetDC(NULL);
hdc = CreateCompatibleDC(hdcScreen);
HBITMAP hbm = CreateCompatibleBitmap(hdcScreen,200,20);
HBITMAP hbmOld = (HBITMAP)SelectObject(hdc,hbm);
ReleaseDC(NULL,hdcScreen);
bkmodeOld = SetBkMode(hdc, TRANSPARENT);
QueryPerformanceFrequency( &liFrequency );
lfQuality[0] = NONANTIALIASED_QUALITY;
lfQuality[1] = ANTIALIASED_QUALITY;
memset(&lf,0,sizeof(lf));
lstrcpy(lf.lfFaceName,TEXT("Arial"));
lf.lfWeight = FW_BOLD;
for (iIter3 = 0; iIter3 < 2; iIter3++)
{
liTotal.QuadPart = 0;
for (iIter2 = 0; iIter2 < 5; iIter2++)
{
//
// First, Flush the constructed font cache
//
for (iIter = 0; iIter < 64; iIter++)
{
lf.lfHeight = -14-iIter; // 10+ pt
lf.lfQuality = NONANTIALIASED_QUALITY;
hfont = CreateFontIndirect(&lf);
hfontOld = (HFONT)SelectObject(hdc, hfont);
TextOut(hdc, 0, 0, g_cszLetters, cchLength);
SelectObject(hdc, hfontOld);
DeleteObject(hfont);
}
GdiFlush();
colorref = GetPixel(hdc,0,0);
//
// Now measure how long it takes to construct and use a this font
//
lf.lfHeight = -13; // 10 pt
lf.lfQuality = lfQuality[iIter3];
QueryPerformanceCounter( &liStart );
hfont = CreateFontIndirect(&lf);
hfontOld = (HFONT)SelectObject(hdc, hfont);
for (iIter = 0; iIter < 10; iIter++)
{
TextOut(hdc, 0, 0, g_cszLetters, cchLength);
}
GdiFlush();
colorref = GetPixel(hdc,0,0);
QueryPerformanceCounter( &liStop );
liTotal.QuadPart += liStop.QuadPart - liStart.QuadPart;
GetTextExtentPoint(hdc, g_cszLetters, cchLength, &size);
SelectObject(hdc, hfontOld);
DeleteObject(hfont);
}
eTime[iIter3] = (double)liTotal.QuadPart / (double)liFrequency.QuadPart;
}
SetBkMode(hdc, bkmodeOld);
SelectObject(hdc,hbmOld);
DeleteObject(hbm);
DeleteDC(hdc);
return (eTime[1]/eTime[0] <= 4.0);
}
BOOL _PerfTestAlphaLayer(void)
{
DOUBLE eTime = 100.0; // 100 is too large to enable features
int cx = 200;
int cy = 500;
LARGE_INTEGER liFrequency;
QueryPerformanceFrequency( &liFrequency );
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(bmi));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = cx;
bmi.bmiHeader.biHeight = cy;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
//
// Create the image we want to alpha blend onto the screen
//
HDC hdcScreen = GetDC(NULL);
HDC hdcImage = CreateCompatibleDC(NULL);
if (hdcImage != NULL)
{
PVOID pbits;
HBITMAP hbmImage = CreateDIBSection(hdcImage, &bmi, DIB_RGB_COLORS,
&pbits, NULL, NULL);
if (hbmImage != NULL)
{
HBITMAP hbmOld = (HBITMAP)SelectObject(hdcImage, hbmImage);
BitBlt(hdcImage, 0, 0, cx, cy, hdcScreen, 0, 0, SRCCOPY);
if (pbits != NULL)
{
RGBQUAD *prgb = (RGBQUAD *)pbits;
for (int y = 0; y < cy; y++)
{
for (int x = 0; x < cx; x++)
{
BYTE color_r;
BYTE color_g;
BYTE color_b;
color_r = prgb->rgbRed;
color_g = prgb->rgbBlue;
color_b = prgb->rgbGreen;
color_r = color_r / 2;
color_g = color_g / 2;
color_b = color_b / 2;
prgb->rgbRed = color_r;
prgb->rgbBlue = color_g;
prgb->rgbGreen = color_b;
prgb->rgbReserved = 0x80;
prgb++;
}
}
}
HWND hwnd1 = CreateWindowEx( WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
TEXT("Button"),
TEXT("Windows XP"),
WS_POPUPWINDOW,
0, 0,
cx, cy,
NULL, NULL,
0,
NULL);
HWND hwnd2 = CreateWindowEx( WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
TEXT("Button"),
TEXT("Windows XP"),
WS_POPUPWINDOW,
0, 0,
cx, cy,
NULL, NULL,
0,
NULL);
if (hwnd1 != NULL && hwnd2 != NULL)
{
SetWindowPos(hwnd1, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
SetWindowPos(hwnd2, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
BLENDFUNCTION blend;
blend.BlendOp = AC_SRC_OVER;
blend.BlendFlags = 0;
blend.SourceConstantAlpha = 0xFF;
blend.AlphaFormat = AC_SRC_ALPHA;
HDC hdc1 = GetDC(hwnd1);
HDC hdc2 = GetDC(hwnd2);
POINT ptSrc;
SIZE size;
ptSrc.x = 0;
ptSrc.y = 0;
size.cx = cx;
size.cy = cy;
COLORREF colorref;
LARGE_INTEGER liStart;
LARGE_INTEGER liStop;
LARGE_INTEGER liTotal;
GdiFlush();
colorref = GetPixel(hdc1,0,0);
colorref = GetPixel(hdc2,0,0);
colorref = GetPixel(hdcScreen,0,0);
QueryPerformanceCounter( &liStart );
for (int iIter = 0; iIter < 10; iIter++)
{
UpdateLayeredWindow(hwnd1, hdc1, NULL, &size,
hdcImage, &ptSrc, 0,
&blend, ULW_ALPHA);
UpdateLayeredWindow(hwnd2, hdc2, NULL, &size,
hdcImage, &ptSrc, 0,
&blend, ULW_ALPHA);
}
GdiFlush();
colorref = GetPixel(hdc1,0,0);
colorref = GetPixel(hdc2,0,0);
colorref = GetPixel(hdcScreen,0,0);
QueryPerformanceCounter( &liStop );
liTotal.QuadPart = liStop.QuadPart - liStart.QuadPart;
eTime = ((DOUBLE)liTotal.QuadPart * 1000.0) / (DOUBLE)liFrequency.QuadPart;
eTime = eTime / 10.0;
ReleaseDC(hwnd1, hdc1);
ReleaseDC(hwnd2, hdc2);
}
if (hwnd1)
{
DestroyWindow(hwnd1);
}
if (hwnd2)
{
DestroyWindow(hwnd2);
}
SelectObject(hdcImage,hbmOld);
DeleteObject(hbmImage);
}
DeleteDC(hdcImage);
}
ReleaseDC(NULL, hdcScreen);
return (eTime <= 75.0);
}
BOOL g_fPerfFont = FALSE;
BOOL g_fPerfAlpha = FALSE;
#define VISUALEFFECTS_KEY TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\VisualEffects")
#define VISUALEFFECTS_CHECK TEXT("CheckedValue")
#define VISUALEFFECTS_UNCHECK TEXT("UncheckedValue")
#define VISUALEFFECTS_DEFAULT TEXT("DefaultValue")
#define VISUALEFFECTS_APPLIED TEXT("DefaultApplied")
#define VISUALEFFECTS_MINCPU TEXT("MinimumCPU")
#define VISUALEFFECTS_MINMEM TEXT("MinimumMEM")
#define VISUALEFFECTS_FONT TEXT("DefaultByFontTest")
#define VISUALEFFECTS_ALPHA TEXT("DefaultByAlphaTest")
#define VISUALEFFECTS_VER 1
void _ApplyDefaultVisualEffect(HKEY hkey,HKEY hkeyUser)
{
//
// blow this off completely on TS client to avoid stepping
// on TS client's toes
//
if (!IsOS(OS_TERMINALCLIENT))
{
DWORD cb;
DWORD dwDefaultApplied = 0;
if (0 != hkeyUser)
{
cb = sizeof(dwDefaultApplied);
RegQueryValueEx(hkeyUser, VISUALEFFECTS_APPLIED, NULL, NULL, (LPBYTE)&dwDefaultApplied, &cb);
}
//
// Apply defaults only if the version number is old
//
if (VISUALEFFECTS_VER > dwDefaultApplied)
{
LPTSTR pszValue = NULL; // use the default value
DWORD dwMinimumCPU = 0;
DWORD dwMinimumMEM = 0;
BOOL fFontTestDefault = FALSE;
BOOL fAlphaTestDefault = FALSE;
//
// see if a minimum physical memory value is specified
//
cb = sizeof(dwMinimumMEM);
RegQueryValueEx(hkey, VISUALEFFECTS_MINMEM, NULL, NULL, (LPBYTE)&dwMinimumMEM, &cb);
//
// see if a minimum CPU speed is specified
//
cb = sizeof(dwMinimumCPU);
RegQueryValueEx(hkey, VISUALEFFECTS_MINCPU, NULL, NULL, (LPBYTE)&dwMinimumCPU, &cb);
//
// see if the font performance test value is needed
//
cb = sizeof(fFontTestDefault);
RegQueryValueEx(hkey, VISUALEFFECTS_FONT, NULL, NULL, (LPBYTE)&fFontTestDefault, &cb);
//
// see if the alpha performance test value is needed
//
cb = sizeof(fAlphaTestDefault);
RegQueryValueEx(hkey, VISUALEFFECTS_ALPHA, NULL, NULL, (LPBYTE)&fAlphaTestDefault, &cb);
if ( dwMinimumCPU > 0
|| dwMinimumMEM > 0
|| fFontTestDefault
|| fAlphaTestDefault)
{
pszValue = VISUALEFFECTS_CHECK;
if (_GetProcessorSpeed() < dwMinimumCPU)
{
pszValue = VISUALEFFECTS_UNCHECK;
}
if (_GetPhysicalMemory() < dwMinimumMEM)
{
pszValue = VISUALEFFECTS_UNCHECK;
}
if (fFontTestDefault && !g_fPerfFont)
{
pszValue = VISUALEFFECTS_UNCHECK;
}
if (fAlphaTestDefault && !g_fPerfAlpha)
{
pszValue = VISUALEFFECTS_UNCHECK;
}
}
if (IsOS(OS_ANYSERVER))
{
//
// on server, we default to best performance (*everything* off)
//
pszValue = VISUALEFFECTS_UNCHECK;
}
DWORD dwValue = 0;
cb = sizeof(dwValue);
if (pszValue)
{
//
// set the default according to the chosen value
//
RegQueryValueEx(hkey, pszValue, NULL, NULL, (LPBYTE)&dwValue, &cb);
//
// when figuring out settings that need to adjust the default
// value the VISUALEFFECTS_DEFAULT value must be re-applied
// to the per-user key.
//
if (0 != hkeyUser)
{
RegSetValueEx(hkeyUser, VISUALEFFECTS_DEFAULT, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue));
}
}
else
{
//
// read in the default value
//
RegQueryValueEx(hkey, VISUALEFFECTS_DEFAULT, NULL, NULL, (LPBYTE)&dwValue, &cb);
}
//
// how do we apply this setting?
//
DWORD uiAction;
TCHAR szBuf[MAX_PATH];
if (cb = sizeof(szBuf),
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CLSID"), NULL, NULL, (LPBYTE)&szBuf, &cb))
{
//
// by CLSID
//
CLSID clsid;
GUIDFromString(szBuf, &clsid);
IRegTreeItem* pti;
if (SUCCEEDED(CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IRegTreeItem, &pti))))
{
pti->SetCheckState(dwValue);
pti->Release();
}
}
else if (cb = sizeof(uiAction),
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("SPIActionSet"), NULL, NULL, (LPBYTE)&uiAction, &cb))
{
//
// by SPI
//
SHBoolSystemParametersInfo(uiAction, &dwValue);
}
else if (cb = sizeof(szBuf),
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("RegPath"), NULL, NULL, (LPBYTE)&szBuf, &cb))
{
//
// by reg key
//
TCHAR szValueName[96];
cb = sizeof(szValueName);
if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("ValueName"), NULL, NULL, (LPBYTE)&szValueName, &cb))
{
SHSetValue(HKEY_CURRENT_USER, szBuf, szValueName, REG_DWORD, &dwValue, sizeof(dwValue));
}
}
if (0 != hkeyUser)
{
dwDefaultApplied = VISUALEFFECTS_VER;
RegSetValueEx(hkeyUser, VISUALEFFECTS_APPLIED, 0, REG_DWORD, (LPBYTE)&dwDefaultApplied, sizeof(dwDefaultApplied));
}
}
}
}
void _DefaultVisualEffects(void)
{
HKEY hkeyUser;
DWORD dw;
g_fPerfFont = _PerfTestSmoothFonts();
g_fPerfAlpha = _PerfTestAlphaLayer();
if (ERROR_SUCCESS == RegCreateKeyExW(HKEY_CURRENT_USER, VISUALEFFECTS_KEY, 0, TEXTW(""), 0, KEY_SET_VALUE,
NULL, &hkeyUser, &dw))
{
HKEY hkey;
REGSAM samDesired = KEY_READ;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, VISUALEFFECTS_KEY, 0, samDesired, &hkey))
{
TCHAR szName[96];
for (int i = 0; ERROR_SUCCESS == RegEnumKey(hkey, i, szName, ARRAYSIZE(szName)); i++)
{
HKEY hkeyUserItem;
if (ERROR_SUCCESS == RegCreateKeyExW(hkeyUser, szName, 0, TEXTW(""), 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
NULL, &hkeyUserItem, &dw))
{
HKEY hkeyItem;
if (ERROR_SUCCESS == RegOpenKeyEx(hkey, szName, 0, samDesired, &hkeyItem))
{
// only apply the default for the setting if the "NoApplyDefault" reg value is NOT present
if (RegQueryValueEx(hkeyItem, TEXT("NoApplyDefault"), NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
{
_ApplyDefaultVisualEffect(hkeyItem, hkeyUserItem);
}
RegCloseKey(hkeyItem);
}
RegCloseKey(hkeyUserItem);
}
}
RegCloseKey(hkey);
}
RegCloseKey(hkeyUser);
}
}
STDAPI CDeskHtmlProp_RegUnReg(BOOL bInstall);
STDAPI_(BOOL) ApplyRegistrySecurity();
STDAPI_(void) FixPlusIcons();
STDAPI_(void) CleanupFileSystem();
STDAPI_(void) InitializeSharedDocs(BOOL fOnWow64);
#define KEEP_FAILURE(hrSum, hrLast) if (FAILED(hrLast)) hrSum = hrLast;
#ifdef _WIN64
// On IA64 machines we need to copy the EULA file (eula.txt) from %SytemRoot%\System32, to
// %SystemRoot%\SysWOW64. This is needed because when you do help|about on a 32-bit app running
// under wow64 it will look in the syswow64 directory for the file.
//
// Why is shell32.dll doing this and not setup you might ask? The EULA has to be installed by textmode
// since it is unsigned (and changes for every sku). Since txtmode setup does a MOVE instead of a copy, we
// cannot have it installed into two places. Thus the easies thing to do is to simply copy the file
// from the System32 directory to the SysWOW64 directory here. Sigh.
BOOL CopyEULAForWow6432()
{
BOOL bRet = FALSE;
TCHAR szEULAPath[MAX_PATH];
TCHAR szWow6432EULAPath[MAX_PATH];
if (GetSystemWindowsDirectory(szEULAPath, ARRAYSIZE(szEULAPath)))
{
lstrcpyn(szWow6432EULAPath, szEULAPath, ARRAYSIZE(szWow6432EULAPath));
if (PathAppend(szEULAPath, TEXT("System32\\eula.txt")) &&
PathAppend(szWow6432EULAPath, TEXT("SysWOW64\\eula.txt")))
{
// now we have the source (%SystemRoot%\System32\eula.txt) and dest (%SystemRoot%\SysWOW64\eula.txt)
// paths, lets do the copy!
bRet = CopyFile(szEULAPath, szWow6432EULAPath, FALSE);
}
}
return bRet;
}
#endif // _WIN64
//
// Upgrades from Win9x are internally handled by setup as "clean" installs followed by some
// migration of settings. So, the following function does the job of truly detecting a win9x
// upgrade.
// The way it detects: Look in %windir%\system32\$winnt$.inf in the section [Data]
// for Win9xUpgrade=Yes if it is a Win9x upgrade.
//
BOOL IsUpgradeFromWin9x()
{
TCHAR szFilePath[MAX_PATH];
TCHAR szYesOrNo[10];
GetSystemDirectory(szFilePath, ARRAYSIZE(szFilePath));
PathAppend(szFilePath, TEXT("$WINNT$.INF"));
GetPrivateProfileString(TEXT("Data"), // Section name.
TEXT("Win9xUpgrade"), // Key name.
TEXT("No"), // Default string, if key is missing.
szYesOrNo,
ARRAYSIZE(szYesOrNo),
szFilePath); // Full path to "$winnt$.inf" file.
return (0 == lstrcmpi(szYesOrNo, TEXT("Yes")));
}
BOOL IsCleanInstallInProgress()
{
LPCTSTR szKeyName = TEXT("SYSTEM\\Setup");
HKEY hKeySetup;
BOOL fCleanInstall = FALSE;
if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, szKeyName, 0,
KEY_READ, &hKeySetup) == ERROR_SUCCESS)
{
DWORD dwSize;
LONG lResult;
DWORD dwSystemSetupInProgress = 0;
dwSize = sizeof(DWORD);
lResult = RegQueryValueEx (hKeySetup, TEXT("SystemSetupInProgress"), NULL,
NULL, (LPBYTE) &dwSystemSetupInProgress, &dwSize);
if (lResult == ERROR_SUCCESS)
{
DWORD dwMiniSetupInProgress = 0;
dwSize = sizeof(DWORD);
RegQueryValueEx (hKeySetup, TEXT("MiniSetupInProgress"), NULL,
NULL, (LPBYTE) &dwMiniSetupInProgress, &dwSize);
if(dwSystemSetupInProgress && !dwMiniSetupInProgress)
{
DWORD dwUpgradeInProgress = 0;
dwSize = sizeof(DWORD);
//Setup is in progress and MiniSetup is NOT in progress.
//That means that we are in the GUI mode of setup!
//On clean installs, this value won't be there and the following call will fail.
RegQueryValueEx (hKeySetup, TEXT("UpgradeInProgress"), NULL,
NULL, (LPBYTE) &dwUpgradeInProgress, &dwSize);
fCleanInstall = !dwUpgradeInProgress;
}
}
RegCloseKey (hKeySetup);
}
if(fCleanInstall)
{
// Caution: An upgrade from Win9x is internally done by setup as a "clean" install.
// So, we need to figure out if this is really a clean install or an upgrade from
// win9x.
fCleanInstall = !IsUpgradeFromWin9x();
}
return fCleanInstall ;
}
//
// Set the default MFU to be picked up when each user logs on for the
// first time. The string block must be 16 strings long (_0 through _15).
//
STDAPI SetDefaultMFU(UINT ids)
{
HKEY hkMFU;
LONG lRc = RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\SMDEn"),
0, NULL, 0, KEY_WRITE, NULL, &hkMFU, NULL);
if (lRc == ERROR_SUCCESS)
{
for (int i = 0; lRc == ERROR_SUCCESS && i < 16; i++)
{
TCHAR szValue[80];
TCHAR szData[80];
wnsprintf(szValue, ARRAYSIZE(szValue), TEXT("Link%d"), i);
wnsprintf(szData, ARRAYSIZE(szData), TEXT("@xpsp1res.dll,-%d"), ids + i);
DWORD cbData = (lstrlen(szData) + 1) * sizeof(TCHAR);
lRc = RegSetValueEx(hkMFU, szValue, 0, REG_SZ, (LPBYTE)szData, cbData);
}
RegCloseKey(hkMFU);
}
return HRESULT_FROM_WIN32(lRc);
}
STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine)
{
HRESULT hrTemp, hr = S_OK;
// 99/05/03 vtan: If you're reading this section then you are considering
// adding code to the registration/installation of shell32.dll. There are
// now 3 schemes to accomplish this task:
// 1. IE4UINIT.EXE
// Check HKLM\Software\Microsoft\Active Setup\Installed Components\{89820200-ECBD-11cf-8B85-00AA005B4383}
// This says that if there is a new version of IE5 to launch ie4uinit.exe.
// You can add code to this executable if you wish. You need to enlist in
// the setup project on \\trango\slmadd using "ieenlist setup"
// 2. REGSVR32.EXE /n /i:U shell32.dll
// Check HKLM\Software\Microsoft\Active Setup\Installed Components\{89820200-ECBD-11cf-8B85-00AA005B4340}
// This is executed using the same scheme as IE4UINIT.EXE except that the
// executable used is regsvr32.exe with a command line passed to
// shell32!DllInstall. Add your code in the section for "U" below.
// If you put the code in the section which is NOT "U" then your
// code is executed at GUI setup and any changes you make to HKCU
// go into the default user (template). Be careful when putting
// things here as winlogon.exe (or some other process) may put
// your changes into a user profile unconditionally.
// 3. HIVEUSD.INX
// Checks NT build numbers and does command based on the previous build
// number and the current build number only executing the changes between
// the builds. If you wish to add something using this method, currently
// you have to enlist in the setup project on \\rastaman\ntwin using
// "enlist -fgs \\rastaman\ntwin -p setup". To find hiveusd.inx go to
// nt\private\setup\inf\win4\inf. Add the build number which the delta
// is required and a command to launch %SystemRoot%\System32\shmgrate.exe
// with one or two parameters. The first parameter tells what command to
// execute. The second parameter is optional. shmgrate.exe then finds
// shell32.dll and calls shell32!FirstUserLogon. Code here is for upgrading
// HKCU user profiles from one NT build to another NT build.
// Code is executed in the process context shmgrate.exe and is executed
// at a time where no UI is possible. Always use HKLM\Software\Microsoft
// \Windows NT\CurrentVersion\Image File Execution Options\Debugger with
// "-d".
// Schemes 1 and 2 work on either Win9x or WinNT but have the sometimes
// unwanted side effect of ALWAYS getting executed on version upgrades.
// Scheme 3 only gets executed on build number deltas. Because schemes 1
// and 2 are always executed, if a user changes (or deletes) that setting
// it will always get put back. Not so with scheme 3.
// Ideally, the best solution is have an internal shell32 build number
// delta scheme which determines the from build and the to build and does
// a similar mechanism to what hiveusd.inx and shmgrate.exe do. This
// would probably involve either a common installation function (such as
// FirstUserLogon()) which is called differently from Win9x and WinNT or
// common functions to do the upgrade and two entry points (such as
// FirstUserLogonNT() and FirstUserLogonWin9X().
if (bInstall)
{
NT_PRODUCT_TYPE type = NtProductWinNt;
RtlGetNtProductType(&type);
// "U" means it's the per user install call
BOOL fPerUser = pszCmdLine && (StrCmpIW(pszCmdLine, L"U") == 0);
if (fPerUser)
{
// NOTE: Code in this segment get run during first login. We want first
// login to be as quick as possible so try to minimize this section.
// Put per-user install stuff here. Any HKCU registration
// done here is suspect. (If you are setting defaults, do
// so in HKLM and use the SHRegXXXUSValue functions.)
// WARNING: we get called by the ie4unit.exe (ieunit.inf) scheme:
// %11%\shell32.dll,NI,U
// this happens per user, to test this code "regsvr32 /n /i:U shell32.dll"
// Some of this stuff we don't want to do on all upgrades (in particular XP Gold -> XP SPn)
BOOL fUpgradeUserSettings = TRUE;
WCHAR szVersion[50]; // plenty big for aaaa,bbbb,cccc,dddd
DWORD cbVersion = sizeof(szVersion);
if (ERROR_SUCCESS==SHGetValueW(HKEY_CURRENT_USER,
L"Software\\Microsoft\\Active Setup\\Installed Components\\{89820200-ECBD-11cf-8B85-00AA005B4340}",L"Version", // guid is Shell32's Active Setup
NULL, szVersion, &cbVersion))
{
__int64 nverUpgradeFrom;
__int64 nverWinXP;
if (SUCCEEDED(GetVersionFromString64(szVersion, &nverUpgradeFrom)) &&
SUCCEEDED(GetVersionFromString64(L"6,0,2600,0000", &nverWinXP)))
{
fUpgradeUserSettings = nverUpgradeFrom < nverWinXP;
}
}
#ifdef INSTALL_MSI
// Install the Office WebFolders shell namespace extension per user.
MSI_Install(TEXT("webfldrs.msi"));
#endif
hrTemp = CreateShowDesktopOnQuickLaunch();
KEEP_FAILURE(hrTemp, hr);
// upgrade the recent folder.
WCHAR sz[MAX_PATH];
SHGetFolderPath(NULL, CSIDL_RECENT | CSIDL_FLAG_CREATE | CSIDL_FLAG_PER_USER_INIT, NULL, SHGFP_TYPE_CURRENT, sz);
SHGetFolderPath(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE | CSIDL_FLAG_PER_USER_INIT, NULL, SHGFP_TYPE_CURRENT, sz);
// torch this value on upgrade.
// insuring the warning that they will see the ugly desktop.ini files
if (fUpgradeUserSettings)
{
SKDeleteValue(SHELLKEY_HKCU_EXPLORER, L"Advanced", L"ShowSuperHidden");
}
HKEY hk = SHGetShellKey(SHELLKEY_HKCULM_MUICACHE, NULL, FALSE);
if (hk)
{
SHDeleteKeyA(hk, NULL);
RegCloseKey(hk);
}
// delete old sendto entries we dont want any more
_DeleteSendToEntries();
// handle the per user init for this guy
_DoMyDocsPerUserInit();
_DefaultVisualEffects();
// handle the per user change of value for NoDriveAutoRun
if (!IsOS(OS_ANYSERVER))
{
_NoDriveAutorunTweak();
}
}
else
{
// Delete any old registration entries, then add the new ones.
// Keep ADVPACK.DLL loaded across multiple calls to RegInstall.
// (The inf engine doesn't guarantee DelReg/AddReg order, that's
// why we explicitly unreg and reg here.)
//
hrTemp = CallRegInstall("RegDll");
KEEP_FAILURE(hrTemp, hr);
// I suppose we should call out NT-only registrations, just in case
// we ever have to ship a win9x based shell again
hrTemp = CallRegInstall("RegDllNT");
KEEP_FAILURE(hrTemp, hr);
// If we are on NT server, do additional stuff
if (type != NtProductWinNt)
{
hrTemp = CallRegInstall("RegDllNTServer");
KEEP_FAILURE(hrTemp, hr);
}
else // workstation
{
if (!IsOS(OS_PERSONAL))
{
hrTemp = CallRegInstall("RegDllNTPro");
KEEP_FAILURE(hrTemp, hr);
//
// NTRAID#NTBUG9-418621-2001/06/27-jeffreys
//
// If the ForceGuest value is unset, e.g. on upgrade
// from Win2k, set the SimpleSharing/DefaultValue to 0.
//
DWORD dwForceGuest;
DWORD cb = sizeof(dwForceGuest);
if (ERROR_SUCCESS != SHGetValue(HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\Lsa"), TEXT("ForceGuest"), NULL, &dwForceGuest, &cb))
{
dwForceGuest = 0;
SHSetValue(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Folder\\SimpleSharing"), TEXT("DefaultValue"), REG_DWORD, &dwForceGuest, sizeof(dwForceGuest));
}
}
// Service Pack is not allowed to change selfreg.inf
// so we need to do this manually. Must do this after
// RegDll so we can overwrite his settings.
#ifdef _WIN64
hrTemp = SetDefaultMFU(IDS_SHELL32_PROMFU64_0);
#else
hrTemp = SetDefaultMFU(IDS_SHELL32_PROMFU32_0);
#endif
KEEP_FAILURE(hrTemp, hr);
}
//
// If this is clean install, then hide some desktop icons.
//
if(IsCleanInstallInProgress())
{
hrTemp = CallRegInstall("RegHideDeskIcons");
KEEP_FAILURE(hrTemp, hr);
}
// This is apparently the only way to get setup to remove all the registry backup
// for old names no longer in use...
hrTemp = CallRegInstall("CleanupOldRollback1");
KEEP_FAILURE(hrTemp, hr);
hrTemp = CallRegInstall("CleanupOldRollback2");
KEEP_FAILURE(hrTemp, hr);
// REVIEW (ToddB): Move this to DllRegisterServer.
hrTemp = Shell32RegTypeLib();
KEEP_FAILURE(hrTemp, hr);
ApplyRegistrySecurity();
FixPlusIcons();
// Filesystem stuff should be done only on the native platform
// (don't do it when in the emulator) since there is only one
// filesystem. Otherwise the 32-bit version writes 32-bit goo
// into the filesystem that the 64-bit shell32 can't handle
if (!IsOS(OS_WOW6432))
{
CleanupFileSystem();
}
#ifdef _WIN64
// this will copy eula.txt to the %SystemRoot%\SysWOW64 directory for
// 32-bit apps running on IA64 under emulation
CopyEULAForWow6432();
#endif
// Initialize the shared documents objects
InitializeSharedDocs(IsOS(OS_WOW6432));
DoFusion();
}
}
else
{
// We only need one unreg call since all our sections share
// the same backup information
hrTemp = CallRegInstall("UnregDll");
KEEP_FAILURE(hrTemp, hr);
UnregisterTypeLibrary(&LIBID_Shell32);
}
CDeskHtmlProp_RegUnReg(bInstall);
return hr;
}
STDAPI DllRegisterServer(void)
{
// NT5 setup calls this so it is now safe to put code here.
return S_OK;
}
STDAPI DllUnregisterServer(void)
{
return S_OK;
}
BOOL CopyRegistryValues (HKEY hKeyBaseSource, LPCTSTR pszSource, HKEY hKeyBaseTarget, LPCTSTR pszTarget)
{
DWORD dwDisposition, dwMaxValueNameSize, dwMaxValueDataSize;
HKEY hKeySource, hKeyTarget;
BOOL fSuccess = FALSE; //Assume error!
hKeySource = hKeyTarget = NULL;
if ((ERROR_SUCCESS == RegOpenKeyEx(hKeyBaseSource,
pszSource,
0,
KEY_READ,
&hKeySource)) &&
(ERROR_SUCCESS == RegCreateKeyEx(hKeyBaseTarget,
pszTarget,
0,
TEXT(""),
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKeyTarget,
&dwDisposition)) &&
(ERROR_SUCCESS == RegQueryInfoKey(hKeySource,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
&dwMaxValueNameSize,
&dwMaxValueDataSize,
NULL,
NULL)))
{
TCHAR *pszValueName;
void *pValueData;
pszValueName = reinterpret_cast<TCHAR*>(LocalAlloc(LMEM_FIXED, ++dwMaxValueNameSize * sizeof(TCHAR)));
if (pszValueName != NULL)
{
pValueData = LocalAlloc(LMEM_FIXED, dwMaxValueDataSize);
if (pValueData != NULL)
{
DWORD dwIndex, dwType, dwValueNameSize, dwValueDataSize;
dwIndex = 0;
dwValueNameSize = dwMaxValueNameSize;
dwValueDataSize = dwMaxValueDataSize;
while (ERROR_SUCCESS == RegEnumValue(hKeySource,
dwIndex,
pszValueName,
&dwValueNameSize,
NULL,
&dwType,
reinterpret_cast<LPBYTE>(pValueData),
&dwValueDataSize))
{
RegSetValueEx(hKeyTarget,
pszValueName,
0,
dwType,
reinterpret_cast<LPBYTE>(pValueData),
dwValueDataSize);
++dwIndex;
dwValueNameSize = dwMaxValueNameSize;
dwValueDataSize = dwMaxValueDataSize;
}
LocalFree(pValueData);
fSuccess = TRUE; //Succeeded!
}
LocalFree(pszValueName);
}
}
if(hKeySource)
RegCloseKey(hKeySource);
if(hKeyTarget)
RegCloseKey(hKeyTarget);
return fSuccess;
}
STDAPI MergeDesktopAndNormalStreams(void)
{
static const TCHAR scszBaseRegistryLocation[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer");
static const int sciMaximumStreams = 128;
static const TCHAR sccOldMRUListBase = TEXT('a');
// Upgrade from NT4 (classic shell) to Windows 2000 (integrated shell)
// This involves TWO major changes and one minor change:
// 1. Merging DesktopStreamMRU and StreamMRU
// 2. Upgrading the MRUList to MRUListEx
// 3. Leaving the old settings alone for the roaming user profile scenario
// This also involves special casing the users desktop PIDL because this is
// stored as an absolute path PIDL in DesktopStream and needs to be stored
// in Streams\Desktop instead.
// The conversion is performed in-situ and simultaneously.
// 1. Open all the keys we are going to need to do the conversion.
HKEY hKeyBase, hKeyDesktopStreamMRU, hKeyDesktopStreams, hKeyStreamMRU, hKeyStreams;
hKeyBase = hKeyDesktopStreamMRU = hKeyDesktopStreams = hKeyStreamMRU = hKeyStreams = NULL;
if ((ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
scszBaseRegistryLocation,
0,
KEY_ALL_ACCESS,
&hKeyBase)) &&
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
TEXT("DesktopStreamMRU"),
0,
KEY_ALL_ACCESS,
&hKeyDesktopStreamMRU)) &&
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
TEXT("DesktopStreams"),
0,
KEY_ALL_ACCESS,
&hKeyDesktopStreams)) &&
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
TEXT("StreamMRU"),
0,
KEY_ALL_ACCESS,
&hKeyStreamMRU)) &&
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
TEXT("Streams"),
0,
KEY_ALL_ACCESS,
&hKeyStreams)) &&
// 2. Determine whether this upgrade is needed at all. If the presence of
// StreamMRU\MRUListEx is detected then stop.
(ERROR_SUCCESS != RegQueryValueEx(hKeyStreamMRU,
TEXT("MRUListEx"),
NULL,
NULL,
NULL,
NULL)))
{
DWORD *pdwMRUListEx, *pdwMRUListExBase;
pdwMRUListExBase = pdwMRUListEx = reinterpret_cast<DWORD*>(LocalAlloc(LPTR, sciMaximumStreams * sizeof(DWORD) * 2));
if (pdwMRUListEx != NULL)
{
DWORD dwLastFreeSlot, dwMRUListSize, dwType;
TCHAR *pszMRUList, szMRUList[sciMaximumStreams];
// 3. Read the StreamMRU\MRUList, iterate thru this list
// and convert as we go.
dwLastFreeSlot = 0;
dwMRUListSize = sizeof(szMRUList);
if (ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
TEXT("MRUList"),
NULL,
&dwType,
reinterpret_cast<LPBYTE>(szMRUList),
&dwMRUListSize))
{
pszMRUList = szMRUList;
while (*pszMRUList != TEXT('\0'))
{
DWORD dwValueDataSize;
TCHAR szValue[16];
// Read the PIDL information based on the letter in
// the MRUList.
szValue[0] = *pszMRUList++;
szValue[1] = TEXT('\0');
if (ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
szValue,
NULL,
NULL,
NULL,
&dwValueDataSize))
{
DWORD dwValueType;
void *pValueData;
pValueData = LocalAlloc(LMEM_FIXED, dwValueDataSize);
if ((pValueData != NULL) &&
(ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
szValue,
NULL,
&dwValueType,
reinterpret_cast<LPBYTE>(pValueData),
&dwValueDataSize)))
{
// Allocate a new number in the MRUListEx for the PIDL.
*pdwMRUListEx = szValue[0] - sccOldMRUListBase;
wsprintf(szValue, TEXT("%d"), *pdwMRUListEx++);
++dwLastFreeSlot;
RegSetValueEx(hKeyStreamMRU,
szValue,
NULL,
dwValueType,
reinterpret_cast<LPBYTE>(pValueData),
dwValueDataSize);
LocalFree(pValueData);
}
}
}
}
// 4. Read the DesktopStreamMRU\MRUList, iterate thru this
// this and append to the new MRUListEx that is being
// created as well as copying both the PIDL in DesktopStreamMRU
// and the view information in DesktopStreams.
dwMRUListSize = sizeof(szMRUList);
if (ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
TEXT("MRUList"),
NULL,
&dwType,
reinterpret_cast<LPBYTE>(szMRUList),
&dwMRUListSize))
{
bool fConvertedEmptyPIDL;
TCHAR szDesktopDirectoryPath[MAX_PATH];
fConvertedEmptyPIDL = false;
SHGetFolderPath(NULL, CSIDL_DESKTOPDIRECTORY, NULL, SHGFP_TYPE_CURRENT, szDesktopDirectoryPath);
pszMRUList = szMRUList;
while (*pszMRUList != TEXT('\0'))
{
DWORD dwValueDataSize;
TCHAR szSource[16];
// Read the PIDL information based on the letter in
// the MRUList.
szSource[0] = *pszMRUList++;
szSource[1] = TEXT('\0');
if (ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
szSource,
NULL,
NULL,
NULL,
&dwValueDataSize))
{
DWORD dwValueType;
void *pValueData;
pValueData = LocalAlloc(LMEM_FIXED, dwValueDataSize);
if ((pValueData != NULL) &&
(ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
szSource,
NULL,
&dwValueType,
reinterpret_cast<LPBYTE>(pValueData),
&dwValueDataSize)))
{
TCHAR szTarget[16], szStreamPath[MAX_PATH];
if ((SHGetPathFromIDList(reinterpret_cast<LPCITEMIDLIST>(pValueData), szStreamPath) != 0) &&
(0 == lstrcmpi(szStreamPath, szDesktopDirectoryPath)))
{
if (!fConvertedEmptyPIDL)
{
// 99/05/24 #343721 vtan: Prefer the desktop relative PIDL
// (empty PIDL) when given a choice of two PIDLs that refer
// to the desktop. The old absolute PIDL is from SP3 and
// earlier days. The new relative PIDL is from SP4 and
// later days. An upgraded SP3 -> SP4 -> SPx -> Windows
// 2000 system will possibly have old absolute PIDLs.
// Check for the empty PIDL. If this is encountered already
// then don't process this stream.
fConvertedEmptyPIDL = ILIsEmpty(reinterpret_cast<LPCITEMIDLIST>(pValueData));
wsprintf(szSource, TEXT("%d"), szSource[0] - sccOldMRUListBase);
CopyRegistryValues(hKeyDesktopStreams, szSource, hKeyStreams, TEXT("Desktop"));
}
}
else
{
// Allocate a new number in the MRUListEx for the PIDL.
*pdwMRUListEx++ = dwLastFreeSlot;
wsprintf(szTarget, TEXT("%d"), dwLastFreeSlot++);
if (ERROR_SUCCESS == RegSetValueEx(hKeyStreamMRU,
szTarget,
NULL,
dwValueType,
reinterpret_cast<LPBYTE>(pValueData),
dwValueDataSize))
{
// Copy the view information from DesktopStreams to Streams
wsprintf(szSource, TEXT("%d"), szSource[0] - sccOldMRUListBase);
CopyRegistryValues(hKeyDesktopStreams, szSource, hKeyStreams, szTarget);
}
}
LocalFree(pValueData);
}
}
}
}
*pdwMRUListEx++ = static_cast<DWORD>(-1);
RegSetValueEx(hKeyStreamMRU,
TEXT("MRUListEx"),
NULL,
REG_BINARY,
reinterpret_cast<LPCBYTE>(pdwMRUListExBase),
++dwLastFreeSlot * sizeof(DWORD));
LocalFree(reinterpret_cast<HLOCAL>(pdwMRUListExBase));
}
}
if (hKeyStreams != NULL)
RegCloseKey(hKeyStreams);
if (hKeyStreamMRU != NULL)
RegCloseKey(hKeyStreamMRU);
if (hKeyDesktopStreams != NULL)
RegCloseKey(hKeyDesktopStreams);
if (hKeyDesktopStreamMRU != NULL)
RegCloseKey(hKeyDesktopStreamMRU);
if (hKeyBase != NULL)
RegCloseKey(hKeyBase);
return(S_OK);
}
static const int s_ciMaximumNumericString = 32;
int GetRegistryStringValueAsInteger (HKEY hKey, LPCTSTR pszValue, int iDefaultValue)
{
int iResult;
DWORD dwType, dwStringSize;
TCHAR szString[s_ciMaximumNumericString];
dwStringSize = sizeof(szString);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
pszValue,
NULL,
&dwType,
reinterpret_cast<LPBYTE>(szString),
&dwStringSize) && (dwType == REG_SZ))
{
iResult = StrToInt(szString);
}
else
{
iResult = iDefaultValue;
}
return(iResult);
}
void SetRegistryIntegerAsStringValue (HKEY hKey, LPCTSTR pszValue, int iValue)
{
TCHAR szString[s_ciMaximumNumericString];
wnsprintf(szString, ARRAYSIZE(szString), TEXT("%d"), iValue);
TW32(RegSetValueEx(hKey,
pszValue,
0,
REG_SZ,
reinterpret_cast<LPBYTE>(szString),
(lstrlen(szString) + sizeof('\0')) * sizeof(TCHAR)));
}
STDAPI MoveAndAdjustIconMetrics(void)
{
// 99/06/06 #309198 vtan: The following comes from hiveusd.inx which is
// where this functionality used to be executed. It used to consist of
// simple registry deletion and addition. This doesn't work on upgrade
// when the user has large icons (Shell Icon Size == 48).
// In this case that metric must be moved and the new values adjusted
// so that the metric is preserved should the user then decide to turn
// off large icons.
// To restore old functionality, remove the entry in hiveusd.inx at
// build 1500 which is where this function is invoked and copy the
// old text back in.
/*
HKR,"1508\Hive\2","Action",0x00010001,3
HKR,"1508\Hive\2","KeyName",0000000000,"Control Panel\Desktop\WindowMetrics"
HKR,"1508\Hive\2","Value",0000000000,"75"
HKR,"1508\Hive\2","ValueName",0000000000,"IconSpacing"
HKR,"1508\Hive\3","Action",0x00010001,3
HKR,"1508\Hive\3","KeyName",0000000000,"Control Panel\Desktop\WindowMetrics"
HKR,"1508\Hive\3","Value",0000000000,"1"
HKR,"1508\Hive\3","ValueName",0000000000,"IconTitleWrap"
*/
// Icon metric keys have moved from HKCU\Control Panel\Desktop\Icon*
// to HKCU\Control Panel\Desktop\WindowMetrics\Icon* but only 3 values
// should be moved. These are "IconSpacing", "IconTitleWrap" and
// "IconVerticalSpacing". This code is executed before the deletion
// entry in hiveusd.inx so that it can get the values before they
// are deleted. The addition section has been remove (it's above).
static const TCHAR s_cszIconSpacing[] = TEXT("IconSpacing");
static const TCHAR s_cszIconTitleWrap[] = TEXT("IconTitleWrap");
static const TCHAR s_cszIconVerticalSpacing[] = TEXT("IconVerticalSpacing");
static const int s_ciStandardOldIconSpacing = 75;
static const int s_ciStandardNewIconSpacing = -1125;
HKEY hKeyDesktop, hKeyWindowMetrics;
hKeyDesktop = hKeyWindowMetrics = NULL;
if ((ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
TEXT("Control Panel\\Desktop"),
0,
KEY_ALL_ACCESS,
&hKeyDesktop)) &&
(ERROR_SUCCESS == RegOpenKeyEx(hKeyDesktop,
TEXT("WindowMetrics"),
0,
KEY_ALL_ACCESS,
&hKeyWindowMetrics)))
{
int iIconSpacing, iIconTitleWrap, iIconVerticalSpacing;
// 1. Read the values that we wish the move and adjust.
iIconSpacing = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconSpacing, s_ciStandardOldIconSpacing);
iIconTitleWrap = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconTitleWrap, 1);
iIconVerticalSpacing = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconVerticalSpacing, s_ciStandardOldIconSpacing);
// 2. Perform the adjustment.
iIconSpacing = s_ciStandardNewIconSpacing * iIconSpacing / s_ciStandardOldIconSpacing;
iIconVerticalSpacing = s_ciStandardNewIconSpacing * iIconVerticalSpacing / s_ciStandardOldIconSpacing;
// 3. Write the values back out in the new (moved) location.
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconSpacing, iIconSpacing);
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconTitleWrap, iIconTitleWrap);
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconVerticalSpacing, iIconVerticalSpacing);
// 4. Let winlogon continue processing hiveusd.inx and delete the
// old entries in the process. We already created the new entries
// and that has been removed from hiveusd.inx.
}
if (hKeyWindowMetrics != NULL)
TW32(RegCloseKey(hKeyWindowMetrics));
if (hKeyDesktop != NULL)
TW32(RegCloseKey(hKeyDesktop));
return(S_OK);
}
STDAPI FirstUserLogon(LPCSTR pcszCommand, LPCSTR pcszOptionalArguments)
{
const struct
{
LPCSTR pcszCommand;
HRESULT (WINAPI *pfn)();
}
sCommands[] =
{
{ "MergeDesktopAndNormalStreams", MergeDesktopAndNormalStreams },
{ "MoveAndAdjustIconMetrics", MoveAndAdjustIconMetrics },
};
HRESULT hr = E_FAIL;
// Match what shmgrate.exe passed us and execute the command.
// Only use the optional argument if required. Note this is
// done ANSI because the original command line is ANSI from
// shmgrate.exe.
for (int i = 0; i < ARRAYSIZE(sCommands); ++i)
{
if (lstrcmpA(pcszCommand, sCommands[i].pcszCommand) == 0)
{
hr = sCommands[i].pfn();
break;
}
}
return hr;
}
#ifdef INSTALL_MSI
//
// WebFolders namespace extension installation.
// This is the code that initially installs the Office WebFolders
// shell namespace extension on the computer. Code in shmgrate.exe
// (see private\windows\shell\migrate) performs per-user
// web folders registration duties.
//
typedef UINT (WINAPI * PFNMSIINSTALLPRODUCT)(LPCTSTR, LPCTSTR);
typedef INSTALLUILEVEL (WINAPI * PFNMSISETINTERNALUI)(INSTALLUILEVEL, HWND *);
#define GETPROC(var, hmod, ptype, fn) ptype var = (ptype)GetProcAddress(hmod, fn)
#define API_MSISETINTERNALUI "MsiSetInternalUI"
#ifdef UNICODE
# define API_MSIINSTALLPRODUCT "MsiInstallProductW"
#else
# define API_MSIINSTALLPRODUCT "MsiInstallProductA"
#endif
void MSI_Install(LPTSTR pszMSIFile)
{
HMODULE hmod = LoadLibrary(TEXT("msi.dll"));
if (hmod)
{
BOOL bFreeLib = FALSE;
GETPROC(pfnMsiSetInternalUI, hmod, PFNMSISETINTERNALUI, API_MSISETINTERNALUI);
GETPROC(pfnMsiInstallProduct, hmod, PFNMSIINSTALLPRODUCT, API_MSIINSTALLPRODUCT);
if (pfnMsiSetInternalUI && pfnMsiInstallProduct)
{
TCHAR szPath[MAX_PATH];
GetSystemDirectory(szPath, ARRAYSIZE(szPath));
PathAppend(szPath, pszMSIFile);
//
// Use "silent" install mode. No UI.
//
INSTALLUILEVEL oldUILevel = pfnMsiSetInternalUI(INSTALLUILEVEL_NONE, NULL);
// Install the MSI package.
// Old code did this polling loop on a background thread, but that doesn't
// work since we're called at DllInstall time, and the process will
// go away before the install completes. Must do it all on this thread.
// Wait a little bit before re-trying.
UINT uRet = 0;
do {
uRet = pfnMsiInstallProduct(szPath, TEXT(""));
} while ((uRet == ERROR_INSTALL_ALREADY_RUNNING) && (Sleep(100),TRUE));
pfnMsiSetInternalUI(oldUILevel, NULL);
}
if (bFreeLib)
FreeLibrary(hmod);
}
}
#endif // INSTALL_MSI
// now is the time on sprockets when we lock down the registry
STDAPI_(BOOL) ApplyRegistrySecurity()
{
BOOL fSuccess = FALSE; // assume failure
SHELL_USER_PERMISSION supEveryone;
SHELL_USER_PERMISSION supSystem;
SHELL_USER_PERMISSION supAdministrators;
PSHELL_USER_PERMISSION aPerms[3] = {&supEveryone, &supSystem, &supAdministrators};
// we want the "Everyone" to have read access
supEveryone.susID = susEveryone;
supEveryone.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
supEveryone.dwAccessMask = KEY_READ;
supEveryone.fInherit = TRUE;
supEveryone.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
supEveryone.dwInheritAccessMask = GENERIC_READ;
// we want the "SYSTEM" to have full control
supSystem.susID = susSystem;
supSystem.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
supSystem.dwAccessMask = KEY_ALL_ACCESS;
supSystem.fInherit = TRUE;
supSystem.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
supSystem.dwInheritAccessMask = GENERIC_ALL;
// we want the "Administrators" to have full control
supAdministrators.susID = susAdministrators;
supAdministrators.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
supAdministrators.dwAccessMask = KEY_ALL_ACCESS;
supAdministrators.fInherit = TRUE;
supAdministrators.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
supAdministrators.dwInheritAccessMask = GENERIC_ALL;
SECURITY_DESCRIPTOR* psd = GetShellSecurityDescriptor(aPerms, ARRAYSIZE(aPerms));
if (psd)
{
HKEY hkLMBitBucket;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket"), 0, KEY_ALL_ACCESS, &hkLMBitBucket) == ERROR_SUCCESS)
{
if (RegSetKeySecurity(hkLMBitBucket, DACL_SECURITY_INFORMATION, psd) == ERROR_SUCCESS)
{
// victory is mine!
fSuccess = TRUE;
}
RegCloseKey(hkLMBitBucket);
}
LocalFree(psd);
}
return fSuccess;
}
CComModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
// nothing in here, use clsobj.c class table instead
END_OBJECT_MAP()
// ATL DllMain, needed to support our ATL classes that depend on _Module
// REVIEW: confirm that _Module is really needed
STDAPI_(BOOL) ATL_DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
_Module.Init(ObjectMap, hInstance);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
_Module.Term();
}
return TRUE; // ok
}
#define FUSION_FLAG_SYSTEM32 0
#define FUSION_FLAG_WINDOWS 1
#define FUSION_FLAG_PROGRAMFILES 2
#define FUSION_ENTRY(x, z) {L#x, NULL, z},
#define FUSION_ENTRY_DEST(x, y, z) {L#x, L#y, z},
struct
{
PWSTR pszAppName;
PWSTR pszDestination;
DWORD dwFlags;
}
g_FusionizedApps[] =
{
FUSION_ENTRY(ncpa.cpl, FUSION_FLAG_SYSTEM32)
FUSION_ENTRY(nwc.cpl, FUSION_FLAG_SYSTEM32)
FUSION_ENTRY(sapi.cpl, FUSION_FLAG_SYSTEM32)
FUSION_ENTRY(wuaucpl.cpl, FUSION_FLAG_SYSTEM32)
FUSION_ENTRY(cdplayer.exe, FUSION_FLAG_SYSTEM32)
FUSION_ENTRY_DEST(msimn.exe, "OutLook Express", FUSION_FLAG_PROGRAMFILES)
// WARNING: Do NOT add iexplorer or Explorer.exe! This will cause all apps to get fusioned; which is bad, mkay?
};
void DoFusion()
{
TCHAR szManifest[MAX_PATH];
// We will however generate a manifest for other apps
for (int i = 0; i < ARRAYSIZE(g_FusionizedApps); i++)
{
switch(g_FusionizedApps[i].dwFlags)
{
case FUSION_FLAG_SYSTEM32:
GetSystemDirectory(szManifest, ARRAYSIZE(szManifest));
break;
case FUSION_FLAG_WINDOWS:
GetWindowsDirectory(szManifest, ARRAYSIZE(szManifest));
break;
case FUSION_FLAG_PROGRAMFILES:
SHGetSpecialFolderPath(NULL, szManifest, CSIDL_PROGRAM_FILES, FALSE);
PathCombine(szManifest, szManifest, g_FusionizedApps[i].pszDestination);
break;
}
PathCombine(szManifest, szManifest, g_FusionizedApps[i].pszAppName);
StrCatBuff(szManifest, TEXT(".manifest"), ARRAYSIZE(szManifest));
SHSquirtManifest(HINST_THISDLL, IDS_EXPLORERMANIFEST, szManifest);
}
SHGetManifest(szManifest, ARRAYSIZE(szManifest));
SHSquirtManifest(HINST_THISDLL, IDS_EXPLORERMANIFEST, szManifest);
}
Reference in a new issue Copy permalink