You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3192 lines
117 KiB
3192 lines
117 KiB
//+----------------------------------------------------------------------------
|
|
//
|
|
// File: install.cpp
|
|
//
|
|
// Module: CMSTP.EXE
|
|
//
|
|
// Synopsis: This source file contains the code for installing CM profiles.
|
|
//
|
|
// Copyright (c) 1997-1999 Microsoft Corporation
|
|
//
|
|
// Author: quintinb Created 07/14/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
#include "cmmaster.h"
|
|
#include "installerfuncs.h"
|
|
#include "winuserp.h"
|
|
#include <aclapi.h>
|
|
#include <advpub.h>
|
|
#include "tunl_str.h"
|
|
#include "cmsecure.h"
|
|
#include "gppswithalloc.cpp"
|
|
|
|
//
|
|
// This global var, contains the path to the source files to install such as the
|
|
// cmp, cms, and inf. (From the inf path passed in to InstallInf).
|
|
//
|
|
TCHAR g_szProfileSourceDir[MAX_PATH+1];
|
|
|
|
// This is really ugly, we need to consolidate our platform detection code between CM and
|
|
// the setup components.
|
|
BOOL IsNT()
|
|
{
|
|
CPlatform plat;
|
|
return plat.IsNT();
|
|
}
|
|
|
|
#define OS_NT (IsNT())
|
|
BOOL IsAtLeastNT5()
|
|
{
|
|
CPlatform plat;
|
|
return plat.IsAtLeastNT5();
|
|
}
|
|
|
|
#define OS_NT5 (IsAtLeastNT5())
|
|
#include "MemberOfGroup.cpp"
|
|
|
|
#include "cmexitwin.cpp"
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SetPermissionsOnWin2kExceptionUninstallRegKeys
|
|
//
|
|
// Synopsis: This function sets the permissions on the uninstall registry keys
|
|
// created by the Windows 2000 exception installer. The function
|
|
// gives Everyone read access, Local Administrators full control, and
|
|
// the CREATOR OWNER full control.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: HRESULT -- standard COM style error codes
|
|
//
|
|
// History: quintinb Created 10/04/01
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT SetPermissionsOnWin2kExceptionUninstallRegKeys()
|
|
{
|
|
DWORD dwRes;
|
|
HRESULT hr = S_OK;
|
|
LPWSTR pszCmExceptionUninstallKey = L"MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\CMEXCEPT";
|
|
|
|
PACL pNewAccessList = NULL;
|
|
PSID pEveryoneSid = NULL;
|
|
PSID pAdministratorsSid = NULL;
|
|
PSID pCreatorSid = NULL;
|
|
PSID pCurrentUserSid = NULL;
|
|
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
|
|
SID_IDENTIFIER_AUTHORITY WorldSidAuthority = SECURITY_WORLD_SID_AUTHORITY;
|
|
SID_IDENTIFIER_AUTHORITY CreatorSidAuthority = SECURITY_CREATOR_SID_AUTHORITY;
|
|
EXPLICIT_ACCESS_W AccessEntryArray[3] = {0};
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
|
|
HANDLE pTokenHandle = NULL;
|
|
PTOKEN_USER ptu = NULL;
|
|
DWORD dwNeeded = 0;
|
|
|
|
BOOL bRet;
|
|
|
|
//
|
|
// Link to Advapi32.dll so that we can load the security functions we need from it
|
|
//
|
|
|
|
typedef BOOL (WINAPI *pfnAllocateAndInitializeSidSpec)(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID);
|
|
typedef DWORD (WINAPI* pfnSetEntriesInAclWSpec)(ULONG, PEXPLICIT_ACCESS_W, PACL, PACL *);
|
|
typedef DWORD (WINAPI* pfnSetNamedSecurityInfoWSpec)(LPWSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID, PSID, PACL, PACL);
|
|
typedef PVOID (WINAPI* pfnFreeSidSpec)(PSID);
|
|
typedef VOID (WINAPI* pfnBuildTrusteeWithSidWSpec)(PTRUSTEE_W, PSID);
|
|
typedef BOOL (WINAPI* pfnOpenProcessTokenSpec)(HANDLE, DWORD, PHANDLE);
|
|
typedef BOOL (WINAPI* pfnGetTokenInformationSpec)(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD, PDWORD);
|
|
|
|
pfnAllocateAndInitializeSidSpec pfnAllocateAndInitializeSid = NULL;
|
|
pfnSetEntriesInAclWSpec pfnSetEntriesInAclW = NULL;
|
|
pfnSetNamedSecurityInfoWSpec pfnSetNamedSecurityInfoW = NULL;
|
|
pfnFreeSidSpec pfnFreeSid = NULL;
|
|
pfnBuildTrusteeWithSidWSpec pfnBuildTrusteeWithSidW = NULL;
|
|
pfnOpenProcessTokenSpec pfnOpenProcessToken = NULL;
|
|
pfnGetTokenInformationSpec pfnGetTokenInformation = NULL;
|
|
|
|
HMODULE hAdvapi32 = LoadLibrary(TEXT("advapi32.dll"));
|
|
|
|
if (hAdvapi32)
|
|
{
|
|
pfnAllocateAndInitializeSid = (pfnAllocateAndInitializeSidSpec)GetProcAddress(hAdvapi32, "AllocateAndInitializeSid");
|
|
pfnSetEntriesInAclW = (pfnSetEntriesInAclWSpec)GetProcAddress(hAdvapi32, "SetEntriesInAclW");
|
|
pfnSetNamedSecurityInfoW = (pfnSetNamedSecurityInfoWSpec)GetProcAddress(hAdvapi32, "SetNamedSecurityInfoW");
|
|
pfnFreeSid = (pfnFreeSidSpec)GetProcAddress(hAdvapi32, "FreeSid");
|
|
pfnBuildTrusteeWithSidW = (pfnBuildTrusteeWithSidWSpec)GetProcAddress(hAdvapi32, "BuildTrusteeWithSidW");
|
|
pfnOpenProcessToken = (pfnOpenProcessTokenSpec)GetProcAddress(hAdvapi32, "OpenProcessToken");
|
|
pfnGetTokenInformation = (pfnGetTokenInformationSpec)GetProcAddress(hAdvapi32, "GetTokenInformation");
|
|
|
|
if (0 == (pfnOpenProcessToken && pfnGetTokenInformation &&
|
|
pfnAllocateAndInitializeSid && pfnSetEntriesInAclW &&
|
|
pfnSetNamedSecurityInfoW && pfnFreeSid &&
|
|
pfnBuildTrusteeWithSidW))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND);
|
|
goto exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the SID for Everyone
|
|
//
|
|
bRet = pfnAllocateAndInitializeSid (&WorldSidAuthority, 1, SECURITY_WORLD_RID,
|
|
0, 0, 0, 0, 0, 0, 0, &pEveryoneSid);
|
|
|
|
if (!bRet || (NULL == pEveryoneSid))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the SID for the Local Administrators group
|
|
//
|
|
bRet = pfnAllocateAndInitializeSid (&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
|
|
0, 0, 0, 0, 0, 0, &pAdministratorsSid);
|
|
if (!bRet || (NULL == pAdministratorsSid))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the SID the for CREATOR OWNER
|
|
//
|
|
bRet = pfnAllocateAndInitializeSid (&CreatorSidAuthority, 1, SECURITY_CREATOR_OWNER_RID,
|
|
0, 0, 0, 0, 0, 0, 0, &pCreatorSid);
|
|
|
|
if (!bRet || (NULL == pCreatorSid))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
|
|
bRet = pfnOpenProcessToken(GetCurrentProcess(), TOKEN_READ , &pTokenHandle);
|
|
if (bRet && pTokenHandle)
|
|
{
|
|
bRet = pfnGetTokenInformation(pTokenHandle, TokenUser, NULL, 0, &dwNeeded);
|
|
if (dwNeeded)
|
|
{
|
|
ptu = (PTOKEN_USER)CmMalloc(dwNeeded);
|
|
if (ptu)
|
|
{
|
|
DWORD dwNeededAgain = 0;
|
|
bRet = pfnGetTokenInformation(pTokenHandle, TokenUser, ptu, dwNeeded, &dwNeededAgain);
|
|
if (bRet)
|
|
{
|
|
pCurrentUserSid = ptu->User.Sid;
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseHandle(pTokenHandle);
|
|
pTokenHandle = NULL;
|
|
}
|
|
|
|
if (!bRet || (NULL == pCurrentUserSid))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
|
|
//
|
|
// Give Everyone generic read access
|
|
//
|
|
pfnBuildTrusteeWithSidW(&(AccessEntryArray[0].Trustee), pEveryoneSid);
|
|
AccessEntryArray[0].grfInheritance = NO_INHERITANCE;
|
|
AccessEntryArray[0].grfAccessMode = GRANT_ACCESS;
|
|
AccessEntryArray[0].grfAccessPermissions = GENERIC_READ;
|
|
|
|
//
|
|
// Give the local Administrators group full control
|
|
//
|
|
pfnBuildTrusteeWithSidW(&(AccessEntryArray[1].Trustee), pAdministratorsSid);
|
|
AccessEntryArray[1].grfInheritance = NO_INHERITANCE;
|
|
AccessEntryArray[1].grfAccessMode = GRANT_ACCESS;
|
|
AccessEntryArray[1].grfAccessPermissions = (STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL);
|
|
|
|
//
|
|
// Give current user full control
|
|
//
|
|
pfnBuildTrusteeWithSidW(&(AccessEntryArray[2].Trustee), pCurrentUserSid);
|
|
AccessEntryArray[2].grfInheritance = NO_INHERITANCE;
|
|
AccessEntryArray[2].grfAccessMode = GRANT_ACCESS;
|
|
AccessEntryArray[2].grfAccessPermissions = (STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL);
|
|
|
|
|
|
//
|
|
// Build an access list from the access list entry.
|
|
//
|
|
|
|
dwRes = pfnSetEntriesInAclW(3, &(AccessEntryArray[0]), NULL, &pNewAccessList);
|
|
|
|
if (ERROR_SUCCESS == dwRes)
|
|
{
|
|
//
|
|
// Set the access-control information in the object's DACL. Note that setting PROTECTED_DACL_SECURITY_INFORMATION
|
|
// turns off the inherited permissions.
|
|
//
|
|
dwRes = pfnSetNamedSecurityInfoW(pszCmExceptionUninstallKey, // name of the object
|
|
SE_REGISTRY_KEY, // type of object
|
|
(DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION), // type of information to set
|
|
NULL, // pointer to the new owner SID
|
|
NULL, // pointer to the new primary group SID
|
|
pNewAccessList, // pointer to new DACL
|
|
NULL); // pointer to new SACL
|
|
|
|
}
|
|
|
|
hr = HRESULT_FROM_WIN32(dwRes);
|
|
|
|
exit:
|
|
if (ptu)
|
|
{
|
|
CmFree(ptu);
|
|
ptu = NULL;
|
|
}
|
|
|
|
if (pEveryoneSid && pfnFreeSid)
|
|
{
|
|
pfnFreeSid(pEveryoneSid);
|
|
}
|
|
|
|
if (pAdministratorsSid && pfnFreeSid)
|
|
{
|
|
pfnFreeSid(pAdministratorsSid);
|
|
}
|
|
|
|
if (pCreatorSid && pfnFreeSid)
|
|
{
|
|
pfnFreeSid(pCreatorSid);
|
|
}
|
|
|
|
if (pNewAccessList)
|
|
{
|
|
LocalFree(pNewAccessList);
|
|
}
|
|
|
|
if (pSecurityDescriptor)
|
|
{
|
|
LocalFree(pSecurityDescriptor);
|
|
}
|
|
|
|
if (hAdvapi32)
|
|
{
|
|
FreeLibrary(hAdvapi32);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CheckIeDllRequirements
|
|
//
|
|
// Synopsis: This function checks to see if the browser agnostic dlls are of
|
|
// a sufficient version for CM to work, or if we should copy the
|
|
// dlls we carry in the package with us.
|
|
//
|
|
// Arguments: CPlatform* pPlat - a CPlatform object
|
|
//
|
|
// Returns: BOOL - returns TRUE if all browser files meet the requirements, FALSE
|
|
// if any one of the files fails to meet what CM needs.
|
|
//
|
|
// History: quintinb Created Header 5/24/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CheckIeDllRequirements(CPlatform* pPlat)
|
|
{
|
|
TCHAR szSysDir[MAX_PATH+1];
|
|
TCHAR szDllToCheck[MAX_PATH+1];
|
|
if(GetSystemDirectory(szSysDir, MAX_PATH))
|
|
{
|
|
if (pPlat->IsWin9x())
|
|
{
|
|
//
|
|
// Need Advapi32.dll to be version 4.70.0.1215 or greater.
|
|
//
|
|
const DWORD c_dwRequiredAdvapi32Version = (4 << c_iShiftAmount) + 70;
|
|
const DWORD c_dwRequiredAdvapi32BuildNumber = 1215;
|
|
|
|
MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"),
|
|
szSysDir, TEXT("\\advapi32.dll")));
|
|
|
|
CVersion AdvApi32Version(szDllToCheck);
|
|
|
|
if ((c_dwRequiredAdvapi32Version > AdvApi32Version.GetVersionNumber()) ||
|
|
((c_dwRequiredAdvapi32Version == AdvApi32Version.GetVersionNumber()) &&
|
|
(c_dwRequiredAdvapi32BuildNumber > AdvApi32Version.GetBuildAndQfeNumber())))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Need comctl32.dll to be version 4.70.0.1146 or greater.
|
|
//
|
|
const DWORD c_dwRequiredComctl32Version = (4 << c_iShiftAmount) + 70;
|
|
const DWORD c_dwRequiredComctl32BuildNumber = 1146;
|
|
|
|
MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"),
|
|
szSysDir, TEXT("\\comctl32.dll")));
|
|
|
|
CVersion Comctl32Version(szDllToCheck);
|
|
|
|
if ((c_dwRequiredComctl32Version > Comctl32Version.GetVersionNumber()) ||
|
|
((c_dwRequiredComctl32Version == Comctl32Version.GetVersionNumber()) &&
|
|
(c_dwRequiredComctl32BuildNumber > Comctl32Version.GetBuildAndQfeNumber())))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Need rnaph.dll to be version 4.40.311.0 or greater.
|
|
//
|
|
const DWORD c_dwRequiredRnaphVersion = (4 << c_iShiftAmount) + 40;
|
|
const DWORD c_dwRequiredRnaphBuildNumber = (311 << c_iShiftAmount);
|
|
|
|
MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"),
|
|
szSysDir, TEXT("\\rnaph.dll")));
|
|
|
|
CVersion RnaphVersion(szDllToCheck);
|
|
if ((c_dwRequiredRnaphVersion > RnaphVersion.GetVersionNumber()) ||
|
|
((c_dwRequiredRnaphVersion == RnaphVersion.GetVersionNumber()) &&
|
|
(c_dwRequiredRnaphBuildNumber > RnaphVersion.GetBuildAndQfeNumber())))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Need wininet.dll to be version 4.70.0.1301 or greater.
|
|
//
|
|
const DWORD c_dwRequiredWininetVersion = (4 << c_iShiftAmount) + 70;
|
|
const DWORD c_dwRequiredWininetBuildNumber = 1301;
|
|
|
|
MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"),
|
|
szSysDir, TEXT("\\wininet.dll")));
|
|
|
|
CVersion WininetVersion(szDllToCheck);
|
|
|
|
if ((c_dwRequiredWininetVersion > WininetVersion.GetVersionNumber()) ||
|
|
((c_dwRequiredWininetVersion == WininetVersion.GetVersionNumber()) &&
|
|
(c_dwRequiredWininetBuildNumber > WininetVersion.GetBuildAndQfeNumber())))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: WriteSingleUserProfileMappings
|
|
//
|
|
// Synopsis: This function write the single user mappings key.
|
|
//
|
|
// Arguments: HINSTANCE hInstance - an Instance handle to load string resources with
|
|
// LPCTSTR pszShortServiceName - short service name of the profile
|
|
// LPCTSTR pszServiceName - Long service name of the profile
|
|
//
|
|
// Returns: BOOL - TRUE if successful
|
|
//
|
|
// History: quintinb Created 5/23/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL WriteSingleUserProfileMappings(LPCTSTR pszInstallDir, LPCTSTR pszShortServiceName, LPCTSTR pszServiceName)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
TCHAR szCmpFile [MAX_PATH+1];
|
|
TCHAR szTemp [MAX_PATH+1];
|
|
TCHAR szUserProfilePath [MAX_PATH+1];
|
|
HKEY hKey = NULL;
|
|
|
|
//
|
|
// Construct the Cmp Path
|
|
//
|
|
MYVERIFY(CELEMS(szCmpFile) > (UINT)wsprintf(szCmpFile, TEXT("%s\\%s.cmp"),
|
|
pszInstallDir, pszShortServiceName));
|
|
|
|
//
|
|
// Figure out the User Profile directory
|
|
//
|
|
|
|
DWORD dwChars = ExpandEnvironmentStrings(TEXT("%AppData%"), szUserProfilePath, MAX_PATH);
|
|
|
|
if (dwChars && (MAX_PATH >= dwChars))
|
|
{
|
|
//
|
|
// We want to do a lstrcmpi but with only so many chars. Unfortunately this doesn't
|
|
// exist in Win32 so we will use lstrcpyn into a temp buffer and then use lstrcmpi.
|
|
//
|
|
lstrcpyn(szTemp, szCmpFile, lstrlen(szUserProfilePath) + 1);
|
|
|
|
if (0 == lstrcmpi(szTemp, szUserProfilePath))
|
|
{
|
|
lstrcpy(szTemp, szCmpFile + lstrlen(szUserProfilePath));
|
|
lstrcpy(szCmpFile, TEXT("%AppData%"));
|
|
lstrcat(szCmpFile, szTemp);
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Unable to build the Single User Mappings key value, exiting."));
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Okay, now we need to write out the single user mappings key
|
|
//
|
|
DWORD dwDisposition;
|
|
LONG lResult = RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegCmMappings, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL,
|
|
&hKey, &dwDisposition);
|
|
|
|
if (ERROR_SUCCESS == lResult)
|
|
{
|
|
DWORD dwType = REG_SZ;
|
|
DWORD dwSize = lstrlen(szCmpFile) + 1;
|
|
|
|
if (ERROR_SUCCESS != RegSetValueEx(hKey, pszServiceName, NULL, dwType,
|
|
(CONST BYTE *)szCmpFile, dwSize))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Unable to write the Single User Mappings key value, exiting."));
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Unable to expand the AppData String, exiting."));
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
|
|
if (hKey)
|
|
{
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: ProcessPreferencesUI
|
|
//
|
|
// Synopsis: This function processes messages for either of the two dialogs used
|
|
// to ask the user if they want a desktop shortcut. One dialog is for
|
|
// non-admins and only contains the shortcut question, the other dialog
|
|
// is for local admins and also contains whether the admin wants the
|
|
// profile installed for all users or just for single users.
|
|
//
|
|
//
|
|
// History: quintinb Created 2/19/98
|
|
// quintinb Renamed from ProcessAdminUI to ProcessPreferencesUI and
|
|
// added new functionality 6/9/8
|
|
// quintinb removed mention of Start Menu Shortcut 2/17/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL APIENTRY ProcessPreferencesUI(
|
|
HWND hDlg,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
int iUiChoices;
|
|
HKEY hKey;
|
|
DWORD dwSize;
|
|
DWORD dwTemp;
|
|
DWORD dwType;
|
|
InitDialogStruct* pDialogArgs = NULL;
|
|
|
|
switch (message)
|
|
{
|
|
|
|
case WM_INITDIALOG:
|
|
//
|
|
// Look up the preferences for Desktop Shortcuts/Start Menu Links
|
|
// in the registry and set them accordingly.
|
|
//
|
|
pDialogArgs = (InitDialogStruct*)lParam;
|
|
|
|
if (pDialogArgs->bNoDesktopIcon)
|
|
{
|
|
MYVERIFY(0 != CheckDlgButton(hDlg, IDC_DESKTOP, FALSE));
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegStickyUiDefault,
|
|
0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ, NULL, &hKey, &dwTemp))
|
|
{
|
|
//
|
|
// The default of whether a desktop shortcut should be created is stored in the
|
|
// registry. Get this value to populate the UI. (default is off)
|
|
//
|
|
dwType = REG_DWORD;
|
|
dwSize = sizeof(DWORD);
|
|
dwTemp = 0;
|
|
RegQueryValueEx(hKey, c_pszRegDesktopShortCut, NULL, &dwType, (LPBYTE)&dwTemp,
|
|
&dwSize); //lint !e534
|
|
MYVERIFY(0 != CheckDlgButton(hDlg, IDC_DESKTOP, dwTemp));
|
|
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the Window Text to the Profile Name
|
|
//
|
|
MYVERIFY(FALSE != SetWindowText(hDlg, pDialogArgs->pszTitle));
|
|
|
|
if (!(pDialogArgs->bSingleUser))
|
|
{
|
|
CheckDlgButton(hDlg, IDC_ALLUSERS, TRUE); //lint !e534 this will fail if using the nochoice UI
|
|
|
|
//
|
|
// Set focus to the All user radio button
|
|
//
|
|
HWND hControl = GetDlgItem(hDlg, IDC_ALLUSERS);
|
|
|
|
if (hControl)
|
|
{
|
|
SetFocus(hControl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CheckDlgButton(hDlg, IDC_YOURSELF, TRUE); //lint !e534 this will fail if using the nochoice UI
|
|
|
|
//
|
|
// Set focus to the Single user radio button
|
|
//
|
|
HWND hControl = GetDlgItem(hDlg, IDC_YOURSELF);
|
|
|
|
if (hControl)
|
|
{
|
|
SetFocus(hControl);
|
|
}
|
|
}
|
|
|
|
//
|
|
// We return FALSE here but the focus is correctly set.
|
|
//
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
//
|
|
// Build the return value
|
|
//
|
|
if (IsDlgButtonChecked(hDlg, IDC_ALLUSERS) == BST_CHECKED)
|
|
{
|
|
iUiChoices = ALLUSERS;
|
|
}
|
|
else
|
|
{
|
|
iUiChoices = 0;
|
|
}
|
|
|
|
if (IsDlgButtonChecked(hDlg, IDC_DESKTOP))
|
|
{
|
|
iUiChoices |= CREATEDESKTOPICON;
|
|
}
|
|
|
|
//
|
|
// Make sure to save the users preferences for Desktop Icons
|
|
// and Start Menu Links.
|
|
//
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegStickyUiDefault,
|
|
0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwTemp))
|
|
{
|
|
//
|
|
// Store the current state of whether we should create a desktop shortcut
|
|
//
|
|
dwTemp = IsDlgButtonChecked(hDlg, IDC_DESKTOP);
|
|
MYVERIFY(ERROR_SUCCESS == RegSetValueEx(hKey, c_pszRegDesktopShortCut, 0,
|
|
REG_DWORD, (LPBYTE)&dwTemp, sizeof(DWORD)));
|
|
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
|
|
MYVERIFY(FALSE != EndDialog(hDlg, iUiChoices));
|
|
|
|
return (TRUE);
|
|
|
|
case IDCANCEL:
|
|
MYVERIFY(FALSE != EndDialog(hDlg, -1));
|
|
return TRUE;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
MYVERIFY(FALSE != EndDialog(hDlg, -1));
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: InstallCm
|
|
//
|
|
// Synopsis: This function calls LaunchInfSection on the appropriate
|
|
// install section to install Connection Manager. It also installs
|
|
// the browser files as appropriate.
|
|
//
|
|
// Arguments: HINSTANCE hInstance - Instance handle for strings
|
|
// LPCTSTR szInfPath - Full path to the inf
|
|
//
|
|
// Returns: HRESULT - standard com codes, could return ERROR_SUCCESS_REBOOT_REQUIRED
|
|
// so the caller must check for this case and ask for a reboot
|
|
// if required.
|
|
//
|
|
// History: quintinb Created 8/12/98
|
|
// quintinb Moved Browser file installation code here, since it is
|
|
// part of the installation of CM. 10-2-98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT InstallCm(HINSTANCE hInstance, LPCTSTR szInfPath)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
MYDBGASSERT((szInfPath) && (TEXT('\0') != szInfPath[0]));
|
|
|
|
//
|
|
// Load the Cmstp Title just in case we need to show error messages.
|
|
//
|
|
|
|
TCHAR szTitle[MAX_PATH+1] = {TEXT("")};
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CMSTP_TITLE, szTitle, MAX_PATH));
|
|
MYDBGASSERT(TEXT('\0') != szTitle[0]);
|
|
|
|
//
|
|
// Make sure that the Inf File exists
|
|
//
|
|
if (!FileExists(szInfPath))
|
|
{
|
|
CMTRACE1(TEXT("InstallCm -- Can't find %s, the inputted Inf file."), szInfPath);
|
|
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
CPlatform plat;
|
|
TCHAR szInstallSection[MAX_PATH+1] = {TEXT("")};
|
|
|
|
if (plat.IsNT())
|
|
{
|
|
MYVERIFY(CELEMS(szInstallSection) > (UINT)wsprintf(szInstallSection,
|
|
TEXT("DefaultInstall_NT")));
|
|
}
|
|
else
|
|
{
|
|
MYVERIFY(CELEMS(szInstallSection) > (UINT)wsprintf(szInstallSection,
|
|
TEXT("DefaultInstall")));
|
|
}
|
|
|
|
hr = LaunchInfSection(szInfPath, szInstallSection, szTitle, TRUE); // bQuiet = TRUE
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: InstallWhistlerCmOnWin2k
|
|
//
|
|
// Synopsis: This function uses the CM exception inf (cmexcept.inf) to install
|
|
// the Whistler CM binaries on Win2k.
|
|
//
|
|
// Arguments: LPCSTR pszSourceDir - source directory for cmexcept.inf and CM
|
|
// binaries, including the trailing slash.
|
|
//
|
|
// Returns: HRESULT - standard com codes, could return ERROR_SUCCESS_REBOOT_REQUIRED
|
|
// which means the caller needs to request a reboot.
|
|
//
|
|
// History: quintinb Created 02/09/2001
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT InstallWhistlerCmOnWin2k(LPCSTR pszSourceDir)
|
|
{
|
|
CPlatform cmplat;
|
|
HRESULT hr = E_UNEXPECTED;
|
|
LPSTR pszInfFile = NULL;
|
|
LPCSTR c_pszExceptionInf = "cmexcept.inf";
|
|
LPCSTR c_pszInstallSection = "DefaultInstall";
|
|
LPCSTR c_pszUnInstallSection = "DefaultUninstall_NoPrompt";
|
|
|
|
if (cmplat.IsNT5())
|
|
{
|
|
if (pszSourceDir && pszSourceDir[0])
|
|
{
|
|
DWORD dwSize = sizeof(CHAR)*(lstrlenA(pszSourceDir) + lstrlenA(c_pszExceptionInf) + 1);
|
|
|
|
pszInfFile = (LPSTR)CmMalloc(dwSize);
|
|
|
|
if (pszInfFile)
|
|
{
|
|
wsprintf(pszInfFile, "%s%s", pszSourceDir, c_pszExceptionInf);
|
|
|
|
if (FileExists(pszInfFile))
|
|
{
|
|
hr = CallLaunchInfSectionEx(pszInfFile, c_pszInstallSection, (ALINF_BKINSTALL | ALINF_QUIET));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
CMTRACE1(TEXT("InstallWhistlerCmOnWin2k -- CallLaunchInfSectionEx failed with hr=0x%x"), hr);
|
|
|
|
HRESULT hrTemp = CallLaunchInfSectionEx(pszInfFile, c_pszUnInstallSection, (ALINF_ROLLBKDOALL | ALINF_QUIET));
|
|
|
|
CMTRACE1(TEXT("InstallWhistlerCmOnWin2k -- Rolling back. CallLaunchInfSectionEx returned hr=0x%x"), hrTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INSTALL_PLATFORM_UNSUPPORTED); // kind of a double use of this error
|
|
}
|
|
|
|
CmFree(pszInfFile);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: UpdateCmpDataFromExistingProfile
|
|
//
|
|
// Synopsis: This function enumerates all of the keys in all of the sections
|
|
// of an existing cmp file and copies them to the cmp file to be
|
|
// installed. This function copies all of the data in the existing
|
|
// cmp unless that data already exists in the cmp to install. This
|
|
// allows Admins to preseed cmp files and have their settings override
|
|
// what the user currently has in their cmp.
|
|
//
|
|
// Arguments: LPCTSTR pszShortServiceName - Short Service name of the profile
|
|
// LPCTSTR szCurrentCmp - Full path to the currently installed cmp
|
|
// LPCTSTR szCmpToBeInstalled - Full path to the cmp to install
|
|
//
|
|
// Returns: BOOL - TRUE if the cmp is copied and updated properly
|
|
//
|
|
// History: quintinb Created 03/16/99
|
|
// quintinb rewrote for Whistler bug 18021 03/05/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL UpdateCmpDataFromExistingProfile(LPCTSTR pszShortServiceName, LPCTSTR pszCurrentCmp, LPCTSTR pszCmpToBeInstalled)
|
|
{
|
|
|
|
if((NULL == pszShortServiceName) && (TEXT('\0') == pszShortServiceName[0]) &&
|
|
(NULL == pszCurrentCmp) && (TEXT('\0') == pszCurrentCmp[0]) &&
|
|
(NULL == pszCmpToBeInstalled) && (TEXT('\0') == pszCmpToBeInstalled[0]))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Invalid parameter."));
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bReturn = FALSE;
|
|
BOOL bExitLoop = FALSE;
|
|
DWORD dwSize = MAX_PATH;
|
|
DWORD dwReturnedSize;
|
|
LPTSTR pszAllSections = NULL;
|
|
LPTSTR pszAllKeysInCurrentSection = NULL;
|
|
LPTSTR pszCurrentSection = NULL;
|
|
LPTSTR pszCurrentKey = NULL;
|
|
TCHAR szData[MAX_PATH+1];
|
|
|
|
//
|
|
// First lets get all of the sections from the existing cmp
|
|
//
|
|
pszAllSections = (TCHAR*)CmMalloc(dwSize*sizeof(TCHAR));
|
|
|
|
do
|
|
{
|
|
MYDBGASSERT(pszAllSections);
|
|
|
|
if (pszAllSections)
|
|
{
|
|
dwReturnedSize = GetPrivateProfileString(NULL, NULL, TEXT(""), pszAllSections, dwSize, pszCurrentCmp);
|
|
|
|
if (dwReturnedSize == (dwSize - 2))
|
|
{
|
|
//
|
|
// The buffer is too small, lets allocate a bigger one
|
|
//
|
|
dwSize = 2*dwSize;
|
|
if (dwSize > 1024*1024)
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Allocation above 1MB, bailing out."));
|
|
goto exit;
|
|
}
|
|
|
|
pszAllSections = (TCHAR*)CmRealloc(pszAllSections, dwSize*sizeof(TCHAR));
|
|
}
|
|
else if (0 == dwReturnedSize)
|
|
{
|
|
//
|
|
// We got an error, lets exit.
|
|
//
|
|
CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- GetPrivateProfileString returned failure."));
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
bExitLoop = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
} while (!bExitLoop);
|
|
|
|
//
|
|
// Okay, now we have all of the sections in the existing cmp file. Lets enumerate
|
|
// all of the keys in each section and see which ones need to be copied over.
|
|
//
|
|
|
|
pszCurrentSection = pszAllSections;
|
|
dwSize = MAX_PATH;
|
|
|
|
pszAllKeysInCurrentSection = (TCHAR*)CmMalloc(dwSize*sizeof(TCHAR));
|
|
|
|
while (TEXT('\0') != pszCurrentSection[0])
|
|
{
|
|
//
|
|
// Get all of the keys in the current section
|
|
//
|
|
bExitLoop = FALSE;
|
|
|
|
do
|
|
{
|
|
if (pszAllKeysInCurrentSection)
|
|
{
|
|
dwReturnedSize = GetPrivateProfileString(pszCurrentSection, NULL, TEXT(""), pszAllKeysInCurrentSection,
|
|
dwSize, pszCurrentCmp);
|
|
|
|
if (dwReturnedSize == (dwSize - 2))
|
|
{
|
|
//
|
|
// The buffer is too small, lets allocate a bigger one
|
|
//
|
|
dwSize = 2*dwSize;
|
|
if (dwSize > 1024*1024)
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Allocation above 1MB, bailing out."));
|
|
goto exit;
|
|
}
|
|
|
|
pszAllKeysInCurrentSection = (TCHAR*)CmRealloc(pszAllKeysInCurrentSection, dwSize*sizeof(TCHAR));
|
|
|
|
}
|
|
else if (0 == dwReturnedSize)
|
|
{
|
|
//
|
|
// We got an error, lets exit.
|
|
//
|
|
CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- GetPrivateProfileString returned failure."));
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
bExitLoop = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
} while (!bExitLoop);
|
|
|
|
//
|
|
// Now process all of the keys in the current section
|
|
//
|
|
pszCurrentKey = pszAllKeysInCurrentSection;
|
|
|
|
while (TEXT('\0') != pszCurrentKey[0])
|
|
{
|
|
//
|
|
// Try to get the value of the key from the new cmp. If it
|
|
// doesn't exist, then copy of the old cmp value. If it
|
|
// does exist keep the new cmp value and ignore the old one.
|
|
//
|
|
dwReturnedSize = GetPrivateProfileString(pszCurrentSection, pszCurrentKey, TEXT(""),
|
|
szData, MAX_PATH, pszCmpToBeInstalled);
|
|
if (0 == dwReturnedSize)
|
|
{
|
|
//
|
|
// Then we have a value in the old profile that we don't have in the new profile.
|
|
//
|
|
dwReturnedSize = GetPrivateProfileString(pszCurrentSection, pszCurrentKey, TEXT(""),
|
|
szData, MAX_PATH, pszCurrentCmp);
|
|
|
|
if (dwReturnedSize)
|
|
{
|
|
MYVERIFY(0 != WritePrivateProfileString(pszCurrentSection, pszCurrentKey, szData, pszCmpToBeInstalled));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Advance to the next key in pszAllKeysInCurrentSection
|
|
//
|
|
pszCurrentKey = pszCurrentKey + lstrlen(pszCurrentKey) + 1;
|
|
}
|
|
|
|
|
|
//
|
|
// Now advance to the next string in pszAllSections
|
|
//
|
|
pszCurrentSection = pszCurrentSection + lstrlen(pszCurrentSection) + 1;
|
|
}
|
|
|
|
|
|
//
|
|
// Flush the updated cmp
|
|
//
|
|
WritePrivateProfileString(NULL, NULL, NULL, pszCmpToBeInstalled); //lint !e534 this call will return 0
|
|
|
|
bReturn = TRUE;
|
|
|
|
exit:
|
|
|
|
CmFree(pszAllSections);
|
|
CmFree(pszAllKeysInCurrentSection);
|
|
|
|
return bReturn;
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: MigrateCmpData
|
|
//
|
|
// Synopsis: This function checks to see if a profile of the same long service
|
|
// and short service name is already installed. If it is, it migrates
|
|
// the existing cmp data to the cmp file that is to be installed.
|
|
// If the same piece of data exists in both profiles the data in the
|
|
// cmp to be installed wins (allows admins to pre-seed data in the
|
|
// cmp and override what users have picked).
|
|
//
|
|
// Arguments: HINSTANCE hInstance - Instance handle for string resources
|
|
// BOOL bInstallForAllUsers - whether this is an all users profile or not
|
|
// LPCTSTR pszServiceName - ServiceName of the current profile
|
|
// LPCTSTR pszShortServiceName - Short Service name of the current profile
|
|
// BOOL bSilent - whether messages to the user can be displayed or not
|
|
//
|
|
// Returns: int - returns -1 on error, otherwise TRUE or FALSE depending on if a same name
|
|
// profile was discovered
|
|
//
|
|
// History: quintinb Created 9/8/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL MigrateCmpData(HINSTANCE hInstance, BOOL bInstallForAllUsers, LPCTSTR pszServiceName,
|
|
LPCTSTR pszShortServiceName, BOOL bSilent)
|
|
{
|
|
//
|
|
// Check the parameters
|
|
//
|
|
if ((NULL == pszShortServiceName) || (TEXT('\0') == pszShortServiceName[0]) ||
|
|
(NULL == pszServiceName) || (TEXT('\0') == pszServiceName[0]))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("MigrateCmpData -- Invalid Parameter"));
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bReturn = TRUE;
|
|
DWORD dwSize = MAX_PATH;
|
|
HKEY hKey = NULL;
|
|
HKEY hBaseKey = bInstallForAllUsers ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
|
|
TCHAR szExistingCmp[MAX_PATH+1];
|
|
TCHAR szCmpToBeInstalled[MAX_PATH+1];
|
|
TCHAR szFmtString[2*MAX_PATH+1] = TEXT("");
|
|
TCHAR szMsg[2*MAX_PATH+1] = TEXT("");
|
|
|
|
//
|
|
// Read the mappings value
|
|
//
|
|
LONG lResult = RegOpenKeyEx(hBaseKey, c_pszRegCmMappings, 0, KEY_READ, &hKey);
|
|
|
|
if (ERROR_SUCCESS == lResult)
|
|
{
|
|
lResult = RegQueryValueEx(hKey, pszServiceName, NULL, NULL, (LPBYTE)szFmtString, &dwSize);
|
|
|
|
if (ERROR_SUCCESS == lResult)
|
|
{
|
|
//
|
|
// Expand the path in case it contains environment vars
|
|
//
|
|
if (0 == ExpandEnvironmentStrings(szFmtString, szExistingCmp, MAX_PATH))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("MigrateCmpData -- Unable to expand environment strings, not migrating cmp data."));
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If the file doesn't exist we have nothing to get cmp settings from ... thus
|
|
// lets just happily exit.
|
|
//
|
|
if (!FileExists(szExistingCmp))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Check to make sure that the Short Service Names agree for the two profiles
|
|
//
|
|
|
|
CFileNameParts ExistingCmpParts(szExistingCmp);
|
|
if (0 != lstrcmpi(pszShortServiceName, ExistingCmpParts.m_FileName))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_SAME_LS_DIFF_SS, szFmtString, CELEMS(szFmtString)));
|
|
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszShortServiceName,
|
|
ExistingCmpParts.m_FileName, pszServiceName));
|
|
|
|
MessageBox(NULL, szMsg, pszServiceName, MB_OK);
|
|
}
|
|
|
|
bReturn = -1;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the path of the cmp to install
|
|
//
|
|
MYVERIFY(CELEMS(szCmpToBeInstalled) > (UINT)wsprintf(szCmpToBeInstalled,
|
|
TEXT("%s%s.cmp"), g_szProfileSourceDir, pszShortServiceName));
|
|
|
|
if (FALSE == UpdateCmpDataFromExistingProfile(pszShortServiceName, szExistingCmp, szCmpToBeInstalled))
|
|
{
|
|
bReturn = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
|
|
if (hKey)
|
|
{
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: NeedCM10Upgrade
|
|
//
|
|
// Synopsis: This function detects and prepares data for the same name upgrade of a CM 1.0 profile.
|
|
// Thus if you pass in a short service name and a service name, the
|
|
// function detects if this profile is already installed for all users.
|
|
// If it is, then the function checks the profile version stamps in the cmp.
|
|
// If the current version isn't already newer and the user isn't a non-admin
|
|
// on NT5, then we prompt the user if they want to upgrade the current install.
|
|
// If they choose to upgrade then this function migrates the cmp data and
|
|
// finds the uninstall inf.
|
|
//
|
|
// Arguments: HINSTANCE hInstance - Instance handle for string resources
|
|
// LPCTSTR pszServiceName - ServiceName of the current profile
|
|
// LPCTSTR pszShortServiceName - Short Service name of the current profile
|
|
// LPTSTR pszOldInfPath - Out param for the old inf path, if the same name
|
|
// upgrade is needed.
|
|
//
|
|
// Returns: int - returns -1 on error, otherwise TRUE or FALSE depending on if a same name
|
|
// profile was discovered
|
|
//
|
|
// History: quintinb Created 9/8/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
int NeedCM10Upgrade(HINSTANCE hInstance, LPCTSTR pszServiceName, LPCTSTR pszShortServiceName,
|
|
LPTSTR pszOldInfPath, BOOL bSilent, CPlatform* plat)
|
|
{
|
|
HKEY hKey = NULL;
|
|
int iReturn = FALSE;
|
|
TCHAR szFmtString[2*MAX_PATH+1] = TEXT("");
|
|
TCHAR szMsg[2*MAX_PATH+1] = TEXT("");
|
|
const int c_iCM12ProfileVersion = 4;
|
|
|
|
MYDBGASSERT((NULL != pszShortServiceName) && (TEXT('\0') != pszShortServiceName[0]));
|
|
MYDBGASSERT((NULL != pszServiceName) && (TEXT('\0') != pszServiceName[0]));
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmMappings, 0,
|
|
KEY_READ, &hKey))
|
|
{
|
|
int iCurrentCmpVersion;
|
|
int iCmpVersionToInstall;
|
|
TCHAR szCurrentCmp[MAX_PATH+1];
|
|
TCHAR szCmpToBeInstalled[MAX_PATH+1];
|
|
DWORD dwSize = MAX_PATH;
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey, pszServiceName, NULL,
|
|
NULL, (LPBYTE)szCurrentCmp, &dwSize))
|
|
{
|
|
//
|
|
// First check to see that the file really exists. It is a somewhat probable case
|
|
// that the users will have deleted their Profile files but left the registry
|
|
// keys intact (they didn't uninstall it). In fact, MSN 2.5 and 2.6 operate this
|
|
// way. Thus if the cmp doesn't actually exist then we don't need a same name
|
|
// upgrade.
|
|
//
|
|
if (!FileExists(szCurrentCmp))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Detected a CM 1.0 Upgrade, but the cmp didn't exist. Not Processing the upgrade."));
|
|
iReturn = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Check to make sure that the Short Service Names agree for the two profiles
|
|
//
|
|
|
|
CFileNameParts CurrentCmpParts(szCurrentCmp);
|
|
if (0 != lstrcmpi(pszShortServiceName, CurrentCmpParts.m_FileName))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_SAME_LS_DIFF_SS, szFmtString, CELEMS(szFmtString)));
|
|
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszShortServiceName,
|
|
CurrentCmpParts.m_FileName, pszServiceName));
|
|
|
|
MessageBox(NULL, szMsg, pszServiceName, MB_OK);
|
|
}
|
|
|
|
iReturn = -1;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Then we have the same servicename profile installed as an all users install.
|
|
// Check the version number in the CMP. If the same version or less then we want
|
|
// to run the same name upgrade. If the current version is more recent, then
|
|
// we want to prevent the user from installing.
|
|
//
|
|
|
|
//
|
|
// Get Currently Installed Profile version
|
|
//
|
|
iCurrentCmpVersion = GetPrivateProfileInt(c_pszCmSectionProfileFormat, c_pszVersion,
|
|
0, szCurrentCmp);
|
|
|
|
//
|
|
// Get the version of the profile to install
|
|
//
|
|
MYVERIFY(CELEMS(szCmpToBeInstalled) > (UINT)wsprintf(szCmpToBeInstalled,
|
|
TEXT("%s%s.cmp"), g_szProfileSourceDir, pszShortServiceName));
|
|
|
|
iCmpVersionToInstall = GetPrivateProfileInt(c_pszCmSectionProfileFormat, c_pszVersion, 0,
|
|
szCmpToBeInstalled);
|
|
|
|
if (iCurrentCmpVersion > iCmpVersionToInstall)
|
|
{
|
|
//
|
|
// We must not allow the install because a newer version of the profile format
|
|
// is already installed.
|
|
//
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_NEWER_SAMENAME, szFmtString, CELEMS(szFmtString)));
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
|
|
MessageBox(NULL, szMsg, pszServiceName, MB_OK | MB_TOPMOST | MB_SYSTEMMODAL);
|
|
}
|
|
|
|
iReturn = -1;
|
|
goto exit;
|
|
}
|
|
else if (iCurrentCmpVersion < c_iCM12ProfileVersion)
|
|
{
|
|
int iUserSelection = 0;
|
|
|
|
//
|
|
// Make sure that this isn't a Non-Admin NT5 person trying to install
|
|
//
|
|
if (plat->IsAtLeastNT5() && !IsAdmin())
|
|
{
|
|
CMASSERTMSG(!bSilent, TEXT("NeedCM10Upgrade -- NonAdmin trying to Same Name upgrade a profile, exiting!"));
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_GET_ADMIN, szFmtString, CELEMS(szFmtString)));
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
|
|
MessageBox(NULL, szMsg, pszServiceName, MB_OK);
|
|
}
|
|
|
|
iReturn = -1;
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Now prompt the user to make sure that they want to go ahead with the upgrade
|
|
//
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UPGRADE_SAMENAME, szFmtString, CELEMS(szFmtString)));
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
|
|
iUserSelection = MessageBox(NULL, szMsg, pszServiceName, MB_YESNO | MB_TOPMOST | MB_SYSTEMMODAL);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Assume yes with Silent Same Name Upgrade
|
|
//
|
|
|
|
iUserSelection = IDYES;
|
|
}
|
|
}
|
|
|
|
if (IDYES == iUserSelection)
|
|
{
|
|
if (UpdateCmpDataFromExistingProfile(pszShortServiceName, szCurrentCmp, szCmpToBeInstalled))
|
|
{
|
|
CFileNameParts FileParts(szCurrentCmp);
|
|
if (0 != GetSystemDirectory(szFmtString, MAX_PATH)) // use szFmtString as a temp
|
|
{
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.inf"), szFmtString, FileParts.m_FileName));
|
|
if (FileExists(szMsg))
|
|
{
|
|
lstrcpy(pszOldInfPath, szMsg);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Not in the system directory, try profile dir.
|
|
//
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg,
|
|
TEXT("%s%s%s\\%s.inf"), FileParts.m_Drive,
|
|
FileParts.m_Dir, FileParts.m_FileName,
|
|
FileParts.m_FileName));
|
|
|
|
if (FileExists(szMsg))
|
|
{
|
|
lstrcpy(pszOldInfPath, szMsg);
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Unable to locate the profile INF -- old profile won't be uninstalled but installation will continue."));
|
|
pszOldInfPath[0] = TEXT('\0');
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Couldn't copy cmp file for same name upgrade. Exiting."));
|
|
iReturn = -1;
|
|
goto exit;
|
|
}
|
|
|
|
iReturn = TRUE;
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
iReturn = -1;
|
|
goto exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Then either the version numbers are the same or the version to install is newer but
|
|
// the existing profile is at least a 1.2 profile.
|
|
//
|
|
iReturn = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
if (hKey)
|
|
{
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: MeetsMinimumProfileInstallVersion
|
|
//
|
|
// Synopsis: Because of problems with previous profile installers (namely 1.0),
|
|
// we built in minimum install requirements for profiles. Thus we
|
|
// look under the Connection Manager App Paths key for a minimum profile
|
|
// version, a minimum build number, and a minimum profile format version.
|
|
// If the profile trying to install doesn't meet any of these requirements,
|
|
// then the function returns FALSE and the install is failed.
|
|
//
|
|
// Arguments: DWORD dwInstallerVersionNumber - current installer version number
|
|
// DWORD dwInstallerBuildNumber - current installer build number
|
|
// LPCTSTR pszInfFile - path to the inf to get the profile format version number
|
|
//
|
|
// Returns: BOOL - TRUE if all the version requirements are met
|
|
//
|
|
// History: quintinb Created Header 5/24/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL MeetsMinimumProfileInstallVersion(DWORD dwInstallerVersionNumber,
|
|
DWORD dwInstallerBuildNumber, LPCTSTR pszInfFile)
|
|
{
|
|
const TCHAR* const c_pszRegMinProfileVersion = TEXT("MinProfileVersion");
|
|
const TCHAR* const c_pszRegMinProfileBuildNum = TEXT("MinProfileBuildNum");
|
|
const TCHAR* const c_pszRegMinProfileFmtVersion = TEXT("MinProfileFmtVersion");
|
|
|
|
HKEY hKey = NULL;
|
|
BOOL bReturn = TRUE;
|
|
DWORD dwTemp;
|
|
|
|
//
|
|
// First check the format version.
|
|
//
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmAppPaths, 0, KEY_READ, &hKey))
|
|
{
|
|
DWORD dwSize = sizeof(DWORD);
|
|
DWORD dwType = 0;
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileFmtVersion, NULL,
|
|
&dwType, (LPBYTE)&dwTemp, &dwSize))
|
|
{
|
|
//
|
|
// Get the profile format version from the cmp file
|
|
//
|
|
DWORD dwFormatVersion;
|
|
CFileNameParts InfParts(pszInfFile);
|
|
TCHAR szCmpFile[MAX_PATH+1];
|
|
|
|
MYVERIFY(CELEMS(szCmpFile) > (UINT)wsprintf(szCmpFile, TEXT("%s%s%s%s"),
|
|
InfParts.m_Drive, InfParts.m_Dir, InfParts.m_FileName, c_pszCmpExt));
|
|
|
|
dwFormatVersion = (DWORD)GetPrivateProfileInt(c_pszCmSectionProfileFormat,
|
|
c_pszVersion, -1, szCmpFile);
|
|
|
|
if (dwTemp > dwFormatVersion)
|
|
{
|
|
bReturn = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Next Check the profile version (equivalent to the version number of the
|
|
// CM bits the profile was built with)
|
|
//
|
|
|
|
dwSize = sizeof(DWORD);
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileVersion, NULL,
|
|
&dwType, (LPBYTE)&dwTemp, &dwSize))
|
|
{
|
|
//
|
|
// If the minimum version number from the registry is higher than the
|
|
// version number listed here, fail the install.
|
|
//
|
|
if (dwTemp > dwInstallerVersionNumber)
|
|
{
|
|
bReturn = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Next Check the profile build number (equivalent to the build number of the
|
|
// CM bits the profile was built with)
|
|
//
|
|
|
|
dwSize = sizeof(DWORD);
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileBuildNum, NULL,
|
|
&dwType, (LPBYTE)&dwTemp, &dwSize))
|
|
{
|
|
//
|
|
// If the minimum version number from the registry is higher than the
|
|
// version number listed here, fail the install.
|
|
//
|
|
if (dwTemp > dwInstallerBuildNumber)
|
|
{
|
|
bReturn = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
|
|
if (hKey)
|
|
{
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: UninstallExistingCmException
|
|
//
|
|
// Synopsis: This function looks for the cmexcept.inf file in the %windir%\inf
|
|
// directory. If this file exists, then we uninstall the
|
|
// existing exception before we install the new one. This prevents
|
|
// the rollback information from being lost.
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: BOOL - returns TRUE if the installer needs to uninstall the
|
|
// existing CM exception install and FALSE if the install
|
|
// can continue without it.
|
|
//
|
|
// History: quintinb Created 11/1/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT UninstallExistingCmException()
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
LPCSTR c_pszCmExceptInfRelative = TEXT("\\Inf\\cmexcept.inf");
|
|
LPCSTR c_pszUnInstallSection = "DefaultUninstall_NoPrompt";
|
|
|
|
UINT uNumChars = GetWindowsDirectoryA(NULL, 0);
|
|
|
|
if (uNumChars)
|
|
{
|
|
uNumChars = uNumChars + lstrlenA(c_pszCmExceptInfRelative);
|
|
|
|
LPSTR pszPathToCmExceptInf = (LPSTR)CmMalloc(sizeof(CHAR)*(uNumChars + 1));
|
|
|
|
if (pszPathToCmExceptInf)
|
|
{
|
|
if (GetWindowsDirectoryA(pszPathToCmExceptInf, uNumChars))
|
|
{
|
|
lstrcatA(pszPathToCmExceptInf, c_pszCmExceptInfRelative);
|
|
|
|
if (FileExists(pszPathToCmExceptInf))
|
|
{
|
|
//
|
|
// We have an exception inf in the directory so we need to uninstall it. Were the
|
|
// bits already on the machine newer than the bits we have in the cab, then we wouldn't
|
|
// be installing. If the bits on the machine don't match the version that the inf says,
|
|
// then we are better uninstalling those bits and putting them in a known state anyway.
|
|
//
|
|
hr = CallLaunchInfSectionEx(pszPathToCmExceptInf, c_pszUnInstallSection, ALINF_ROLLBKDOALL);
|
|
|
|
CMTRACE1(TEXT("UninstallExistingCmException -- CM Exception inf found, uninstalling. CallLaunchInfSectionEx returned hr=0x%x"), hr);
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE; // nothing to delete
|
|
}
|
|
}
|
|
|
|
CmFree(pszPathToCmExceptInf);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CheckCmAndIeRequirements
|
|
//
|
|
// Synopsis: This function checks the CM and IE requirements for a profile
|
|
// and returns whether the CM should be installed, whether profile
|
|
// migration should occur, and most importantly if the install should
|
|
// exit now because of insufficient requirements.
|
|
//
|
|
// Arguments: BOOL* pbInstallCm - tells if CM should be installed or not
|
|
// BOOL* pbMigrateExistingProfiles - tells if profile migration should occur
|
|
// LPCTSTR szInfFile - the inf file to install
|
|
// LPCTSTR szServiceName - The Service name, used as a title
|
|
//
|
|
// Returns: BOOL - returns TRUE if the install should continue, FALSE if
|
|
// if the install should be failed.
|
|
//
|
|
// History: quintinb Created 11/1/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CheckCmAndIeRequirements(HINSTANCE hInstance, BOOL* pbInstallCm,
|
|
BOOL* pbMigrateExistingProfiles, LPCTSTR szInfFile,
|
|
BOOL bNoSupportFiles, LPCTSTR szServiceName, BOOL bSilent)
|
|
{
|
|
CmVersion CmVer;
|
|
CPlatform plat;
|
|
BOOL bReturn;
|
|
BOOL bCMRequired;
|
|
TCHAR szMsg[2*MAX_PATH+1];
|
|
TCHAR szTemp[MAX_PATH+1];
|
|
TCHAR szString[MAX_PATH+1];
|
|
DWORD dwInstallerBuildNumber = 0;
|
|
DWORD dwInstallerVersionNumber = 0;
|
|
|
|
|
|
//
|
|
// The inf file tells us if we included the CM bits
|
|
//
|
|
if (plat.IsNT5())
|
|
{
|
|
//
|
|
// We now need to check to see if we need to install the Windows XP bits on
|
|
// Windows 2000. Thus we check the inf to see if this profile includes the CM
|
|
// bits or not. Note that we never want to install the IE support files on
|
|
// Win2k so set bIERequired to TRUE.
|
|
//
|
|
bCMRequired = !GetPrivateProfileInt(c_pszCmakStatus, TEXT("IncludeCMCode"), 0, szInfFile);
|
|
}
|
|
else if (CmIsNative())
|
|
{
|
|
//
|
|
// CM and IE are required on Windows XP and any platforms with the Native
|
|
// regkey set except NT5 and Win98 SE as they are special cases.
|
|
//
|
|
bCMRequired = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bCMRequired = !GetPrivateProfileInt(c_pszCmakStatus, TEXT("IncludeCMCode"),
|
|
0, szInfFile);
|
|
}
|
|
|
|
//
|
|
// Now try to get the version numbers from the profile INF
|
|
//
|
|
dwInstallerBuildNumber = (DWORD)GetPrivateProfileInt(c_pszSectionCmDial32,
|
|
c_pszVerBuild, ((VER_PRODUCTBUILD << c_iShiftAmount) + VER_PRODUCTBUILD_QFE),
|
|
szInfFile);
|
|
|
|
dwInstallerVersionNumber = (DWORD)GetPrivateProfileInt(c_pszSectionCmDial32,
|
|
c_pszVersion, (HIBYTE(VER_PRODUCTVERSION_W) << c_iShiftAmount) + (LOBYTE(VER_PRODUCTVERSION_W)),
|
|
szInfFile);
|
|
|
|
//
|
|
// First check to see if we have any install minimums in the registry. If these
|
|
// minimums exist and our profile doesn't meet those minimums then we must
|
|
// throw an error message and exit.
|
|
//
|
|
if (!MeetsMinimumProfileInstallVersion(dwInstallerVersionNumber,
|
|
dwInstallerBuildNumber, szInfFile))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_PROFILE_TOO_OLD, szMsg, MAX_PATH));
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONERROR);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Should we migrate existing profiles? Always try to migrate if we find all user
|
|
// profiles already on the machine.
|
|
//
|
|
*pbMigrateExistingProfiles = AllUserProfilesInstalled();
|
|
|
|
//
|
|
// Do CM bits exist on the machine?
|
|
//
|
|
if (CmVer.IsPresent())
|
|
{
|
|
if ((dwInstallerVersionNumber < CmVer.GetVersionNumber()) ||
|
|
(dwInstallerBuildNumber < CmVer.GetBuildAndQfeNumber()))
|
|
{
|
|
//
|
|
// If the CM bits on the machine are newer than the bits we have in the cab,
|
|
// then we only want to install the profile files and not the CM bits themselves.
|
|
//
|
|
|
|
*pbInstallCm = FALSE;
|
|
bReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Then the CM bits on the machine are older than the bits in the cab or
|
|
// the two versions match. Either way, we should install the bits in the
|
|
// cab unless this is Win2k where we never want to re-install the same
|
|
// version of CM bits as we will lose our rollback information.
|
|
//
|
|
|
|
if (bCMRequired)
|
|
{
|
|
if ((dwInstallerVersionNumber == CmVer.GetVersionNumber()) &&
|
|
(CmVer.GetBuildNumber() > c_CmMin13Version))
|
|
{
|
|
//
|
|
// Then the builds have the same major and minor version number
|
|
// and should be considered in the same "Version Family". Note
|
|
// that we also check for a minimum build number because 7.00 is
|
|
// the version number for the CM 1.0 release in NT4 SP4 and we want CM
|
|
// profiles to not install on NT5 Beta2 Bits.
|
|
//
|
|
|
|
*pbInstallCm = FALSE;
|
|
bReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
MYVERIFY(CELEMS(szString) > (UINT)wsprintf(szString, TEXT("%u.%u.%u.%u"),
|
|
HIWORD(dwInstallerVersionNumber), LOWORD(dwInstallerVersionNumber),
|
|
HIWORD(dwInstallerBuildNumber), LOWORD(dwInstallerBuildNumber)));
|
|
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CM_OLDVERSION, szTemp, MAX_PATH));
|
|
MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, szString));
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK);
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((dwInstallerVersionNumber == CmVer.GetVersionNumber()) &&
|
|
(dwInstallerBuildNumber == CmVer.GetBuildAndQfeNumber()))
|
|
{
|
|
//
|
|
// Don't reinstall the CM bits if they are the same version
|
|
// and we are on Win2k. Doing so will overwrite the version of
|
|
// CM ready for rollback.
|
|
//
|
|
*pbInstallCm = !(plat.IsNT5());
|
|
bReturn = TRUE;
|
|
}
|
|
else if (plat.IsNT5() && (FALSE == IsAdmin()))
|
|
{
|
|
//
|
|
// If this is Win2k and we need to install the CM binaries via the exception installer,
|
|
// then the user must be an Administrator to do so. Since this user isn't, fail
|
|
// the install and give the user a warning message.
|
|
//
|
|
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CANNOT_INSTALL_CM, szMsg, 2*MAX_PATH));
|
|
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If this is Win2k, we need to make sure we aren't doing a cross language install.
|
|
// Basically, we want to ensure that we aren't installing English CM bits on a native
|
|
// German machine for instance. If so, fail the install and inform the user why.
|
|
//
|
|
if (plat.IsNT5())
|
|
{
|
|
const TCHAR* const c_pszCmstp = TEXT("cmstp.exe");
|
|
CFileNameParts InfFileParts(szInfFile);
|
|
DWORD dwLen = lstrlen(InfFileParts.m_Drive) + lstrlen(InfFileParts.m_Dir) + lstrlen(c_pszCmstp);
|
|
|
|
if (MAX_PATH >= dwLen)
|
|
{
|
|
wsprintf(szTemp, TEXT("%s%s%s"), InfFileParts.m_Drive, InfFileParts.m_Dir, c_pszCmstp);
|
|
|
|
CVersion CmstpVer(szTemp);
|
|
DWORD dwExistingCmLcid = CmVer.GetLCID();
|
|
DWORD dwCmstpLcid = CmstpVer.GetLCID();
|
|
|
|
if (FALSE == ArePrimaryLangIDsEqual(dwExistingCmLcid, dwCmstpLcid))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CROSS_LANG_INSTALL, szMsg, 2*MAX_PATH));
|
|
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now check to see if installing CM is going to have an effect on CMAK
|
|
//
|
|
CmakVersion CmakVer;
|
|
|
|
if (CmakVer.Is121Cmak() || CmakVer.Is122Cmak())
|
|
{
|
|
//
|
|
// Then the Win2k or IEAK5 version of CMAK is installed. Installing
|
|
// the Whistler version of CM will break this version of CMAK. We
|
|
// need to ask the user if they wish to continue the install and break
|
|
// CMAK or abort the install and leave it as is.
|
|
//
|
|
if (bSilent)
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_INSTCM_WITH_OLD_CMAK, szMsg, 2*MAX_PATH));
|
|
|
|
if (IDNO == MessageBox(NULL, szMsg, szServiceName, MB_YESNO | MB_DEFBUTTON2 | MB_ICONEXCLAMATION))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
*pbInstallCm = TRUE;
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bCMRequired)
|
|
{
|
|
//
|
|
// This is an error because we need CM bits but don't have any on
|
|
// the machine or in the cab (or its Whistler and we won't install them).
|
|
//
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CM_NOTPRESENT, szMsg, MAX_PATH));
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
MYDBGASSERT(FALSE == plat.IsNT5()); // we shouldn't be in this state on Win2k but it is probably
|
|
// better for the user if we install.
|
|
|
|
*pbInstallCm = TRUE;
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!bNoSupportFiles)
|
|
{
|
|
if (!CheckIeDllRequirements(&plat))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_NO_SUPPORTFILES, szMsg, MAX_PATH));
|
|
MessageBox(NULL, szMsg, szServiceName, MB_OK);
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: GetInstallOptions
|
|
//
|
|
// Synopsis: This function decides if the profile should be installed for all
|
|
// users or the current user only, as well as whether the user prefers
|
|
// a desktop icon, a start menu link, both, or neither.
|
|
//
|
|
// Arguments: OUT BOOL* pbInstallForAllUsers - should the profile be installed for all users
|
|
// OUT BOOL* pbCreateDesktopIcon - should a desktop icon be created (if NT5)
|
|
// IN BOOL bCM10Upgrade - is this profile upgrading an older same name profile
|
|
// IN BOOL bNoNT5Shortcut - whether the user specified a switch saying they didn't want an NT5 Shortcut
|
|
// IN BOOL bSilentSingleUser - whether the user specified a switch saying they wanted a silent Single User install
|
|
// IN BOOL bSilentAllUser - whether the user specified a switch saying they wanted a silent ALL User install
|
|
//
|
|
// Returns: TRUE if the install should continue, FALSE otherwise
|
|
//
|
|
// History: quintinb Created 11/1/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL GetInstallOptions(HINSTANCE hInstance, BOOL* pbInstallForAllUsers,
|
|
BOOL* pbCreateDesktopIcon, BOOL bCM10Upgrade, BOOL bNoNT5Shortcut,
|
|
BOOL bSingleUser, BOOL bSilent, LPTSTR pszServiceName)
|
|
{
|
|
//
|
|
// We will only allow NT5 users who are administrators to have a choice of how
|
|
// the profile is installed. If the user is on a legacy platform then the profile
|
|
// will be installed for all users just as before. If the profile is installed by
|
|
// an NT5 user that is not an admin, it will be installed just for them. If they
|
|
// are an admin then they can choose if they want the profile available to all users
|
|
// or just for themselves. If we are on NT5 we also allow the user to choose if
|
|
// they want a Desktop Shortcut or not.
|
|
//
|
|
INT_PTR iUiReturn;
|
|
CPlatform plat;
|
|
|
|
if (plat.IsWin9x() || plat.IsNT4())
|
|
{
|
|
//
|
|
// Legacy install, force to all users (ignore SingleUser flag because not supported).
|
|
//
|
|
*pbInstallForAllUsers = TRUE;
|
|
}
|
|
else
|
|
{
|
|
int iDialogID;
|
|
|
|
if (bSilent)
|
|
{
|
|
*pbCreateDesktopIcon = !bNoNT5Shortcut;
|
|
|
|
if (IsAdmin() && !bSingleUser)
|
|
{
|
|
*pbInstallForAllUsers = TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pbInstallForAllUsers = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (IsAdmin())
|
|
{
|
|
//
|
|
// The user is a local admin, we need to prompt to see if they want to install
|
|
// the profile for themselves or for all users. However, if we are doing a
|
|
// same name upgrade, then we always do an all users install and don't give the
|
|
// admin any choice.
|
|
//
|
|
if (bCM10Upgrade)
|
|
{
|
|
iDialogID = IDD_NOCHOICEUI;
|
|
}
|
|
else
|
|
{
|
|
iDialogID = IDD_ADMINUI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Just a normal user, but we still need to prompt for whether they want
|
|
// a desktop shortcut
|
|
//
|
|
if (bCM10Upgrade)
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Non-Admin NT5 made it to UI choice section. Check CM 1.0 upgrade code."));
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
iDialogID = IDD_NOCHOICEUI;
|
|
}
|
|
}
|
|
|
|
InitDialogStruct DialogArgs;
|
|
DialogArgs.pszTitle = pszServiceName;
|
|
DialogArgs.bNoDesktopIcon = bNoNT5Shortcut;
|
|
DialogArgs.bSingleUser = bSingleUser;
|
|
|
|
iUiReturn = DialogBoxParam(hInstance, MAKEINTRESOURCE(iDialogID), NULL,
|
|
(DLGPROC)ProcessPreferencesUI, (LPARAM)&DialogArgs);
|
|
|
|
if (-1 == iUiReturn)
|
|
{
|
|
// then we had an error or the user hit cancel. Either way bail.
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pbInstallForAllUsers = (BOOL)(iUiReturn & ALLUSERS) || bCM10Upgrade;
|
|
*pbCreateDesktopIcon = (BOOL)(iUiReturn & CREATEDESKTOPICON);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL VerifyProfileOverWriteIfExists(HINSTANCE hInstance, LPCTSTR pszCmsFile, LPCTSTR pszServiceName,
|
|
LPCTSTR pszShortServiceName, LPTSTR pszOldInfPath, BOOL bSilent)
|
|
{
|
|
TCHAR szTmpServiceName [MAX_PATH+1] = TEXT("");
|
|
TCHAR szDisplayMsg[3*MAX_PATH+1] = TEXT("");
|
|
TCHAR szTemp [2*MAX_PATH+1] = TEXT("");
|
|
int iRet;
|
|
|
|
if (FileExists(pszCmsFile))
|
|
{
|
|
//
|
|
// If the file exists then we want to make sure that the service name is the same.
|
|
// If the Long Service Names are the same then we have a re-install.
|
|
// If they aren't the same then we need to prompt the user and find out whether to
|
|
// abandon the install or continue and overwrite it.
|
|
//
|
|
|
|
MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName,
|
|
TEXT(""), szTmpServiceName, CELEMS(szTmpServiceName), pszCmsFile));
|
|
|
|
if (0 != lstrcmp(szTmpServiceName, pszServiceName))
|
|
{
|
|
//
|
|
// If the install is silent, we will assume they know what they are doing
|
|
// and we will overwrite. Otherwise prompt the user to see what they want
|
|
// us to do.
|
|
//
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_SAME_SS_DIFF_LS, szTemp, 2*MAX_PATH));
|
|
|
|
MYVERIFY(CELEMS(szDisplayMsg) > (UINT)wsprintf(szDisplayMsg, szTemp, pszServiceName,
|
|
szTmpServiceName, pszShortServiceName));
|
|
|
|
MessageBox(NULL, szDisplayMsg, pszServiceName, MB_OK | MB_TOPMOST | MB_SYSTEMMODAL);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: PresharedKeyPINDlgProc
|
|
//
|
|
// Synopsis: This function obtains the PIN to be used for the Pre-Shared key
|
|
//
|
|
// History: SumitC 29-Mar-2001 Created
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL APIENTRY PresharedKeyPINDlgProc(
|
|
HWND hDlg,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
static PresharedKeyPINStruct * pPSKArgs;
|
|
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
pPSKArgs = (PresharedKeyPINStruct*)lParam;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
MYDBGASSERT(pPSKArgs);
|
|
if (pPSKArgs && pPSKArgs->szPIN)
|
|
{
|
|
GetDlgItemText(hDlg, IDC_PSK_PIN, pPSKArgs->szPIN, c_dwMaxPresharedKeyPIN);
|
|
}
|
|
MYVERIFY(FALSE != EndDialog(hDlg, 1));
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
MYVERIFY(FALSE != EndDialog(hDlg, -1));
|
|
return TRUE;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
MYVERIFY(FALSE != EndDialog(hDlg, -1));
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: GetPINforPresharedKey
|
|
//
|
|
// Synopsis: Asks the user for a PIN (to be used to decrypt the pre-shared key)
|
|
//
|
|
// Arguments: [hInstance] - used for bringing up dialogs
|
|
// [ppszPIN] - ptr to where to put Pre-Shared Key PIN
|
|
//
|
|
// Returns: LRESULT (ERROR_SUCCESS if we got a PIN,
|
|
// ERROR_INVALID_DATA if user cancelled out of PIN dialog,
|
|
// ERROR_INVALID_PARAMETER if params are bad (this is a coding issue)
|
|
//
|
|
// History: 3-Apr-2001 SumitC Created
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
LRESULT GetPINforPresharedKey(HINSTANCE hInstance, LPTSTR * ppszPIN)
|
|
{
|
|
LRESULT lRet = ERROR_SUCCESS;
|
|
|
|
MYDBGASSERT(hInstance);
|
|
MYDBGASSERT(ppszPIN);
|
|
|
|
if (NULL == hInstance || NULL == ppszPIN)
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
*ppszPIN = NULL;
|
|
|
|
//
|
|
// Get the PIN
|
|
//
|
|
PresharedKeyPINStruct PresharedKeyPINArgs = {0};
|
|
|
|
INT_PTR iUiReturn = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_PRESHAREDKEY_PIN), NULL,
|
|
(DLGPROC)PresharedKeyPINDlgProc, (LPARAM)&PresharedKeyPINArgs);
|
|
|
|
if (-1 == iUiReturn)
|
|
{
|
|
lRet = ERROR_INVALID_DATA; // caller maps to appropriate error message.
|
|
}
|
|
else
|
|
{
|
|
DWORD dwLen = lstrlen(PresharedKeyPINArgs.szPIN);
|
|
if (0 == dwLen)
|
|
{
|
|
lRet = ERROR_INVALID_DATA; // caller maps to appropriate error message.
|
|
}
|
|
else
|
|
{
|
|
*ppszPIN = (LPTSTR) CmMalloc((dwLen + 1) * sizeof(TCHAR));
|
|
if (*ppszPIN)
|
|
{
|
|
lstrcpy(*ppszPIN, PresharedKeyPINArgs.szPIN);
|
|
}
|
|
}
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: DecryptPresharedKeyUsingPIN
|
|
//
|
|
// Synopsis: Given an encoded preshared key and a PIN to be used for decoding,
|
|
// performs the decoding job.
|
|
//
|
|
// Arguments: [pszEncodedPresharedKey] - encoded Preshared key
|
|
// [pszPreSharedKeyPIN] - the PIN
|
|
// [ppszPreSharedKey] - ptr to buffer to place Pre-Shared Key
|
|
//
|
|
// Returns: LRESULT (ERROR_SUCCESS successfully decoded
|
|
// ERROR_INVALID_PARAMETER if params are bad (this is a coding issue)
|
|
// other errors as encountered while calling crypto APIs
|
|
//
|
|
// History: 3-Apr-2001 SumitC Created
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
LRESULT DecryptPresharedKeyUsingPIN(LPCTSTR pszEncodedPresharedKey,
|
|
LPCTSTR pszPresharedKeyPIN,
|
|
LPTSTR * ppszPresharedKey)
|
|
{
|
|
LRESULT lRet = ERROR_BADKEY;
|
|
|
|
if (lstrlen(pszPresharedKeyPIN) < c_dwMinPresharedKeyPIN)
|
|
{
|
|
CMTRACE(TEXT("DecryptPresharedKeyUsingPIN - PIN is too short"));
|
|
return lRet;
|
|
}
|
|
if (lstrlen(pszPresharedKeyPIN) > c_dwMaxPresharedKeyPIN)
|
|
{
|
|
CMTRACE(TEXT("DecryptPresharedKeyUsingPIN - PIN is too long"));
|
|
return lRet;
|
|
}
|
|
|
|
//
|
|
// Init Cmsecure
|
|
//
|
|
InitSecure(FALSE); // use secure, not fast encryption
|
|
|
|
//
|
|
// decrypt to get Preshared key
|
|
//
|
|
if (pszEncodedPresharedKey && pszPresharedKeyPIN)
|
|
{
|
|
DWORD dwLen = 0;
|
|
|
|
if (FALSE == DecryptString((LPBYTE)pszEncodedPresharedKey,
|
|
lstrlen(pszEncodedPresharedKey) * sizeof(TCHAR),
|
|
(LPSTR)pszPresharedKeyPIN,
|
|
(LPBYTE *)ppszPresharedKey,
|
|
&dwLen,
|
|
(PFN_CMSECUREALLOC)CmMalloc,
|
|
(PFN_CMSECUREFREE)CmFree))
|
|
{
|
|
CMTRACE1(TEXT("DecryptPresharedKeyUsingPIN - DecryptString failed with %d"), GetLastError());
|
|
lRet = ERROR_BADKEY;
|
|
}
|
|
else
|
|
{
|
|
lRet = ERROR_SUCCESS;
|
|
CMASSERTMSG(dwLen, TEXT("DecryptString succeeded, but pre-shared key retrieved was 0 bytes?"));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Deinit cmsecure
|
|
//
|
|
DeInitSecure();
|
|
|
|
return lRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SetThisConnectionAsDefault
|
|
//
|
|
// Synopsis: This function loads inetcfg.dll and calls the InetSetAutodial
|
|
// entry on the given service name. Thus this function sets the
|
|
// given servicename as the IE default connection.
|
|
//
|
|
// Arguments: LPCSTR pszServiceName - Long service name of the connection to set
|
|
//
|
|
// Returns: BOOL - TRUE if successful
|
|
//
|
|
// History: quintinb Created 03/04/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL SetThisConnectionAsDefault(LPSTR pszServiceName)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
typedef HRESULT (WINAPI *pfnInetSetAutodialProc)(BOOL, LPSTR);
|
|
|
|
if (pszServiceName && (TEXT('\0') != pszServiceName[0]))
|
|
{
|
|
CDynamicLibrary CnetCfg;
|
|
|
|
if (CnetCfg.Load(TEXT("inetcfg.dll")))
|
|
{
|
|
pfnInetSetAutodialProc pfnInetSetAutodial = (pfnInetSetAutodialProc)CnetCfg.GetProcAddress("InetSetAutodial");
|
|
|
|
if (pfnInetSetAutodial)
|
|
{
|
|
HRESULT hr = pfnInetSetAutodial(TRUE, pszServiceName); // TRUE == fEnable
|
|
bReturn = SUCCEEDED(hr);
|
|
}
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: GetPreSharedKey
|
|
//
|
|
// Synopsis: This function does all the grunt work of getting a PreSharedKey
|
|
// out of the profile and decrypting it if one exists.
|
|
//
|
|
// Arguments: LPCSTR pszCmpFile - full path to the cmp file
|
|
//
|
|
// Returns: HRESULT -- S_OK on success
|
|
// S_FALSE if the profile doesn't contain a PSK
|
|
// E_XXX otherwise
|
|
//
|
|
// History: quintinb Created 09/14/01
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT GetPreSharedKey(HINSTANCE hInstance, LPCTSTR pszCmpFile, LPCTSTR pszServiceName, LPTSTR* ppszPreSharedKey, BOOL bSilent)
|
|
{
|
|
//
|
|
// Check input parameters
|
|
//
|
|
if ((NULL == pszCmpFile) || (TEXT('\0') == pszCmpFile[0]) || (NULL == ppszPreSharedKey) || (NULL == pszServiceName) || (TEXT('\0') == pszServiceName[0]))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("GetPreSharedKey -- Invalid parameter passed."));
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HRESULT hrReturn = S_OK;
|
|
TCHAR szTemp[2*MAX_PATH+1];
|
|
CPlatform plat;
|
|
|
|
//
|
|
// Check to see if we have a Pre-shared Key
|
|
//
|
|
if (FileExists(pszCmpFile))
|
|
{
|
|
LPTSTR pszPresharedKey = GetPrivateProfileStringWithAlloc(c_pszCmSection, c_pszCmEntryPresharedKey, TEXT(""), pszCmpFile);
|
|
|
|
if (pszPresharedKey && (TEXT('\0') != pszPresharedKey[0]))
|
|
{
|
|
//
|
|
// Okay, we potentially have a PSK. If we are on Win2k or a downlevel system without the SafeNet client,
|
|
// then we need to warn the user that their connection might not work and ask them if they wish to continue
|
|
// anyway.
|
|
//
|
|
UINT uMessageId = 0;
|
|
|
|
if (plat.IsNT5()) // NT5 only
|
|
{
|
|
uMessageId = IDS_PSK_NEEDS_XP;
|
|
}
|
|
else if (plat.IsNT4() || plat.IsWin9x()) // downlevel without SafeNet
|
|
{
|
|
SafeNetLinkageStruct SnLinkage = {0};
|
|
|
|
if (!IsSafeNetClientAvailable() || !LinkToSafeNet(&SnLinkage)) // UnLinkFromSafeNet needs to be called if we hit this
|
|
{
|
|
uMessageId = IDS_PSK_NEEDS_SAFENET;
|
|
}
|
|
|
|
UnLinkFromSafeNet(&SnLinkage);
|
|
}
|
|
// else it is WinXP+ or downlevel with SafeNet and everything should work just nicely...
|
|
|
|
if (uMessageId)
|
|
{
|
|
//
|
|
// Now show the user the error message unless we are in silent mode. Either way we aren't going to do anything
|
|
// more with the PSK string since the user's OS cannot handle pre-shared keys.
|
|
//
|
|
int iMessageReturn = IDNO;
|
|
|
|
if (!bSilent && LoadString(hInstance, uMessageId, szTemp, sizeof(szTemp)))
|
|
{
|
|
iMessageReturn = MessageBox(NULL, szTemp, pszServiceName, MB_YESNO | MB_ICONWARNING);
|
|
}
|
|
|
|
if (IDYES == iMessageReturn)
|
|
{
|
|
//
|
|
// Okay, we are continuing but we cannot do anything with the PSK, so set the return code to S_FALSE.
|
|
//
|
|
hrReturn = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The user decided to bail or we are in silent mode and needed to show a warning.
|
|
//
|
|
hrReturn = E_ABORT;
|
|
}
|
|
|
|
//
|
|
// We cannot do anything with the PSK so let's free it. We will erase it from the cmp below.
|
|
//
|
|
CmFree(pszPresharedKey);
|
|
pszPresharedKey = NULL;
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Okay, we have a PSK and it needs further processing such as decryption and/or handing off to RAS/SafeNet.
|
|
//
|
|
|
|
CMTRACE(TEXT("Got a pre-shared key"));
|
|
|
|
BOOL bEncrypted = (BOOL) GetPrivateProfileInt(c_pszCmSection, c_pszCmEntryKeyIsEncrypted, FALSE, pszCmpFile);
|
|
|
|
if (bEncrypted)
|
|
{
|
|
CMTRACE(TEXT("Pre-shared key is encrypted"));
|
|
|
|
if (bSilent)
|
|
{
|
|
//
|
|
// If we are in silent mode, then we cannot exactly ask the user for a PIN. Thus we will have to abort.
|
|
//
|
|
CmFree(pszPresharedKey);
|
|
hrReturn = E_ABORT;
|
|
}
|
|
else
|
|
{
|
|
LPTSTR pszPresharedKeyPIN = NULL;
|
|
LRESULT lRet = GetPINforPresharedKey(hInstance, &pszPresharedKeyPIN);
|
|
|
|
if ((ERROR_SUCCESS == lRet) && pszPresharedKeyPIN)
|
|
{
|
|
//
|
|
// The Pre-shared key is encoded
|
|
//
|
|
LPTSTR pszPresharedKeyDecoded = NULL;
|
|
lRet = DecryptPresharedKeyUsingPIN(pszPresharedKey, pszPresharedKeyPIN, &pszPresharedKeyDecoded);
|
|
|
|
if (ERROR_SUCCESS == lRet)
|
|
{
|
|
*ppszPreSharedKey = pszPresharedKeyDecoded;
|
|
}
|
|
else
|
|
{
|
|
*ppszPreSharedKey = NULL;
|
|
lRet = ERROR_BADKEY;
|
|
}
|
|
}
|
|
|
|
CmFree(pszPresharedKey);
|
|
CmFree(pszPresharedKeyPIN);
|
|
|
|
if (ERROR_SUCCESS != lRet)
|
|
{
|
|
switch (lRet)
|
|
{
|
|
case ERROR_INVALID_DATA:
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_PSK_GOTTA_HAVE_IT, szTemp, CELEMS(szTemp)));
|
|
break;
|
|
case ERROR_BADKEY:
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_PSK_INCORRECT_PIN, szTemp, CELEMS(szTemp)));
|
|
break;
|
|
default:
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
|
|
MYDBGASSERT(0);
|
|
break;
|
|
}
|
|
|
|
MessageBox(NULL, szTemp, pszServiceName, MB_OK | MB_ICONEXCLAMATION);
|
|
hrReturn = E_ACCESSDENIED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Nothing to decode, just save the PSK buffer
|
|
//
|
|
*ppszPreSharedKey = pszPresharedKey;
|
|
}
|
|
|
|
//
|
|
// Write to the cmp file that we need to delete this PSK on uninstall. If we never get fully
|
|
// installed then the cmp file gets deleted anyway so no big deal. Note that we do this here
|
|
// so that it is in the cmp file before we copy it to the profile directory.
|
|
//
|
|
if (SUCCEEDED(hrReturn) && (plat.IsNT4() || plat.IsWin9x()))
|
|
{
|
|
WritePrivateProfileString(c_pszCmSection, c_pszDeletePskOnUninstall, TEXT("1"), pszCmpFile);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Erase the PSK from the cmp file
|
|
//
|
|
WritePrivateProfileString(c_pszCmSection, c_pszCmEntryPresharedKey, NULL, pszCmpFile);
|
|
WritePrivateProfileString(c_pszCmSection, c_pszCmEntryKeyIsEncrypted, NULL, pszCmpFile);
|
|
}
|
|
else
|
|
{
|
|
CmFree(pszPresharedKey);
|
|
hrReturn = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return hrReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: InstallInf
|
|
//
|
|
// Synopsis: This is the driver code for installing a CM profile.
|
|
//
|
|
// Arguments: HINSTANCE hInstance - Instance handle for resources
|
|
// LPCTSTR szInfFile - INF file to install
|
|
// BOOL bNoSupportFiles - forces browser files not to be checked for
|
|
// BOOL bNoLegacyIcon - Don't install with a legacy Icon
|
|
// BOOL bNoNT5Shortcut - Don't give the user a NT5 Desktop Shortcut
|
|
// BOOL bSilent - Install the profile silently
|
|
// BOOL bSingleUser - Install the profile for the current user only
|
|
// Note that single user is the default now even for
|
|
// Admins. Non-Admins always get single user installs.
|
|
// BOOL bSetAsDefault - set as the default connection once installed
|
|
// CNamedMutex* pCmstpMutex - pointer to the cmstp mutex object so
|
|
// that it can be released once the profile is launched
|
|
//
|
|
// Returns: HRESULT - standard COM error codes
|
|
//
|
|
// History: quintinb Created 7/14/98
|
|
// quintinb added support for new switches (252872) 11/20/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
HRESULT InstallInf(HINSTANCE hInstance, LPCTSTR szInfFile, BOOL bNoSupportFiles,
|
|
BOOL bNoLegacyIcon, BOOL bNoNT5Shortcut, BOOL bSilent,
|
|
BOOL bSingleUser, BOOL bSetAsDefault, CNamedMutex* pCmstpMutex)
|
|
{
|
|
CPlatform plat;
|
|
|
|
BOOL bMigrateExistingProfiles;
|
|
BOOL bInstallCm;
|
|
BOOL bMustReboot = FALSE;
|
|
BOOL bCM10Upgrade = FALSE;
|
|
HRESULT hrReturn = S_OK;
|
|
HRESULT hrTemp = S_OK;
|
|
BOOL bInstallForAllUsers;
|
|
BOOL bCreateDesktopIcon = FALSE;
|
|
|
|
HKEY hKey = NULL;
|
|
|
|
DWORD dwSize;
|
|
DWORD dwType;
|
|
TCHAR szInstallDir[MAX_PATH+1];
|
|
TCHAR szTemp[2*MAX_PATH+1];
|
|
TCHAR szCmsFile[MAX_PATH+1];
|
|
TCHAR szOldInfPath[MAX_PATH+1];
|
|
TCHAR szServiceName[MAX_PATH+1];
|
|
TCHAR szShortServiceName[MAX_PATH+1];
|
|
TCHAR szTitle[MAX_PATH+1];
|
|
LPTSTR pszPhonebook = NULL;
|
|
LPTSTR pszCmpFile = NULL;
|
|
LPTSTR pszPresharedKey = NULL;
|
|
|
|
//CMASSERTMSG(FALSE, TEXT("Attach the Debugger now!"));
|
|
MYDBGASSERT((szInfFile) && (TEXT('\0') != szInfFile[0]));
|
|
|
|
CFileNameParts InfParts(szInfFile);
|
|
wsprintf(g_szProfileSourceDir, TEXT("%s%s"), InfParts.m_Drive, InfParts.m_Dir);
|
|
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_CMSTP_TITLE, szTitle, CELEMS(szTitle)));
|
|
MYDBGASSERT(TEXT('\0') != szTitle[0]);
|
|
|
|
//
|
|
// Get the ServiceName and ShortServicename from the inf file
|
|
//
|
|
|
|
MYVERIFY(0 != GetPrivateProfileString(c_pszInfSectionStrings, c_pszCmEntryServiceName,
|
|
TEXT(""), szServiceName, CELEMS(szServiceName), szInfFile));
|
|
|
|
MYVERIFY(0 != GetPrivateProfileString(c_pszInfSectionStrings, c_pszShortSvcName,
|
|
TEXT(""), szShortServiceName, CELEMS(szShortServiceName), szInfFile));
|
|
|
|
if ((TEXT('\0') == szServiceName[0]) || (TEXT('\0') == szShortServiceName[0]))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Either the ServiceName or the ShortServiceName are empty, exiting."));
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If this is NT5, check the New Connection Wizard Policy to see if the user is allowed to
|
|
// create new connections. If not, then don't let them install.
|
|
//
|
|
if (plat.IsAtLeastNT5())
|
|
{
|
|
LPTSTR c_pszNewPolicy = TEXT("NC_NewConnectionWizard");
|
|
LPTSTR c_pszConnectionsPoliciesKey = TEXT("Software\\Policies\\Microsoft\\Windows\\Network Connections");
|
|
|
|
//
|
|
// Administrators and all Authenticated users have access to install profiles
|
|
// by default. Non-Authenticated users don't have access to install profiles
|
|
// because they don't have permission to start Rasman. Thus, even if we
|
|
// allowed them to try to install, it would fail when we couldn't create a
|
|
// connectoid for the profile.
|
|
//
|
|
DWORD dwAllowedToInstall = IsAuthenticatedUser() || IsAdmin();
|
|
|
|
//
|
|
// Now we need to check the policy registry key to see if someone has overriden
|
|
// the default behavior. If so, then we will honor it by setting dwAllowedToInstall
|
|
// to the value of the policy key. Note that we even check the registry key for
|
|
// authenticated users (an Admin could enable installation for all users, but users
|
|
// that weren't Authenticated, namely guests, wouldn't be able to The default is to allow Users, Power Users (who are users), and Admins to install
|
|
// connections. However the policy may be setup so that they cannot. Lets assume they
|
|
// can and then check the regkey.
|
|
//
|
|
if (dwAllowedToInstall)
|
|
{
|
|
LONG lResult = RegOpenKeyEx(HKEY_CURRENT_USER, c_pszConnectionsPoliciesKey,
|
|
0, KEY_READ, &hKey);
|
|
|
|
if (ERROR_SUCCESS == lResult)
|
|
{
|
|
dwSize = sizeof(dwAllowedToInstall);
|
|
|
|
lResult = RegQueryValueEx(hKey, c_pszNewPolicy, NULL,
|
|
NULL, (LPBYTE)&dwAllowedToInstall, &dwSize);
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
if (!dwAllowedToInstall)
|
|
{
|
|
//
|
|
// The user isn't allowed to create new connections, thus they aren't allowed to install
|
|
// CM connections. Throw an error message about permissions and exit.
|
|
//
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_INSTALL_NOT_ALLOWED, szTemp, CELEMS(szTemp)));
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK);
|
|
hrReturn = E_ACCESSDENIED;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
if (!CheckCmAndIeRequirements(hInstance, &bInstallCm, &bMigrateExistingProfiles,
|
|
szInfFile, bNoSupportFiles, szServiceName, bSilent))
|
|
{
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Check to see if we have a same name upgrade
|
|
//
|
|
|
|
bCM10Upgrade = NeedCM10Upgrade(hInstance, szServiceName, szShortServiceName,
|
|
szOldInfPath, bSilent, &plat);
|
|
|
|
if (-1 == bCM10Upgrade)
|
|
{
|
|
//
|
|
// if NeedCM10Upgrade returned -1 then either an error occurred or
|
|
// the user decided not to upgrade. Either way, bail.
|
|
//
|
|
hrReturn = S_FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Check to see if a Pre-shared Key is present and if a PIN is required
|
|
//
|
|
pszCmpFile = szTemp; // re-use szTemp to save stack space and not get into trouble on Win9x
|
|
MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(pszCmpFile, TEXT("%s%s.cmp"),
|
|
g_szProfileSourceDir, szShortServiceName));
|
|
|
|
hrReturn = GetPreSharedKey(hInstance, pszCmpFile, szServiceName, &pszPresharedKey, bSilent);
|
|
|
|
if (FAILED(hrReturn))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Throw the UI to get user install options, unless we are in silent mode
|
|
//
|
|
if (!GetInstallOptions(hInstance, &bInstallForAllUsers, &bCreateDesktopIcon,
|
|
bCM10Upgrade, bNoNT5Shortcut, bSingleUser, bSilent, szServiceName))
|
|
{
|
|
hrReturn = S_FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the installation path
|
|
//
|
|
|
|
ZeroMemory(szInstallDir, sizeof(szInstallDir));
|
|
|
|
if (bInstallForAllUsers)
|
|
{
|
|
//
|
|
// Install for All Users
|
|
//
|
|
|
|
if (!GetAllUsersCmDir(szInstallDir, hInstance))
|
|
{
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Install only for the current user
|
|
//
|
|
|
|
GetPrivateCmUserDir(szInstallDir, hInstance); //lint !e534
|
|
|
|
if (TEXT('\0') == szInstallDir[0])
|
|
{
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
MYVERIFY(CELEMS(szCmsFile) > (UINT)wsprintf(szCmsFile, TEXT("%s\\%s\\%s.cms"),
|
|
szInstallDir, szShortServiceName, szShortServiceName));
|
|
|
|
//
|
|
// Check for two profiles with the same Short Service Name and different Long Service
|
|
// Names
|
|
//
|
|
if (!VerifyProfileOverWriteIfExists(hInstance, szCmsFile,
|
|
szServiceName, szShortServiceName, szOldInfPath, bSilent))
|
|
{
|
|
hrReturn = S_FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
// Now Migrate users old cm profiles (to have full paths to their CMP files in the
|
|
// desktop GUID) if necessary
|
|
//
|
|
if (bMigrateExistingProfiles)
|
|
{
|
|
//
|
|
// Ignore the return here for now. Not much we can do about it at this stage.
|
|
// Should we give them an error?
|
|
//
|
|
MYVERIFY(SUCCEEDED(MigrateOldCmProfilesForProfileInstall(hInstance, g_szProfileSourceDir)));
|
|
}
|
|
|
|
if (bCM10Upgrade)
|
|
{
|
|
//
|
|
// Uninstall the current profile so that we can install the newer version. Note
|
|
// that we don't want to use the uninstall string because it might call for
|
|
// cmstp.exe which is already running. Thus uninstall by calling UninstallProfile
|
|
// directly. Note that we do not delete the credentials on a same name upgrade
|
|
// profile uninstall.
|
|
//
|
|
|
|
if (szOldInfPath[0])
|
|
{
|
|
RemoveShowIconFromRunPostSetupCommands(szOldInfPath);
|
|
|
|
MYVERIFY(SUCCEEDED(UninstallProfile(hInstance, szOldInfPath, FALSE))); // bCleanUpCreds == FALSE
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We need to check if we are installing over another profile of the same name.
|
|
// If so, then we want to recover the cmp data unless this is a CM 1.0 upgrade
|
|
// in which case we have already done this as part of that upgrade code.
|
|
//
|
|
if (-1 == MigrateCmpData(hInstance, bInstallForAllUsers, szServiceName, szShortServiceName, bSilent))
|
|
{
|
|
hrReturn = S_FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// In order to keep MSN's online setup working we need to keep the all user install
|
|
// registry key (used to communicate the path to the inf) in the same place that it was
|
|
// for the Win98 SE/Beta3 release. The Single user reg key location had to be moved to
|
|
// allow plain old users to install profiles.
|
|
//
|
|
HKEY hBaseKey;
|
|
LPTSTR pszRegInfCommKeyPath;
|
|
|
|
if (bInstallForAllUsers)
|
|
{
|
|
hBaseKey = HKEY_LOCAL_MACHINE;
|
|
pszRegInfCommKeyPath = (LPTSTR)c_pszRegCmAppPaths;
|
|
}
|
|
else
|
|
{
|
|
hBaseKey = HKEY_CURRENT_USER;
|
|
pszRegInfCommKeyPath = (LPTSTR)c_pszRegCmRoot;
|
|
}
|
|
|
|
|
|
//
|
|
// Now create the install dir and the reg key to communicate this info to the inf file.
|
|
//
|
|
if (TEXT('\0') != szInstallDir[0])
|
|
{
|
|
//
|
|
// Create the full path to the installation directory.
|
|
//
|
|
MYVERIFY(FALSE != CreateLayerDirectory(szInstallDir));
|
|
|
|
//
|
|
// Make sure the CM directory is writable by all users so that phonebook updates can take place.
|
|
//
|
|
if (bInstallForAllUsers && plat.IsAtLeastNT5())
|
|
{
|
|
MYVERIFY(AllowAccessToWorld(szInstallDir));
|
|
}
|
|
|
|
//
|
|
// Create the Profile subdirectory too, that way we avoid profile
|
|
// install problems on Win98 -- NTRAID 376878
|
|
//
|
|
MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), szInstallDir, szShortServiceName));
|
|
MYVERIFY(FALSE != CreateLayerDirectory(szTemp));
|
|
|
|
//
|
|
// We now need to write the registry key that the inf will use as the
|
|
// installation directory. See the CustomDestination section of the
|
|
// profile inf to see where this ties in.
|
|
//
|
|
if (plat.IsWin9x())
|
|
{
|
|
//
|
|
// Then we need to use the Short Name in the regkey or the inf will not install properly
|
|
//
|
|
MYVERIFY(0 != GetShortPathName(szInstallDir, szTemp, CELEMS(szTemp)));
|
|
|
|
lstrcpyn(szInstallDir, szTemp, MAX_PATH); // szTemp is larger than szInstallDir, we only use MAX_PATH chars
|
|
}
|
|
|
|
if (ERROR_SUCCESS != RegCreateKey(hBaseKey, pszRegInfCommKeyPath, &hKey))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to create the Inf Communication Key"));
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK);
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// We now need to create the value with our szInstallDir string.
|
|
//
|
|
|
|
dwType = REG_SZ;
|
|
dwSize = lstrlen(szInstallDir);
|
|
if (ERROR_SUCCESS != RegSetValueEx(hKey, c_pszProfileInstallPath, NULL, dwType,
|
|
(CONST BYTE *)szInstallDir, dwSize))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to set the Profile Install Path value."));
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK);
|
|
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to resolve the Install Directory."));
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK);
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Install the Profile Files and create the mappings entry
|
|
//
|
|
|
|
if (bInstallForAllUsers)
|
|
{
|
|
hrTemp = LaunchInfSection(szInfFile, TEXT("DefaultInstall"), szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
|
|
//
|
|
// Still launch this for Legacy (read MSN online setup reasons, perhaps others)
|
|
//
|
|
hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_AllUser"), szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
}
|
|
else
|
|
{
|
|
hrTemp = LaunchInfSection(szInfFile, TEXT("DefaultInstall_SingleUser"), szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
|
|
//
|
|
// Still launch this for Legacy (I doubt anyone is using this but kept
|
|
// for consistency with All User which at least MSN was using)
|
|
//
|
|
hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_Private"), szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
|
|
//
|
|
// Write the single user mappings key in code since parsing is involved.
|
|
//
|
|
|
|
if (!WriteSingleUserProfileMappings(szInstallDir, szShortServiceName, szServiceName))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("InstallInf -- WriteSingleUserProfileMappings Failed."));
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK);
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Install the CM bits as necessary
|
|
//
|
|
if (bInstallCm)
|
|
{
|
|
MYDBGASSERT(FALSE == plat.IsNT51());
|
|
|
|
//
|
|
// First, we must extract the CM binaries from the binaries
|
|
// executable/cab to the cmbins sub dir.
|
|
//
|
|
wsprintf(szTemp, TEXT("%scmbins\\"), g_szProfileSourceDir);
|
|
|
|
hrTemp = ExtractCmBinsFromExe(g_szProfileSourceDir, szTemp);
|
|
|
|
if (SUCCEEDED(hrTemp))
|
|
{
|
|
TCHAR szSource [MAX_PATH+1] = {0};
|
|
TCHAR szDest [MAX_PATH+1] = {0};
|
|
|
|
if (plat.IsNT5())
|
|
{
|
|
//
|
|
// Copy cmexcept.cat to the cmbins dir
|
|
//
|
|
MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s%s"), szTemp, TEXT("cmexcept.cat")));
|
|
MYVERIFY(CELEMS(szSource) > (UINT)wsprintf(szSource, TEXT("%s%s"), g_szProfileSourceDir, TEXT("cmexcept.cat")));
|
|
|
|
MYVERIFY(CopyFile(szSource, szDest, FALSE)); // FALSE == bFailIfExists
|
|
|
|
|
|
//
|
|
// Check to see if we need to uninstall a previous CM exception inf
|
|
// and uninstall it as necessary.
|
|
//
|
|
hrTemp = UninstallExistingCmException();
|
|
MYDBGASSERT((S_OK == hrTemp) || (S_FALSE == hrTemp));
|
|
|
|
//
|
|
// Finally, install the CM bits
|
|
//
|
|
hrTemp = InstallWhistlerCmOnWin2k(szTemp);
|
|
|
|
if (FAILED(hrTemp))
|
|
{
|
|
if (!bSilent)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_WIN2K_CM_INSTALL_FAILED, szTemp, CELEMS(szTemp)));
|
|
|
|
MessageBox(NULL, szTemp, szServiceName, MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Make sure to set permissions on the registry keys to avoid issues with non Admins uninstalling
|
|
// the CM binaries. If user's have permissions to the uninstall registry keys but not to
|
|
// files in system32 we can get ourselves in a wierd state. Fix this by locking down the reg permissions.
|
|
//
|
|
hrTemp = SetPermissionsOnWin2kExceptionUninstallRegKeys();
|
|
MYVERIFY(SUCCEEDED(hrTemp));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Okay, we need to copy the instcm.inf file to the cmbins dir and then
|
|
// call InstallCm
|
|
//
|
|
LPCTSTR ArrayOfFileNames[] = {
|
|
TEXT("cnet16.dll"),
|
|
TEXT("ccfg95.dll"),
|
|
TEXT("cmutoa.dll"),
|
|
TEXT("instcm.inf") // instcm.inf must be last so it is given to InstallCm correctly.
|
|
};
|
|
|
|
for (int i = 0; i < (sizeof(ArrayOfFileNames)/sizeof(LPCTSTR)); i++)
|
|
{
|
|
MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s%s"), szTemp, ArrayOfFileNames[i]));
|
|
MYVERIFY(CELEMS(szSource) > (UINT)wsprintf(szSource, TEXT("%s%s"), g_szProfileSourceDir, ArrayOfFileNames[i]));
|
|
|
|
MYVERIFY(CopyFile(szSource, szDest, FALSE)); // FALSE == bFailIfExists
|
|
}
|
|
|
|
hrTemp = InstallCm(hInstance, szDest);
|
|
}
|
|
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("InstallInf -- ExtractCmBinsFromExe failed!"));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now Create the Connectoid. Even if it fails, continue to install.
|
|
//
|
|
if (GetPhoneBookPath(szInstallDir, &pszPhonebook, bInstallForAllUsers))
|
|
{
|
|
BOOL bReturn = WriteCmPhonebookEntry(szServiceName, pszPhonebook, szCmsFile);
|
|
|
|
if (!bReturn && plat.IsAtLeastNT5())
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CMSTP Failed to create a pbk entry on NT5, exiting."));
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
if (bInstallForAllUsers && plat.IsAtLeastNT5())
|
|
{
|
|
MYVERIFY(AllowAccessToWorld(pszPhonebook));
|
|
}
|
|
}
|
|
else if (plat.IsAtLeastNT5())
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CMSTP Failed to get a pbk path on NT5, exiting."));
|
|
hrReturn = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Now we have all the files installed and the pbk entry written,
|
|
// finally create the desktop shortcut/GUID
|
|
//
|
|
if ((plat.IsWin9x()) || (plat.IsNT4()))
|
|
{
|
|
//
|
|
// If we have a Legacy install, then we need to create a desktop icon
|
|
//
|
|
if (!bNoLegacyIcon)
|
|
{
|
|
hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_Legacy"), szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Create a desktop shortcut if necessary
|
|
//
|
|
DeleteNT5ShortcutFromPathAndName(hInstance, szServiceName,
|
|
bInstallForAllUsers ? CSIDL_COMMON_DESKTOPDIRECTORY : CSIDL_DESKTOPDIRECTORY);
|
|
|
|
if (bCreateDesktopIcon)
|
|
{
|
|
HRESULT hr = CreateNT5ProfileShortcut(szServiceName, pszPhonebook, bInstallForAllUsers);
|
|
MYVERIFY(SUCCEEDED(hr));
|
|
}
|
|
}
|
|
|
|
//
|
|
// The profile is now basically installed. Before doing any post install commands, lets check to see
|
|
// if the caller asked us to set this connection as the default connection. If so, then
|
|
// lets set it here.
|
|
//
|
|
if (bSetAsDefault)
|
|
{
|
|
MYVERIFY(SetThisConnectionAsDefault(szServiceName));
|
|
}
|
|
|
|
//
|
|
// if we have a preshared key, give it to RAS
|
|
//
|
|
if (pszPresharedKey)
|
|
{
|
|
if (plat.IsAtLeastNT51())
|
|
{
|
|
pfnRasSetCredentialsSpec pfnSetCredentials;
|
|
|
|
hrReturn = E_FAIL;
|
|
|
|
if (FALSE == GetRasApis(NULL, NULL, NULL, NULL, NULL, &pfnSetCredentials))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CMSTP Failed to get RAS API RasSetCredentials, exiting."));
|
|
goto exit;
|
|
}
|
|
|
|
if (lstrlen(pszPresharedKey) > PWLEN)
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("preshared key is larger than RasSetCredentials can handle!"));
|
|
goto exit;
|
|
}
|
|
|
|
RASCREDENTIALS * pRasCreds = NULL;
|
|
|
|
pRasCreds = (RASCREDENTIALS *) CmMalloc(sizeof(RASCREDENTIALS));
|
|
if (NULL == pRasCreds)
|
|
{
|
|
hrReturn = E_OUTOFMEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
pRasCreds->dwSize = sizeof(RASCREDENTIALS);
|
|
pRasCreds->dwMask = RASCM_PreSharedKey;
|
|
lstrcpyn(pRasCreds->szPassword, pszPresharedKey, lstrlen(pszPresharedKey) + 1);
|
|
|
|
if (0 != pfnSetCredentials(pszPhonebook, szServiceName, pRasCreds, FALSE)) // FALSE => set the credentials
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CMSTP RasSetCredentials failed, exiting."));
|
|
CmFree(pRasCreds);
|
|
goto exit;
|
|
}
|
|
|
|
CmFree(pRasCreds);
|
|
hrReturn = S_OK;
|
|
}
|
|
else if ((plat.IsNT4() || plat.IsWin9x()))
|
|
{
|
|
SafeNetLinkageStruct SnLinkage = {0};
|
|
|
|
if (IsSafeNetClientAvailable() && LinkToSafeNet(&SnLinkage))
|
|
{
|
|
DATA_BLOB DataBlob = {0};
|
|
DataBlob.cbData = (lstrlen(pszPresharedKey) + 1)*sizeof(TCHAR);
|
|
DataBlob.pbData = (BYTE*)pszPresharedKey;
|
|
|
|
if (FALSE == SnLinkage.pfnSnPolicySet(SN_L2TPPRESHR, (void*)&DataBlob))
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CMSTP SnPolicySet failed, exiting."));
|
|
UnLinkFromSafeNet(&SnLinkage);
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Now call SnPolicyReload so the SafeNet driver will take the settings changes
|
|
//
|
|
if (FALSE == SnLinkage.pfnSnPolicyReload())
|
|
{
|
|
//
|
|
// Then we need to ask the user to reboot after finishing the install for the changes to take affect.
|
|
//
|
|
bMustReboot = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMTRACE(TEXT("CMSTP tried to set PSK but SafeNet interface unavailable."));
|
|
}
|
|
|
|
UnLinkFromSafeNet(&SnLinkage);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Do any postinstall cmds here
|
|
//
|
|
LPTSTR pszPostInstallSection;
|
|
|
|
if (bInstallForAllUsers)
|
|
{
|
|
pszPostInstallSection = TEXT("PostInstall");
|
|
}
|
|
else
|
|
{
|
|
pszPostInstallSection = TEXT("PostInstall_Single");
|
|
}
|
|
|
|
hrTemp = LaunchInfSection(szInfFile, pszPostInstallSection, szTitle, bSilent);
|
|
MYDBGASSERT(SUCCEEDED(hrTemp));
|
|
bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
|
|
|
|
//
|
|
// Delete the temporary reg key that we used to communicate the install path to the inf
|
|
//
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(hBaseKey, pszRegInfCommKeyPath,
|
|
0, KEY_ALL_ACCESS, &hKey))
|
|
{
|
|
MYVERIFY(ERROR_SUCCESS == RegDeleteValue(hKey, c_pszProfileInstallPath));
|
|
MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("Unable to delete the ProfileInstallPath temporary Reg value."));
|
|
}
|
|
|
|
//
|
|
// Refresh the desktop so that any GUID or shortcut changes will appear
|
|
//
|
|
RefreshDesktop();
|
|
|
|
//
|
|
// For Win98 and Millennium, we write an App Compatibility flag in order to
|
|
// fix SetForegroundWindow. Refer also to Q135788 for more details of the
|
|
// original fix (which requires this extra code on Win9x to actually work).
|
|
//
|
|
// This fixes Whistler bugs 41696 and 90576.
|
|
//
|
|
if (plat.IsWin98())
|
|
{
|
|
if (!WriteProfileString(TEXT("Compatibility95"), TEXT("CMMON32"), TEXT("0x00000002")))
|
|
{
|
|
CMTRACE(TEXT("InstallInf - failed to write app compat entry for CMMON32 to fix SetForegroundWindow"));
|
|
}
|
|
}
|
|
|
|
//
|
|
// We are finally completed. If we need to reboot, show the user the reboot prompt.
|
|
// Otherwise, show the user a completion message.
|
|
//
|
|
|
|
if (bMustReboot)
|
|
{
|
|
MYVERIFY(0 != LoadString(hInstance, IDS_REBOOT_MSG, szTemp, CELEMS(szTemp)));
|
|
|
|
int iRes = MessageBoxEx(NULL,
|
|
szTemp,
|
|
szServiceName,
|
|
MB_YESNO | MB_DEFBUTTON1 | MB_ICONWARNING | MB_SETFOREGROUND,
|
|
LANG_USER_DEFAULT);
|
|
|
|
if (IDYES == iRes)
|
|
{
|
|
//
|
|
// Shutdown Windows
|
|
//
|
|
DWORD dwReason = plat.IsAtLeastNT51() ? (SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_INSTALLATION) : 0;
|
|
|
|
MyExitWindowsEx(EWX_REBOOT, dwReason);
|
|
}
|
|
}
|
|
else if (!bSilent)
|
|
{
|
|
//
|
|
// Instead of giving the user a message box, we will launch the profile
|
|
// for them. (NTRAID 201307)
|
|
//
|
|
|
|
if (plat.IsAtLeastNT5())
|
|
{
|
|
pCmstpMutex->Unlock(); //NTRAID 310478
|
|
|
|
}
|
|
|
|
MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.cmp"),
|
|
szInstallDir, szShortServiceName));
|
|
|
|
LaunchProfile(szTemp, szServiceName, pszPhonebook, bInstallForAllUsers);
|
|
}
|
|
|
|
exit:
|
|
|
|
CmFree(pszPresharedKey);
|
|
CmFree(pszPhonebook);
|
|
return hrReturn;
|
|
}
|
|
|