726 lines
22 KiB
C++
726 lines
22 KiB
C++
//Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
|
|
//
|
|
// SubToggle.cpp
|
|
// subcomponent enable terminal server implementation.
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "SubToggle.h"
|
|
#include "hydraoc.h"
|
|
#include "pages.h"
|
|
#include "secupgrd.h"
|
|
|
|
#include "gpedit.h"
|
|
|
|
// {0F6B957D-509E-11d1-A7CC-0000F87571E3}
|
|
DEFINE_GUID(CLSID_PolicySnapInMachine,0xf6b957d, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
|
|
|
|
|
|
|
|
// #define REGISTRY_EXTENSION_GUID { 0x35378EAC, 0x683F, 0x11D2, 0xA8, 0x9A, 0x00, 0xC0, 0x4F, 0xBB, 0xCF, 0xA2 }
|
|
DEFINE_GUID(CLSID_RegistryEntensionGuid, 0x35378EAC, 0x683F, 0x11D2, 0xA8, 0x9A, 0x00, 0xC0, 0x4F, 0xBB, 0xCF, 0xA2);
|
|
|
|
|
|
GUID guidRegistryEntension = REGISTRY_EXTENSION_GUID;
|
|
GUID guidPolicyMachineSnapin = CLSID_PolicySnapInMachine;
|
|
|
|
|
|
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
extern DefSecPageData *gpSecPageData;
|
|
|
|
|
|
|
|
DWORD SubCompToggle::GetStepCount () const
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
DWORD SubCompToggle::OnQueryState ( UINT uiWhichState ) const
|
|
{
|
|
DWORD dwReturn = SubcompUseOcManagerDefault;
|
|
|
|
switch(uiWhichState)
|
|
{
|
|
case OCSELSTATETYPE_FINAL:
|
|
dwReturn = StateObject.IsItAppServer() ? SubcompOn : SubcompOff;
|
|
break;
|
|
|
|
case OCSELSTATETYPE_ORIGINAL:
|
|
//
|
|
// thought originally the comp was on, we want to unselect it for server sku.
|
|
//
|
|
if (StateObject.CanInstallAppServer())
|
|
{
|
|
dwReturn = StateObject.WasItAppServer() ? SubcompOn : SubcompOff;
|
|
}
|
|
else
|
|
{
|
|
if (StateObject.WasItAppServer())
|
|
{
|
|
LogErrorToSetupLog(OcErrLevWarning, IDS_STRING_TERMINAL_SERVER_UNINSTALLED);
|
|
}
|
|
dwReturn = SubcompOff;
|
|
}
|
|
break;
|
|
|
|
case OCSELSTATETYPE_CURRENT:
|
|
//
|
|
// our state object knows best about the current state for unattended and fresh install cases.
|
|
//
|
|
if (StateObject.IsTSFreshInstall() || StateObject.IsUnattended())
|
|
{
|
|
if (StateObject.CurrentTSMode() == eAppServer)
|
|
{
|
|
dwReturn = SubcompOn;
|
|
}
|
|
else
|
|
{
|
|
dwReturn = SubcompOff;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwReturn = SubcompUseOcManagerDefault;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
AssertFalse();
|
|
break;
|
|
}
|
|
|
|
return dwReturn;
|
|
|
|
}
|
|
|
|
DWORD SubCompToggle::OnQuerySelStateChange (BOOL bNewState, BOOL bDirectSelection) const
|
|
{
|
|
if (bNewState)
|
|
{
|
|
//
|
|
// this component is available only for adv server or highter. so dont let it be selected for
|
|
// any other sku.
|
|
//
|
|
return StateObject.CanInstallAppServer();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
LPCTSTR SubCompToggle::GetSectionToBeProcessed (ESections eSection) const
|
|
{
|
|
//
|
|
// If the state hasn't changed in stand alone setup, don't do anything.
|
|
// Note that an permission settings will be handled later.
|
|
//
|
|
|
|
if ((StateObject.CurrentTSMode() == StateObject.OriginalTSMode()) &&
|
|
StateObject.IsStandAlone())
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// There are no files to install.
|
|
//
|
|
if ((eSection == kFileSection) || (eSection == kDiskSpaceAddSection))
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
ETSMode eMode = StateObject.CurrentTSMode();
|
|
if (StateObject.IsX86())
|
|
{
|
|
switch (eMode)
|
|
{
|
|
case eRemoteAdmin:
|
|
return StateObject.IsWorkstation() ? REMOTE_ADMIN_PRO_X86 : REMOTE_ADMIN_SERVER_X86;
|
|
break;
|
|
case eAppServer:
|
|
return StateObject.IsWorkstation() ? APPSERVER_PRO_X86 : APPSERVER_SERVER_X86;
|
|
break;
|
|
case ePersonalTS:
|
|
return StateObject.IsWorkstation() ? PERSONALTS_PRO_X86 : PERSONALTS_SERVER_X86;
|
|
break;
|
|
case eTSDisabled:
|
|
default:
|
|
ASSERT(FALSE);
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (eMode)
|
|
{
|
|
case eRemoteAdmin:
|
|
return StateObject.IsWorkstation() ? REMOTE_ADMIN_PRO_IA64 : REMOTE_ADMIN_SERVER_IA64;
|
|
break;
|
|
case eAppServer:
|
|
return StateObject.IsWorkstation() ? APPSERVER_PRO_IA64 : APPSERVER_SERVER_IA64;
|
|
break;
|
|
case ePersonalTS:
|
|
return StateObject.IsWorkstation() ? PERSONALTS_PRO_IA64 : PERSONALTS_SERVER_IA64;
|
|
break;
|
|
case eTSDisabled:
|
|
default:
|
|
ASSERT(FALSE);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
BOOL SubCompToggle::BeforeCompleteInstall ()
|
|
{
|
|
if (StateObject.IsItAppServer() != StateObject.WasItAppServer())
|
|
{
|
|
SetProgressText(StateObject.IsItAppServer() ? IDS_STRING_PROGRESS_ENABLING : IDS_STRING_PROGRESS_DISABLING);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
LPCTSTR SubCompToggle::GetSubCompID () const
|
|
{
|
|
return (APPSRV_COMPONENT_NAME);
|
|
}
|
|
|
|
BOOL SubCompToggle::AfterCompleteInstall ()
|
|
{
|
|
|
|
LOGMESSAGE0(_T("Entering AfterCompleteInstall"));
|
|
ASSERT(StateObject.Assert());
|
|
StateObject.LogState();
|
|
|
|
WriteLicensingMode();
|
|
Tick();
|
|
|
|
SetPermissionsMode ();
|
|
Tick();
|
|
|
|
//
|
|
// this need to be done even if there is no state change, as we want to do this on upgrades as well.
|
|
//
|
|
if (StateObject.IsStandAlone() && !StateObject.IsAppSrvModeSwitch())
|
|
{
|
|
//
|
|
// nothing has changed. dont bother to do any of the next steps.
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
// UpdateMMDefaults();
|
|
|
|
ResetWinstationSecurity ();
|
|
Tick();
|
|
|
|
ModifyWallPaperPolicy();
|
|
Tick();
|
|
|
|
ModifyAppPriority();
|
|
|
|
|
|
// this really belongs in subcore, but since we want to it after ResetWinstationSecurity is called we are calling it here.
|
|
//
|
|
// we have modified winstation security mechanism for whistler.
|
|
// Call this routine, which takes care of upgrades as well as clean installs.
|
|
//
|
|
LOGMESSAGE0(_T("Will Call SetupWorker now."));
|
|
DWORD dwError = SetupWorker(StateObject);
|
|
LOGMESSAGE0(_T("Done with SetupWorker."));
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
LOGMESSAGE1(_T("ERROR :SetupWorker failed. ErrorCode = %d"), dwError);
|
|
}
|
|
|
|
if( StateObject.IsGuiModeSetup() )
|
|
{
|
|
// WARNING : this must be done after SetupWorker()
|
|
SetupRunOnce( GetComponentInfHandle(), RUNONCE_SECTION_KEYWORD );
|
|
}
|
|
|
|
//
|
|
// We need a reboot if we toggled TS through AR/P.
|
|
//
|
|
|
|
if ( StateObject.IsStandAlone() && StateObject.IsAppSrvModeSwitch())
|
|
{
|
|
SetReboot();
|
|
|
|
//
|
|
// If we're changing into or out of app-compatibility mode, inform
|
|
// the licensing system, because we're about to reboot
|
|
//
|
|
InformLicensingOfModeChange();
|
|
Tick();
|
|
}
|
|
|
|
ASSERT(StateObject.Assert());
|
|
StateObject.LogState();
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL SubCompToggle::WriteLicensingMode ()
|
|
{
|
|
//
|
|
// we need to write this value only if it's set in answer file
|
|
//
|
|
if (StateObject.IsItAppServer() && (StateObject.NewLicMode() != eLicUnset))
|
|
{
|
|
DWORD dwError;
|
|
CRegistry oRegTermsrv;
|
|
|
|
dwError = oRegTermsrv.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
DWORD dwMode = StateObject.NewLicMode();
|
|
|
|
TCHAR *tszValueName = StateObject.IsItAppServer() ? REG_LICENSING_MODE_AC_ON : REG_LICENSING_MODE_AC_OFF;
|
|
|
|
LOGMESSAGE2(_T("Writing %s = %d"), tszValueName, dwMode);
|
|
|
|
dwError = oRegTermsrv.WriteRegDWord(tszValueName, dwMode);
|
|
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("Error (%d), Writing, %s Value"), dwError, tszValueName);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("Error (%d), Opening , %s key"), dwError, REG_CONTROL_TS_LICENSING_KEY);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL SubCompToggle::ApplySection (LPCTSTR szSection)
|
|
{
|
|
|
|
DWORD dwError;
|
|
|
|
LOGMESSAGE1(_T("Setting up Registry from section = %s"), szSection);
|
|
dwError = SetupInstallFromInfSection(
|
|
NULL, // hwndOwner
|
|
GetComponentInfHandle(), // inf handle
|
|
szSection, //
|
|
SPINST_REGISTRY, // operation flags
|
|
NULL, // relative key root
|
|
NULL, // source root path
|
|
0, // copy flags
|
|
NULL, // callback routine
|
|
NULL, // callback routine context
|
|
NULL, // device info set
|
|
NULL // device info struct
|
|
);
|
|
|
|
if (dwError == 0)
|
|
{
|
|
LOGMESSAGE1(_T("ERROR:while installating section <%lu>"), GetLastError());
|
|
}
|
|
|
|
return (dwError != 0);
|
|
}
|
|
|
|
|
|
BOOL SubCompToggle::ResetWinstationSecurity ()
|
|
{
|
|
//
|
|
// If the TS mode is changing, reset winstation securities.
|
|
//
|
|
|
|
DWORD dwError;
|
|
if (StateObject.IsAppSrvModeSwitch() && gpSecPageData->GetWinStationCount() > 0)
|
|
{
|
|
CRegistry pReg;
|
|
CRegistry pSubKey;
|
|
LPTSTR* pWinStationArray = gpSecPageData->GetWinStationArray();
|
|
UINT cArray = gpSecPageData->GetWinStationCount();
|
|
|
|
LOGMESSAGE1(_T("%d WinStations to reset."), cArray);
|
|
|
|
//
|
|
// Open the WinStations key. At this point, this key must exist.
|
|
//
|
|
|
|
VERIFY(pReg.OpenKey(HKEY_LOCAL_MACHINE, REG_WINSTATION_KEY) == ERROR_SUCCESS);
|
|
|
|
if (cArray != 0)
|
|
{
|
|
ASSERT(pWinStationArray != NULL);
|
|
|
|
for (UINT i = 0; i < cArray; i++)
|
|
{
|
|
LOGMESSAGE1(_T("Resetting %s."), pWinStationArray[i]);
|
|
|
|
dwError = pSubKey.OpenKey(pReg, pWinStationArray[i]);
|
|
if (dwError == ERROR_SUCCESS)
|
|
{
|
|
LOGMESSAGE2(_T("Delete registry value %s\\%s"), pWinStationArray[i], REG_SECURITY_VALUE);
|
|
|
|
dwError = pSubKey.DeleteValue(REG_SECURITY_VALUE);
|
|
if (dwError == ERROR_SUCCESS)
|
|
{
|
|
LOGMESSAGE0(_T("Registry value deleted."));
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Error deleting value: %ld"), dwError);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("Couldn't open key %s: %ld"), pWinStationArray[i], dwError);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
BOOL SubCompToggle::InformLicensingOfModeChange ()
|
|
{
|
|
BOOL fRet;
|
|
|
|
ASSERT(StateObject.IsTSModeChanging());
|
|
|
|
//
|
|
// RPC into licensing to tell it we're going to reboot
|
|
//
|
|
|
|
HANDLE hServer = ServerLicensingOpen(NULL);
|
|
|
|
if (NULL == hServer)
|
|
{
|
|
LOGMESSAGE1(_T("ERROR: InformLicensingOfModeChange calling ServerLicensingOpen <%lu>"), GetLastError());
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
fRet = ServerLicensingDeactivateCurrentPolicy(
|
|
hServer
|
|
);
|
|
if (!fRet)
|
|
{
|
|
LOGMESSAGE1(_T("ERROR: InformLicensingOfModeChange calling ServerLicensingDeactivateCurrentPolicy <%lu>"), GetLastError());
|
|
}
|
|
|
|
ServerLicensingClose(hServer);
|
|
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL SubCompToggle::SetPermissionsMode ()
|
|
{
|
|
//
|
|
// If TS is toggling on, set the security key based on the choices
|
|
// made through the wizard page. This must be done even if TS was
|
|
// already enabled, as the permissions mode can be changed by the
|
|
// unattended file.
|
|
//
|
|
|
|
CRegistry reg;
|
|
EPermMode ePermMode = StateObject.CurrentPermMode();
|
|
|
|
VERIFY(reg.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY) == ERROR_SUCCESS);
|
|
// BUGBUG should be
|
|
// return (ERROR_SUCCESS == reg.WriteRegDWord( _T("TSUserEnabled"), StateObject.IsItAppServer() ? (DWORD)ePermMode : (DWORD)PERM_WIN2K));
|
|
return (ERROR_SUCCESS == reg.WriteRegDWord( _T("TSUserEnabled"), StateObject.IsTSEnableSelected() ? (DWORD)ePermMode : (DWORD)PERM_TS4));
|
|
|
|
}
|
|
|
|
|
|
BOOL RegisterDll(LPCTSTR szDll)
|
|
{
|
|
USES_CONVERSION;
|
|
HMODULE hMod = LoadLibrary(szDll);
|
|
HRESULT hResult = E_FAIL;
|
|
|
|
if (hMod)
|
|
{
|
|
FARPROC pfRegSrv = GetProcAddress(hMod, "DllRegisterServer");
|
|
if (pfRegSrv)
|
|
{
|
|
__try
|
|
{
|
|
hResult = (HRESULT)pfRegSrv();
|
|
if (hResult != S_OK)
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, DllRegister Server in %s failed, hResult = %x"), szDll, hResult);
|
|
}
|
|
}
|
|
__except( 1 )
|
|
{
|
|
hResult = E_FAIL;
|
|
LOGMESSAGE2(_T("ERROR, Exception hit Registrering of %s failed, Exception = %x"), szDll, GetExceptionCode());
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to Get proc for DllregisterServer for %s"), szDll);
|
|
}
|
|
|
|
FreeLibrary(hMod);
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Failed to Load library %s, lastError = %d"), szDll, GetLastError());
|
|
}
|
|
|
|
return hResult == S_OK;
|
|
}
|
|
|
|
|
|
BOOL SubCompToggle::ModifyWallPaperPolicy ()
|
|
{
|
|
USES_CONVERSION;
|
|
BOOL bRet = FALSE;
|
|
|
|
//
|
|
// policy must be applied when we change modes.
|
|
// also for fresh installs/upgrades of app server.
|
|
//
|
|
if (StateObject.IsAppSrvModeSwitch() || (StateObject.IsGuiModeSetup() && StateObject.IsItAppServer()))
|
|
{
|
|
LOGMESSAGE0(_T("Will apply/change policies now..."));
|
|
if (StateObject.IsGuiModeSetup())
|
|
{
|
|
//
|
|
// in case of Gui mode setup
|
|
// the group policy object may not be registered yet.
|
|
// so lets register it ourselves.
|
|
//
|
|
|
|
TCHAR szGPEditFile[MAX_PATH];
|
|
GetSystemDirectory(szGPEditFile, MAX_PATH);
|
|
_tcscat(szGPEditFile, _T("\\gpedit.dll"));
|
|
if (!RegisterDll(szGPEditFile))
|
|
{
|
|
LOGMESSAGE1(_T("Error, failed to register dll - %s."), szGPEditFile);
|
|
}
|
|
|
|
}
|
|
|
|
OleInitialize(NULL);
|
|
IGroupPolicyObject *pIGroupPolicyObject = NULL;
|
|
HRESULT hResult = CoCreateInstance(
|
|
CLSID_GroupPolicyObject, //Class identifier (CLSID) of the object
|
|
NULL, //Pointer to controlling IUnknown
|
|
CLSCTX_ALL, //Context for running executable code
|
|
IID_IGroupPolicyObject, //Reference to the identifier of the interface
|
|
(void **)&pIGroupPolicyObject //Address of output variable that receives the interface pointer requested in riid
|
|
);
|
|
if (SUCCEEDED(hResult))
|
|
{
|
|
ASSERT(pIGroupPolicyObject);
|
|
|
|
hResult = pIGroupPolicyObject->OpenLocalMachineGPO(GPO_OPEN_LOAD_REGISTRY);
|
|
if (SUCCEEDED(hResult))
|
|
{
|
|
HKEY hMachinePolicyKey = NULL;
|
|
hResult = pIGroupPolicyObject->GetRegistryKey(GPO_SECTION_MACHINE, &hMachinePolicyKey);
|
|
if (SUCCEEDED(hResult))
|
|
{
|
|
ASSERT(hMachinePolicyKey);
|
|
|
|
const LPCTSTR szNoActiveDesktop_key = _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer");
|
|
const LPCTSTR szNoActiveDesktop_val = _T("NoActiveDesktop");
|
|
const DWORD szNoActiveDesktop_dat = 1;
|
|
|
|
const LPCTSTR szNoFileAssoc_key = _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer");
|
|
const LPCTSTR szNoFileAssoc_val = _T("NoFileAssociate");
|
|
const DWORD szNoFileAssoc_dat = 1;
|
|
|
|
CRegistry regMachinePolicy;
|
|
|
|
if (ERROR_SUCCESS == regMachinePolicy.CreateKey(hMachinePolicyKey, szNoActiveDesktop_key))
|
|
{
|
|
if (StateObject.IsItAppServer())
|
|
{
|
|
if (ERROR_SUCCESS != regMachinePolicy.WriteRegDWord(szNoActiveDesktop_val, szNoActiveDesktop_dat))
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to Write %s policy"), szNoActiveDesktop_val);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_SUCCESS != regMachinePolicy.DeleteValue(szNoActiveDesktop_val))
|
|
{
|
|
LOGMESSAGE1(_T("Failed to delete %s policy"), szNoActiveDesktop_val);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ERROR_SUCCESS == regMachinePolicy.CreateKey(hMachinePolicyKey, szNoFileAssoc_key))
|
|
{
|
|
if (StateObject.IsItAppServer())
|
|
{
|
|
if (ERROR_SUCCESS != regMachinePolicy.WriteRegDWord(szNoFileAssoc_val, szNoFileAssoc_dat))
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to Write %s policy"), szNoFileAssoc_val);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_SUCCESS != regMachinePolicy.DeleteValue(szNoFileAssoc_val))
|
|
{
|
|
LOGMESSAGE1(_T("Failed to delete %s policy"), szNoFileAssoc_val);
|
|
}
|
|
}
|
|
}
|
|
|
|
pIGroupPolicyObject->Save(TRUE, TRUE, &guidRegistryEntension, &guidPolicyMachineSnapin);
|
|
RegCloseKey(hMachinePolicyKey);
|
|
bRet = TRUE;
|
|
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to GetRegistryKey...hResult = %x"), hResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to OpenLocalMachineGPO...hResult = %x"), hResult);
|
|
}
|
|
|
|
pIGroupPolicyObject->Release();
|
|
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("ERROR, Failed to get the interface IID_IGroupPolicyObject...hResult = %x"), hResult);
|
|
|
|
}
|
|
|
|
LOGMESSAGE0(_T("Done with Policy changes!"));
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL SubCompToggle::ModifyAppPriority()
|
|
{
|
|
if (StateObject.IsAppSrvModeSwitch())
|
|
{
|
|
DWORD dwSrvPrioity = StateObject.IsItAppServer() ? 0x26 : 0x18;
|
|
|
|
LPCTSTR PRIORITY_KEY = _T("SYSTEM\\CurrentControlSet\\Control\\PriorityControl");
|
|
|
|
CRegistry oReg;
|
|
if (ERROR_SUCCESS == oReg.OpenKey(HKEY_LOCAL_MACHINE, PRIORITY_KEY))
|
|
{
|
|
if (ERROR_SUCCESS != oReg.WriteRegDWord(_T("Win32PrioritySeparation"), dwSrvPrioity))
|
|
{
|
|
LOGMESSAGE0(_T("Error, Failed to update Win32PrioritySeparation"));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Errror, Failed to open %s key"), PRIORITY_KEY);
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
BOOL SubCompToggle::UpdateMMDefaults ()
|
|
{
|
|
LPCTSTR MM_REG_KEY = _T("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management");
|
|
LPCTSTR SESSION_VIEW_SIZE_VALUE = _T("SessionViewSize");
|
|
LPCTSTR SESSION_POOL_SIZE_VALUE = _T("SessionPoolSize");
|
|
|
|
const DWORD dwViewSizeforPTS = 48;
|
|
const DWORD dwPoolSizeforPTS = 4;
|
|
const DWORD dwPoolSizeforRA = 48;
|
|
// const DWORD dwPoolSizeforAS = 16;
|
|
|
|
ASSERT(StateObject.IsTSEnableSelected());
|
|
|
|
if (!StateObject.IsX86())
|
|
{
|
|
// these setting apply only for x86
|
|
return TRUE;
|
|
}
|
|
|
|
CRegistry regMM;
|
|
if (ERROR_SUCCESS != regMM.OpenKey(HKEY_LOCAL_MACHINE, MM_REG_KEY))
|
|
{
|
|
LOGMESSAGE0(_T("ERROR, Failed to open mm Key"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (StateObject.IsWorkstation())
|
|
{
|
|
if ((ERROR_SUCCESS != regMM.WriteRegDWord(SESSION_VIEW_SIZE_VALUE, dwViewSizeforPTS)) ||
|
|
(ERROR_SUCCESS != regMM.WriteRegDWord(SESSION_POOL_SIZE_VALUE, dwPoolSizeforPTS)))
|
|
{
|
|
LOGMESSAGE0(_T("ERROR, Failed to write MM Defaults for PTS"));
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE0(_T("Wrote MM Defaults for PTS"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (StateObject.IsItAppServer())
|
|
{
|
|
// for app server mode, mm sets the right defaults.
|
|
// so just delete these value.
|
|
regMM.DeleteValue(SESSION_VIEW_SIZE_VALUE);
|
|
regMM.DeleteValue(SESSION_POOL_SIZE_VALUE);
|
|
|
|
LOGMESSAGE0(_T("deleted MM defaults for AS"));
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_SUCCESS != regMM.WriteRegDWord(SESSION_POOL_SIZE_VALUE, dwPoolSizeforRA))
|
|
{
|
|
LOGMESSAGE0(_T("ERROR, Failed to write MM Defaults for RA"));
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE0(_T("Wrote MM Defaults for RA"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
*/
|
|
|
|
|