1215 lines
39 KiB
C++
1215 lines
39 KiB
C++
#include "pch.hxx"
|
|
#include <regutil.h>
|
|
#include "msident.h"
|
|
#include <initguid.h>
|
|
#include <ourguid.h>
|
|
#include "strings.h"
|
|
#include "util.h"
|
|
#include "migerror.h"
|
|
|
|
// Sections of INF corresponding to versions
|
|
const LPCTSTR c_szSects[] = { c_szVERnone, c_szVER1_0, c_szVER1_1, c_szVER4_0, c_szVER5B1, c_szVER5_0, c_szVERnone, c_szVERnone, c_szVERnone };
|
|
|
|
void SetUrlDllDefault(BOOL fMailTo);
|
|
|
|
/****************************************************************************
|
|
|
|
NAME: NTReboot
|
|
|
|
****************************************************************************/
|
|
BOOL NTReboot()
|
|
{
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tkp;
|
|
|
|
// get a token from this process
|
|
if (OpenProcessToken(GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
|
|
{
|
|
// get the LUID for the shutdown privilege
|
|
LookupPrivilegeValue( NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid );
|
|
|
|
tkp.PrivilegeCount = 1;
|
|
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
//get the shutdown privilege for this proces
|
|
if (AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0))
|
|
|
|
// shutdown the system and force all applications to close
|
|
if (!ExitWindowsEx( EWX_REBOOT, 0 ) )
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
NAME: Reboot
|
|
|
|
****************************************************************************/
|
|
// Based on Advpack code...
|
|
void Reboot(BOOL bAsk)
|
|
{
|
|
UINT id;
|
|
|
|
id = bAsk ? MsgBox(NULL, IDS_RESTARTYESNO, MB_ICONINFORMATION, MB_YESNO) : IDYES;
|
|
|
|
if (IDYES == id)
|
|
if (VER_PLATFORM_WIN32_WINDOWS == si.osv.dwPlatformId)
|
|
// By default (all platforms), we assume powerdown is possible
|
|
ExitWindowsEx( EWX_REBOOT, 0 );
|
|
else
|
|
NTReboot();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
NAME: OKDespiteDependencies
|
|
|
|
SYNOPSIS: Make sure the user is aware that uninstalling us will break
|
|
apps that use us
|
|
|
|
****************************************************************************/
|
|
BOOL OKDespiteDependencies(void)
|
|
{
|
|
WORD wVerGold[4] = {4,72,2106,0};
|
|
WORD wVerSP1[4] = {4,72,3110,0};
|
|
BOOL fGold;
|
|
BOOL fSP1;
|
|
BOOL fOK = TRUE;
|
|
WORD wVerPrev[4];
|
|
WORD wVer[4];
|
|
TCHAR szExe[MAX_PATH];
|
|
HKEY hkey;
|
|
DWORD cb, dwDisable;
|
|
|
|
int iRet;
|
|
|
|
LOG("Checking Product dependencies...");
|
|
|
|
switch (si.saApp)
|
|
{
|
|
case APP_WAB:
|
|
break;
|
|
|
|
case APP_OE:
|
|
if (si.fPrompt)
|
|
{
|
|
DWORD dwVerInfoSize, dwVerHnd;
|
|
LPSTR lpInfo, lpVersion;
|
|
LPWORD lpwTrans;
|
|
UINT uLen;
|
|
TCHAR szGet[MAX_PATH];
|
|
|
|
// What version would we return to?
|
|
GetVers(NULL, wVerPrev);
|
|
|
|
// Is that good enough for SP1?
|
|
if (fSP1 = GoodEnough(wVerPrev, wVerSP1))
|
|
{
|
|
// Yep, must be good enough for 4.01 too
|
|
fGold = TRUE;
|
|
}
|
|
else
|
|
fGold = GoodEnough(wVerPrev, wVerGold);
|
|
|
|
// Is OL Installed?
|
|
if (GetExePath(c_szOutlookExe, szExe, ARRAYSIZE(szExe), FALSE))
|
|
{
|
|
// Reg entry exists, does the EXE it points to?
|
|
if(0xFFFFFFFF != GetFileAttributes(szExe))
|
|
{
|
|
LOG("Found Outlook...");
|
|
|
|
// Figure out the version
|
|
if (dwVerInfoSize = GetFileVersionInfoSize(szExe, &dwVerHnd))
|
|
{
|
|
if (lpInfo = (LPSTR)GlobalAlloc(GPTR, dwVerInfoSize))
|
|
{
|
|
if (GetFileVersionInfo(szExe, 0, dwVerInfoSize, lpInfo))
|
|
{
|
|
if (VerQueryValue(lpInfo, "\\VarFileInfo\\Translation", (LPVOID *)&lpwTrans, &uLen) &&
|
|
uLen >= (2 * sizeof(WORD)))
|
|
{
|
|
// set up buffer for calls to VerQueryValue()
|
|
wnsprintf(szGet, ARRAYSIZE(szGet), "\\StringFileInfo\\%04X%04X\\FileVersion", lpwTrans[0], lpwTrans[1]);
|
|
if (VerQueryValue(lpInfo, szGet, (LPVOID *)&lpVersion, &uLen) && uLen)
|
|
{
|
|
ConvertStrToVer(lpVersion, wVer);
|
|
|
|
// Check for OL98
|
|
if (8 == wVer[0] && 5 == wVer[1])
|
|
{
|
|
LOG2("98");
|
|
fOK = fGold;
|
|
}
|
|
else if (wVer[0] >= 9)
|
|
{
|
|
LOG2("2000+");
|
|
fOK = fSP1;
|
|
|
|
// Allow for future OLs to disable this check
|
|
if (!fOK && ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, si.pszVerInfo, 0, KEY_QUERY_VALUE, &hkey))
|
|
{
|
|
dwDisable = 0;
|
|
cb = sizeof(dwDisable);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, c_szDisableOLCheck, 0, NULL, (LPBYTE)&dwDisable, &cb))
|
|
{
|
|
if (dwDisable > 0)
|
|
{
|
|
LOG2("...Disabled via reg");
|
|
fOK = TRUE;
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG2("97");
|
|
}
|
|
|
|
if (fOK)
|
|
{
|
|
LOG2("...OK to uninstall");
|
|
}
|
|
else
|
|
{
|
|
LOG2("...Not safe to uninstall");
|
|
|
|
// Potentially have a problem - ask user
|
|
iRet = MsgBox(NULL, IDS_WARN_OL, MB_ICONEXCLAMATION, MB_YESNO | MB_DEFBUTTON2);
|
|
if (IDYES == iRet)
|
|
fOK = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
GlobalFree((HGLOBAL)lpInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Is MS Phone Installed?
|
|
if (fOK && GetExePath(c_szPhoneExe, szExe, ARRAYSIZE(szExe), FALSE))
|
|
{
|
|
// Reg entry exists, does the EXE it points to?
|
|
if(0xFFFFFFFF != GetFileAttributes(szExe))
|
|
{
|
|
LOG("Found MSPhone...");
|
|
|
|
fOK = fSP1;
|
|
|
|
// Allow for future Phones to disable this check
|
|
if (!fOK && ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, si.pszVerInfo, 0, KEY_QUERY_VALUE, &hkey))
|
|
{
|
|
dwDisable = 0;
|
|
cb = sizeof(dwDisable);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, c_szDisablePhoneCheck, 0, NULL, (LPBYTE)&dwDisable, &cb))
|
|
{
|
|
if (dwDisable > 0)
|
|
{
|
|
LOG2("...Disabled via reg...");
|
|
fOK = TRUE;
|
|
}
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
if (fOK)
|
|
{
|
|
LOG2("OK to uninstall");
|
|
}
|
|
else
|
|
{
|
|
LOG2("Not safe to uninstall");
|
|
|
|
// Potentially have a problem - ask user
|
|
iRet = MsgBox(NULL, IDS_WARN_PHONE, MB_ICONEXCLAMATION, MB_YESNO | MB_DEFBUTTON2);
|
|
if (IDYES == iRet)
|
|
{
|
|
fOK = TRUE;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return fOK;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
There is a significant difference between the Win3.1 and Win32
|
|
behavior of RegDeleteKey when the key in question has subkeys.
|
|
The Win32 API does not allow you to delete a key with subkeys,
|
|
while the Win3.1 API deletes a key and all its subkeys.
|
|
|
|
This routine is a recursive worker that enumerates the subkeys
|
|
of a given key, applies itself to each one, then deletes itself.
|
|
|
|
It specifically does not attempt to deal rationally with the
|
|
case where the caller may not have access to some of the subkeys
|
|
of the key to be deleted. In this case, all the subkeys which
|
|
the caller can delete will be deleted, but the api will still
|
|
return ERROR_ACCESS_DENIED.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to an open registry key.
|
|
|
|
lpszSubKey - Supplies the name of a subkey which is to be deleted
|
|
along with all of its subkeys.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS - entire subtree successfully deleted.
|
|
|
|
ERROR_ACCESS_DENIED - given subkey could not be deleted.
|
|
|
|
--*/
|
|
|
|
LONG RegDeleteKeyRecursive(HKEY hKey, LPCTSTR lpszSubKey)
|
|
{
|
|
DWORD i;
|
|
HKEY Key;
|
|
LONG Status;
|
|
DWORD ClassLength=0;
|
|
DWORD SubKeys;
|
|
DWORD MaxSubKey;
|
|
DWORD MaxClass;
|
|
DWORD Values;
|
|
DWORD MaxValueName;
|
|
DWORD MaxValueData;
|
|
DWORD SecurityLength;
|
|
FILETIME LastWriteTime;
|
|
LPTSTR NameBuffer;
|
|
|
|
//
|
|
// First open the given key so we can enumerate its subkeys
|
|
//
|
|
Status = RegOpenKeyEx(hKey,
|
|
lpszSubKey,
|
|
0,
|
|
KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
|
|
&Key);
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// possibly we have delete access, but not enumerate/query.
|
|
// So go ahead and try the delete call, but don't worry about
|
|
// any subkeys. If we have any, the delete will fail anyway.
|
|
//
|
|
return(RegDeleteKey(hKey,lpszSubKey));
|
|
}
|
|
|
|
//
|
|
// Use RegQueryInfoKey to determine how big to allocate the buffer
|
|
// for the subkey names.
|
|
//
|
|
Status = RegQueryInfoKey(Key,
|
|
NULL,
|
|
&ClassLength,
|
|
0,
|
|
&SubKeys,
|
|
&MaxSubKey,
|
|
&MaxClass,
|
|
&Values,
|
|
&MaxValueName,
|
|
&MaxValueData,
|
|
&SecurityLength,
|
|
&LastWriteTime);
|
|
if ((Status != ERROR_SUCCESS) &&
|
|
(Status != ERROR_MORE_DATA) &&
|
|
(Status != ERROR_INSUFFICIENT_BUFFER))
|
|
{
|
|
RegCloseKey(Key);
|
|
return(Status);
|
|
}
|
|
|
|
if (!MemAlloc((void **)&NameBuffer, sizeof(TCHAR) * (MaxSubKey + 1)))
|
|
{
|
|
RegCloseKey(Key);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Enumerate subkeys and apply ourselves to each one.
|
|
//
|
|
i = 0;
|
|
do {
|
|
Status = RegEnumKey(Key,
|
|
i,
|
|
NameBuffer,
|
|
MaxSubKey+1);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = RegDeleteKeyRecursive(Key,NameBuffer);
|
|
}
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Failed to delete the key at the specified index. Increment
|
|
// the index and keep going. We could probably bail out here,
|
|
// since the api is going to fail, but we might as well keep
|
|
// going and delete everything we can.
|
|
//
|
|
++i;
|
|
}
|
|
} while ( (Status != ERROR_NO_MORE_ITEMS) &&
|
|
(i < SubKeys) );
|
|
|
|
MemFree(NameBuffer);
|
|
RegCloseKey(Key);
|
|
|
|
return(RegDeleteKey(hKey,lpszSubKey));
|
|
}
|
|
|
|
// v1 store struct
|
|
typedef struct tagCACHEFILEHDR
|
|
{
|
|
DWORD dwMagic;
|
|
DWORD ver;
|
|
DWORD cMsg;
|
|
DWORD cbValid;
|
|
DWORD dwFlags;
|
|
DWORD verBlob;
|
|
DWORD dwReserved[14];
|
|
} CACHEFILEHDR;
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: HandleInterimOE
|
|
|
|
SYNOPSIS: Tries to unmangle a machine that has had an
|
|
intermediate, non-gold version on it
|
|
|
|
********************************************************************/
|
|
void HandleInterimOE(SETUPVER sv, SETUPVER svReal)
|
|
{
|
|
switch(sv)
|
|
{
|
|
case VER_5_0_B1:
|
|
|
|
LPCTSTR pszRoot = NULL;
|
|
LPTSTR pszStore;
|
|
LPTSTR pszCmd;
|
|
LPCTSTR pszOption;
|
|
|
|
TCHAR szStorePath [MAX_PATH];
|
|
TCHAR szStoreExpanded[MAX_PATH];
|
|
TCHAR szExePath [MAX_PATH];
|
|
TCHAR szTemp [2*MAX_PATH + 20];
|
|
|
|
HKEY hkeySrc, hkeyT;
|
|
DWORD cb, dwType, dw;
|
|
|
|
STARTUPINFO sti;
|
|
PROCESS_INFORMATION pi;
|
|
|
|
// Find the OE5 Beta1 store root
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, c_szRegRoot, 0, KEY_QUERY_VALUE, &hkeySrc))
|
|
{
|
|
cb = sizeof(szStorePath);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkeySrc, c_szRegStoreRootDir, 0, &dwType, (LPBYTE)szStorePath, &cb))
|
|
{
|
|
ZeroMemory(szStoreExpanded, ARRAYSIZE(szStoreExpanded));
|
|
ExpandEnvironmentStrings(szStorePath, szStoreExpanded, ARRAYSIZE(szStoreExpanded));
|
|
|
|
switch (svReal)
|
|
{
|
|
case VER_1_0:
|
|
case VER_1_1:
|
|
BOOL fContinue;
|
|
BOOL fRet;
|
|
|
|
dwType = REG_SZ;
|
|
pszStore= szStoreExpanded;
|
|
pszRoot = c_szRegRoot_V1;
|
|
pszOption = c_szV1;
|
|
|
|
HANDLE hndl;
|
|
HANDLE hFile;
|
|
WIN32_FIND_DATA fd;
|
|
CACHEFILEHDR cfh;
|
|
|
|
// Downgrade .idx files
|
|
StrCpyN(szTemp, szStoreExpanded, ARRAYSIZE(szTemp));
|
|
cb = lstrlen(szTemp);
|
|
if ('\\' != *CharPrev(szTemp, szTemp+cb))
|
|
szTemp[cb++] = '\\';
|
|
StrCpyN(&szTemp[cb], c_szMailSlash, ARRAYSIZE(szTemp)-cb);
|
|
cb += 5; // lstrlen(c_szMailSlash)
|
|
StrCpyN(&szTemp[cb], c_szStarIDX, ARRAYSIZE(szTemp)-cb);
|
|
|
|
hndl = FindFirstFile(szTemp, &fd);
|
|
fContinue = (INVALID_HANDLE_VALUE != hndl);
|
|
if (fContinue)
|
|
{
|
|
while (fContinue)
|
|
{
|
|
// Skip directories
|
|
if (0 == (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
// Append the filename to the path
|
|
StrCpyN(&szTemp[cb], fd.cFileName, ARRAYSIZE(szTemp)-cb);
|
|
|
|
// Open the file
|
|
hFile = CreateFile(szTemp, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
fRet = ReadFile(hFile, &cfh, sizeof(CACHEFILEHDR), &dw, NULL);
|
|
|
|
Assert(dw == sizeof(CACHEFILEHDR));
|
|
|
|
if (fRet)
|
|
{
|
|
// Reset the version to be low, so v1 will attempt to repair it
|
|
cfh.verBlob = 1;
|
|
|
|
dw = SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
|
|
Assert(dw == 0);
|
|
|
|
fRet = WriteFile(hFile, &cfh, sizeof(CACHEFILEHDR), &dw, NULL);
|
|
Assert(fRet);
|
|
Assert(dw == sizeof(CACHEFILEHDR));
|
|
}
|
|
|
|
|
|
CloseHandle(hFile);
|
|
}
|
|
}
|
|
fContinue = FindNextFile(hndl, &fd);
|
|
}
|
|
FindClose(hndl);
|
|
}
|
|
break;
|
|
|
|
case VER_4_0:
|
|
pszStore = szStorePath;
|
|
pszRoot = c_szRegFlat;
|
|
pszOption = c_szV4;
|
|
break;
|
|
}
|
|
|
|
// If we are going to v1 or v4...
|
|
if (pszRoot)
|
|
{
|
|
dw= (DWORD)E_FAIL;
|
|
|
|
// Reverse migrate the store
|
|
|
|
// BUGBUG: 45426 - neilbren
|
|
// Should key off InstallRoot but can't seem to keep that setting around
|
|
|
|
// Try to find the path to oemig50.exe
|
|
if (GetModuleFileName(NULL, szTemp, ARRAYSIZE(szTemp)))
|
|
{
|
|
// Strip exe name and slash
|
|
PathRemoveFileSpec(szTemp);
|
|
|
|
// Add slash and exe name
|
|
wnsprintf(szExePath, ARRAYSIZE(szExePath), c_szPathFileFmt, szTemp, c_szMigrationExe);
|
|
|
|
pszCmd = szExePath;
|
|
}
|
|
// Otherwise, just try local directory
|
|
else
|
|
{
|
|
pszCmd = (LPTSTR)c_szMigrationExe;
|
|
}
|
|
|
|
// Form the command
|
|
wnsprintf(szTemp, ARRAYSIZE(szTemp), c_szMigFmt, pszCmd, pszOption, pszStore);
|
|
|
|
// Zero startup info
|
|
ZeroMemory(&sti, sizeof(STARTUPINFO));
|
|
sti.cb = sizeof(STARTUPINFO);
|
|
|
|
// run oemig50.exe
|
|
if (CreateProcess(NULL, szTemp, NULL, NULL, FALSE, 0, NULL, NULL, &sti, &pi))
|
|
{
|
|
// Wait for the process to finish
|
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
|
|
|
// Get the Exit Process Code
|
|
GetExitCodeProcess(pi.hProcess, &dw);
|
|
|
|
// Close the Thread
|
|
CloseHandle(pi.hThread);
|
|
|
|
// Close the Process
|
|
CloseHandle(pi.hProcess);
|
|
}
|
|
|
|
// Patch up the store root for version we are returning to
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, pszRoot, 0, KEY_SET_VALUE, &hkeyT))
|
|
{
|
|
RegSetValueEx(hkeyT, c_szRegStoreRootDir, 0, dwType, (LPBYTE)pszStore, (lstrlen(pszStore) + 1) * sizeof(TCHAR));
|
|
RegCloseKey(hkeyT);
|
|
}
|
|
}
|
|
}
|
|
RegCloseKey(hkeySrc);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: ConfigureOldVer
|
|
|
|
SYNOPSIS: Calls into INF to config older version
|
|
|
|
********************************************************************/
|
|
void ConfigureOldVer()
|
|
{
|
|
TCHAR szSectionName[128];
|
|
TCHAR szInfFile[MAX_PATH];
|
|
BOOL bUser = (TIME_USER == si.stTime);
|
|
SETUPVER sv, svInterim;
|
|
|
|
GetVerInfo(&sv, NULL);
|
|
|
|
// Patch up User or Machine
|
|
if (sv < VER_MAX)
|
|
{
|
|
wnsprintf(szInfFile, ARRAYSIZE(szInfFile), c_szFileEntryFmt, si.szInfDir, si.pszInfFile);
|
|
wnsprintf(szSectionName, ARRAYSIZE(szSectionName), bUser ? c_szUserRevertFmt : c_szMachineRevertFmt, c_szSects[sv]);
|
|
(*si.pfnRunSetup)(NULL, szInfFile, szSectionName, si.szInfDir, si.szAppName, NULL,
|
|
RSC_FLAG_INF | (bUser ? 0 : RSC_FLAG_NGCONV) | OE_QUIET, 0);
|
|
}
|
|
|
|
// Handle interim builds (user only)
|
|
if (bUser && InterimBuild(&svInterim))
|
|
{
|
|
switch(si.saApp)
|
|
{
|
|
case APP_OE:
|
|
HandleInterimOE(svInterim, sv);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SelectNewClient
|
|
|
|
********************************************************************/
|
|
void SelectNewClient(LPCTSTR pszClient)
|
|
{
|
|
BOOL fMail;
|
|
BOOL fNone = TRUE;
|
|
SETUPVER sv;
|
|
PFN_ISETDEFCLIENT pfn;
|
|
|
|
if (!lstrcmpi(pszClient, c_szNews))
|
|
{
|
|
pfn = ISetDefaultNewsHandler;
|
|
fMail = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pfn = ISetDefaultMailHandler;
|
|
fMail = TRUE;
|
|
}
|
|
|
|
// If we went IMN to 5.0, we will show up as NOT_HANDLED as our subkeys are gone by now
|
|
if ((HANDLED_CURR == DefaultClientSet(pszClient)) || (NOT_HANDLED == DefaultClientSet(pszClient)))
|
|
{
|
|
GetVerInfo(&sv, NULL);
|
|
switch (sv)
|
|
{
|
|
case VER_4_0:
|
|
// If prev ver was 4.0x, could have been Outlook News Reader
|
|
if (FValidClient(pszClient, c_szMOE))
|
|
{
|
|
(*pfn)(c_szMOE, 0);
|
|
fNone = FALSE;
|
|
}
|
|
else if (FValidClient(pszClient, c_szOutlook))
|
|
{
|
|
(*pfn)(c_szOutlook, 0);
|
|
fNone = FALSE;
|
|
}
|
|
break;
|
|
|
|
case VER_1_0:
|
|
// If prev ver was 1.0, IMN may or may not be around (cool, eh?)
|
|
if (FValidClient(pszClient, c_szIMN))
|
|
{
|
|
(*pfn)(c_szIMN, 0);
|
|
fNone = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fNone)
|
|
{
|
|
(*pfn)(_T(""), 0);
|
|
SetUrlDllDefault(fMail);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SelectNewClients
|
|
|
|
********************************************************************/
|
|
void SelectNewClients()
|
|
{
|
|
switch (si.saApp)
|
|
{
|
|
case APP_OE:
|
|
SelectNewClient(c_szNews);
|
|
SelectNewClient(c_szMail);
|
|
break;
|
|
|
|
case APP_WAB:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: UpdateVersionInfo
|
|
|
|
********************************************************************/
|
|
void UpdateVersionInfo()
|
|
{
|
|
HKEY hkeyT;
|
|
DWORD dwType, cb;
|
|
TCHAR szT[50]={0};
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, si.pszVerInfo, 0, KEY_QUERY_VALUE | KEY_SET_VALUE, &hkeyT))
|
|
{
|
|
cb = sizeof(szT);
|
|
if (CALLER_IE == si.caller)
|
|
{
|
|
RegQueryValueEx(hkeyT, c_szRegPrevVer, NULL, &dwType, (LPBYTE)szT, &cb);
|
|
RegSetValueEx(hkeyT, c_szRegCurrVer, 0, REG_SZ, (LPBYTE)szT, (lstrlen(szT) + 1) * sizeof(TCHAR));
|
|
}
|
|
else
|
|
// Special case OS installs that can uninstall OE
|
|
// As there is no rollback, current version should become nothing
|
|
RegSetValueEx(hkeyT, c_szRegCurrVer, 0, REG_SZ, (LPBYTE)c_szBLDnone, (lstrlen(c_szBLDnone) + 1) * sizeof(TCHAR));
|
|
RegSetValueEx(hkeyT, c_szRegPrevVer, 0, REG_SZ, (LPBYTE)c_szBLDnone, (lstrlen(c_szBLDnone) + 1) * sizeof(TCHAR));
|
|
RegCloseKey(hkeyT);
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: PreRollback
|
|
|
|
********************************************************************/
|
|
void PreRollback()
|
|
{
|
|
switch (si.saApp)
|
|
{
|
|
case APP_OE:
|
|
RegisterExes(FALSE);
|
|
break;
|
|
case APP_WAB:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: CreateWinLinks
|
|
|
|
SYNOPSIS: Generates special files in Windows Directory
|
|
|
|
********************************************************************/
|
|
void CreateWinLinks()
|
|
{
|
|
UINT uLen, cb;
|
|
TCHAR szPath[MAX_PATH];
|
|
TCHAR szDesc[CCHMAX_STRINGRES];
|
|
HANDLE hFile;
|
|
|
|
StrCpyN(szPath, si.szWinDir, ARRAYSIZE(szPath));
|
|
uLen = lstrlen(szPath);
|
|
|
|
// generate the link description
|
|
cb = LoadString(g_hInstance, IDS_OLD_MAIL, szDesc, ARRAYSIZE(szDesc));
|
|
|
|
// ---- MAIL
|
|
StrCpyN(&szPath[uLen], szDesc, ARRAYSIZE(szPath)-uLen);
|
|
cb += uLen;
|
|
StrCpyN(&szPath[cb], c_szMailGuid, ARRAYSIZE(szPath)-cb);
|
|
|
|
// create the link target
|
|
hFile = CreateFile(szPath, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hFile);
|
|
|
|
// ---- NEWS
|
|
cb = LoadString(g_hInstance, IDS_OLD_NEWS, szDesc, ARRAYSIZE(szDesc));
|
|
|
|
// generate the path to the link target
|
|
StrCpyN(&szPath[uLen], szDesc, ARRAYSIZE(szPath)-uLen);
|
|
cb += uLen;
|
|
StrCpyN(&szPath[cb], c_szNewsGuid, ARRAYSIZE(szPath)-cb);
|
|
|
|
// create the link target
|
|
hFile = CreateFile(szPath, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: PostRollback
|
|
|
|
********************************************************************/
|
|
void PostRollback()
|
|
{
|
|
SETUPVER sv;
|
|
GetVerInfo(&sv, NULL);
|
|
|
|
switch (si.saApp)
|
|
{
|
|
case APP_OE:
|
|
if (VER_1_0 == sv)
|
|
CreateWinLinks();
|
|
break;
|
|
case APP_WAB:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
/*******************************************************************
|
|
|
|
NAME: RemoveJIT
|
|
|
|
********************************************************************/
|
|
void RemoveJIT()
|
|
{
|
|
HKEY hkey;
|
|
DWORD cb, dw;
|
|
TCHAR szPath[MAX_PATH], szExpanded[MAX_PATH];
|
|
LPTSTR pszPath;
|
|
|
|
switch (si.saApp)
|
|
{
|
|
case APP_OE:
|
|
// WAB
|
|
wnsprintf(szPath, ARRAYSIZE(szPath), c_szPathFileFmt, c_szRegUninstall, c_szRegUninstallWAB);
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, szPath, 0, KEY_QUERY_VALUE, &hkey))
|
|
{
|
|
cb = sizeof(szPath);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, c_szQuietUninstall, 0, &dw, (LPBYTE)szPath, &cb))
|
|
{
|
|
STARTUPINFO sti;
|
|
PROCESS_INFORMATION pi;
|
|
|
|
if (REG_EXPAND_SZ == dw)
|
|
{
|
|
ZeroMemory(szExpanded, ARRAYSIZE(szExpanded));
|
|
ExpandEnvironmentStrings(szPath, szExpanded, ARRAYSIZE(szExpanded));
|
|
pszPath = szExpanded;
|
|
}
|
|
else
|
|
pszPath = szPath;
|
|
|
|
ZeroMemory(&sti, sizeof(STARTUPINFO));
|
|
sti.cb = sizeof(STARTUPINFO);
|
|
|
|
if (CreateProcess(NULL, pszPath, NULL, NULL, FALSE, 0, NULL, NULL, &sti, &pi))
|
|
{
|
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
|
GetExitCodeProcess(pi.hProcess, &dw);
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
break;
|
|
|
|
case APP_WAB:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: RequiredIE
|
|
|
|
SYNOPSIS: Requires IE5 for uninstall
|
|
|
|
********************************************************************/
|
|
BOOL RequiredIE()
|
|
{
|
|
HKEY hkey;
|
|
TCHAR szVer[VERLEN];
|
|
BOOL fOK = FALSE;
|
|
DWORD cb;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szIEKey, 0, KEY_READ, &hkey))
|
|
{
|
|
cb = ARRAYSIZE(szVer);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, c_szValueVersion, 0, NULL, (LPBYTE)szVer, &cb))
|
|
{
|
|
WORD wVer[4];
|
|
WORD wVerOE[4] = {5,0,0,0};
|
|
|
|
ConvertStrToVer(szVer, wVer);
|
|
|
|
if (!(fOK = GoodEnough(wVer, wVerOE)))
|
|
LOG("[WARNING]: Insufficient IE for uninstall");
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
return fOK;
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: UnInstallMachine
|
|
|
|
SYNOPSIS: Handles Application uninstallation
|
|
|
|
********************************************************************/
|
|
BOOL UnInstallMachine()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
TCHAR szArgs[2 * MAX_PATH];
|
|
TCHAR szInfFile[MAX_PATH];
|
|
UINT uID;
|
|
|
|
// Require at least IE 5 to uninstall
|
|
if (!RequiredIE() && (si.fPrompt ? (IDNO == MsgBox(NULL, IDS_WARN_OLDIE, MB_ICONEXCLAMATION, MB_YESNO | MB_DEFBUTTON2)) : TRUE))
|
|
{
|
|
LOG("[ERROR] Setup canceled");
|
|
return FALSE;
|
|
}
|
|
|
|
switch (si.saApp)
|
|
{
|
|
case APP_OE:
|
|
uID = IDS_UNINSTALL_OE;
|
|
break;
|
|
case APP_WAB:
|
|
uID = IDS_UNINSTALL_WAB;
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
// Make sure the user really wants to uninstall and there is nothing preventing it
|
|
if (IDNO == MsgBox(NULL, uID, MB_YESNO, MB_ICONEXCLAMATION ) ||
|
|
!OKDespiteDependencies())
|
|
{
|
|
LOG("[ERROR] Setup canceled");
|
|
return FALSE;
|
|
}
|
|
|
|
// We'll need to move files around and write to HKLM, so require admin privs
|
|
if (!IsNTAdmin())
|
|
{
|
|
LOG("[ERROR] User does not have administrative privileges")
|
|
MsgBox(NULL, IDS_NO_ADMIN_PRIVILEGES, MB_ICONSTOP, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
// Update version info in the reg
|
|
UpdateVersionInfo();
|
|
|
|
wnsprintf(szInfFile, ARRAYSIZE(szInfFile), c_szFileEntryFmt, si.szInfDir, si.pszInfFile);
|
|
if (CALLER_IE == si.caller)
|
|
{
|
|
// Do any housework before the uninstall
|
|
PreRollback();
|
|
|
|
// UnRegister OCXs (immediately)
|
|
(*si.pfnRunSetup)(NULL, szInfFile, c_szUnRegisterOCX, si.szInfDir, si.szAppName, NULL, RSC_FLAG_INF | RSC_FLAG_NGCONV | OE_QUIET, 0);
|
|
|
|
// Return files to original state
|
|
wnsprintf(szArgs, ARRAYSIZE(szArgs), c_szLaunchExFmt, szInfFile, c_szMachineInstallSectionEx, c_szEmpty, ALINF_ROLLBACK | ALINF_NGCONV | OE_QUIET);
|
|
hr = (*si.pfnLaunchEx)(NULL, NULL, szArgs, 0);
|
|
|
|
// Keys off current
|
|
PostRollback();
|
|
|
|
// Patch up Old version so that it runs (keys off current)
|
|
ConfigureOldVer();
|
|
}
|
|
else
|
|
{
|
|
// Set up the per user stub
|
|
(*si.pfnRunSetup)(NULL, szInfFile, c_szGenInstallSection, si.szInfDir, si.szAppName, NULL, RSC_FLAG_INF | RSC_FLAG_NGCONV | OE_QUIET, 0);
|
|
}
|
|
|
|
// Figure out who will be the default handlers now that app is gone
|
|
SelectNewClients();
|
|
|
|
// Uninstall JIT'd in items
|
|
// RemoveJIT();
|
|
|
|
// To simplify matters, we always want our stubs to run (not very ZAW like)
|
|
if (si.fPrompt)
|
|
Reboot(TRUE);
|
|
|
|
// Special case Memphis uninstall - no bits to return to, so just remove the icons now
|
|
if (CALLER_IE != si.caller)
|
|
{
|
|
UnInstallUser();
|
|
// Destory uninstalling user's installed info in case they install an older version without
|
|
// rebooting first
|
|
UpdateStubInfo(FALSE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: CleanupPerUser
|
|
|
|
SYNOPSIS: Handles per user cleanup
|
|
|
|
********************************************************************/
|
|
void CleanupPerUser()
|
|
{
|
|
switch (si.saApp)
|
|
{
|
|
case APP_WAB:
|
|
// Backwards migrate the connection settings
|
|
BackMigrateConnSettings();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: UnInstallUser
|
|
|
|
SYNOPSIS: Handles User uninstallation (icons etc)
|
|
|
|
********************************************************************/
|
|
void UnInstallUser()
|
|
{
|
|
// Remove desktop and quicklaunch links
|
|
HandleLinks(FALSE);
|
|
|
|
// Call into the correct per user stub
|
|
if (CALLER_IE == si.caller)
|
|
ConfigureOldVer();
|
|
|
|
// Handle any per user uninstall cleanup
|
|
CleanupPerUser();
|
|
|
|
if (IsXPSP1OrLater())
|
|
{
|
|
DeleteKeyRecursively(HKEY_CURRENT_USER, "Software\\Microsoft\\Active Setup\\Installed Components\\>{881dd1c5-3dcf-431b-b061-f3f88e8be88a}");
|
|
}
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: BackMigrateConnSettings
|
|
|
|
SYNOPSIS: OE4.1 or the versions before that did not have the
|
|
connection setting type InternetConnectionSetting. So while
|
|
downgrading from OE5 to OE4.1 or prior, we migrate
|
|
InternetConnectionSetting to LAN for every account in every identity
|
|
*******************************************************************/
|
|
|
|
void BackMigrateConnSettings()
|
|
{
|
|
HKEY hKeyAccounts = NULL;
|
|
DWORD dwAcctSubKeys = 0;
|
|
LONG retval;
|
|
DWORD index = 0;
|
|
LPTSTR lpszAccountName = NULL;
|
|
HKEY hKeyAccountName = NULL;
|
|
DWORD memsize = 0;
|
|
DWORD dwValue;
|
|
DWORD cbData = sizeof(DWORD);
|
|
DWORD cbMaxAcctSubKeyLen;
|
|
DWORD DataType;
|
|
DWORD dwConnSettingsMigrated = 0;
|
|
|
|
//This setting is in \\HKCU\Software\Microsoft\InternetAccountManager\Accounts
|
|
|
|
retval = RegOpenKey(HKEY_CURRENT_USER, c_szIAMAccounts, &hKeyAccounts);
|
|
if (ERROR_SUCCESS != retval)
|
|
goto exit;
|
|
|
|
retval = RegQueryValueEx(hKeyAccounts, c_szConnSettingsMigrated, NULL, &DataType,
|
|
(LPBYTE)&dwConnSettingsMigrated, &cbData);
|
|
|
|
if ((retval != ERROR_FILE_NOT_FOUND) && (retval != ERROR_SUCCESS || dwConnSettingsMigrated == 0))
|
|
goto exit;
|
|
|
|
retval = RegQueryInfoKey(hKeyAccounts, NULL, NULL, NULL, &dwAcctSubKeys,
|
|
&cbMaxAcctSubKeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
if (ERROR_SUCCESS != retval)
|
|
goto exit;
|
|
|
|
memsize = sizeof(TCHAR) * cbMaxAcctSubKeyLen;
|
|
|
|
if (!MemAlloc((LPVOID*)&lpszAccountName, memsize))
|
|
{
|
|
lpszAccountName = NULL;
|
|
goto exit;
|
|
}
|
|
|
|
ZeroMemory(lpszAccountName, memsize);
|
|
|
|
while (index < dwAcctSubKeys)
|
|
{
|
|
retval = RegEnumKey(hKeyAccounts, index, lpszAccountName, memsize);
|
|
|
|
index++;
|
|
|
|
if (ERROR_SUCCESS != retval)
|
|
continue;
|
|
|
|
retval = RegOpenKey(hKeyAccounts, lpszAccountName, &hKeyAccountName);
|
|
if (ERROR_SUCCESS != retval)
|
|
continue;
|
|
|
|
cbData = sizeof(DWORD);
|
|
retval = RegQueryValueEx(hKeyAccountName, c_szConnectionType, NULL, &DataType, (LPBYTE)&dwValue, &cbData);
|
|
if (ERROR_SUCCESS != retval)
|
|
{
|
|
RegCloseKey(hKeyAccountName);
|
|
continue;
|
|
}
|
|
|
|
if (dwValue == CONNECTION_TYPE_INETSETTINGS)
|
|
{
|
|
dwValue = CONNECTION_TYPE_LAN;
|
|
retval = RegSetValueEx(hKeyAccountName, c_szConnectionType, 0, REG_DWORD, (const BYTE *)&dwValue,
|
|
sizeof(DWORD));
|
|
}
|
|
|
|
RegCloseKey(hKeyAccountName);
|
|
}
|
|
|
|
//Set this to zero so, when we upgrade when we do forward migration based on this key value
|
|
dwConnSettingsMigrated = 0;
|
|
RegSetValueEx(hKeyAccounts, c_szConnSettingsMigrated, 0, REG_DWORD, (const BYTE*)&dwConnSettingsMigrated,
|
|
sizeof(DWORD));
|
|
|
|
exit:
|
|
SafeMemFree(lpszAccountName);
|
|
|
|
if (hKeyAccounts)
|
|
RegCloseKey(hKeyAccounts);
|
|
}
|
|
|
|
const char c_szMailToHandler[] = "rundll32.exe url.dll,MailToProtocolHandler %l";
|
|
const char c_szNewsHandler[] = "rundll32.exe url.dll,NewsProtocolHandler %l";
|
|
|
|
const char c_szDefIcon[] = "DefaultIcon";
|
|
const char c_szURLProtocol[] = "URL Protocol";
|
|
const char c_szEditFlags[] = "EditFlags";
|
|
|
|
const char c_szSysDirExpand[] = "%SystemRoot%\\System32";
|
|
const char c_szUrlDllIconFmt[] = "%s\\url.dll,%d";
|
|
|
|
void SetUrlDllDefault(BOOL fMailTo)
|
|
{
|
|
char sz[MAX_PATH], szIcon[MAX_PATH];
|
|
HKEY hkey, hkeyT;
|
|
DWORD dw, type;
|
|
int cch;
|
|
|
|
if (si.osv.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
StrCpyN(sz, c_szSysDirExpand, ARRAYSIZE(sz));
|
|
type = REG_EXPAND_SZ;
|
|
}
|
|
else
|
|
{
|
|
GetSystemDirectory(sz, ARRAYSIZE(sz));
|
|
type = REG_SZ;
|
|
}
|
|
wnsprintf(szIcon, ARRAYSIZE(szIcon), c_szUrlDllIconFmt, sz, fMailTo ? 2 : 1);
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CLASSES_ROOT, fMailTo ? c_szURLMailTo : c_szURLNews, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, &dw))
|
|
{
|
|
cch = LoadString(g_hInstance, fMailTo ? IDS_URLDLLMAILTONAME : IDS_URLDLLNEWSNAME, sz, ARRAYSIZE(sz)) + 1;
|
|
RegSetValueEx(hkey, NULL, 0, REG_SZ, (LPBYTE)sz, cch);
|
|
|
|
dw = 2;
|
|
RegSetValueEx(hkey, c_szEditFlags, 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw));
|
|
|
|
RegSetValueEx(hkey, c_szURLProtocol, 0, REG_SZ, (LPBYTE)c_szEmpty, 1);
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(hkey, c_szDefIcon, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkeyT, &dw))
|
|
{
|
|
RegSetValueEx(hkeyT, NULL, 0, type, (LPBYTE)szIcon, lstrlen(szIcon) + 1);
|
|
RegCloseKey(hkeyT);
|
|
}
|
|
|
|
// c_szRegOpen[1] to skip over slash needed elsewhere
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(hkey, &c_szRegOpen[1], 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkeyT, &dw))
|
|
{
|
|
if (fMailTo)
|
|
RegSetValueEx(hkeyT, NULL, 0, REG_SZ, (LPBYTE)c_szMailToHandler, sizeof(c_szMailToHandler));
|
|
else
|
|
RegSetValueEx(hkeyT, NULL, 0, REG_SZ, (LPBYTE)c_szNewsHandler, sizeof(c_szNewsHandler));
|
|
|
|
RegCloseKey(hkeyT);
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|