1293 lines
34 KiB
C++
1293 lines
34 KiB
C++
//Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
|
|
/*
|
|
*
|
|
* State.cpp
|
|
*
|
|
* Routines to gather various state information.
|
|
*
|
|
*/
|
|
|
|
//
|
|
// Includes
|
|
//
|
|
|
|
|
|
#define _STATE_CPP_
|
|
|
|
#include "stdafx.h"
|
|
#include "hydraoc.h"
|
|
|
|
|
|
// local functions
|
|
BOOL ReadStringFromAnsewerFile (LPTSTR *szValue);
|
|
BOOL ReadIntFromAnswerFile(LPCTSTR szSection, LPCTSTR szKey, int *piValue);
|
|
|
|
BOOL GetAllowConnectionFromAnswerFile (BOOL *pbAllowConnection);
|
|
BOOL GetPermissionsSettingsFromUnAttendedFile (EPermMode *pPermMode );
|
|
BOOL GetAppModeFromAnswerFile (BOOL *pbEnableAppCompat);
|
|
|
|
|
|
// global state object.
|
|
TSState StateObject;
|
|
|
|
//
|
|
// OC State Function Definitions
|
|
//
|
|
|
|
BOOL DoesTSAppCompatKeyExist( VOID )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ReadIntFromAnswerFile(LPCTSTR szSection, LPCTSTR szKey, int *piValue)
|
|
{
|
|
ASSERT(szSection);
|
|
ASSERT(szKey);
|
|
ASSERT(piValue);
|
|
|
|
HINF hInf = GetUnAttendedInfHandle();
|
|
if (hInf)
|
|
{
|
|
INFCONTEXT InfContext;
|
|
if (SetupFindFirstLine( hInf, szSection, szKey, &InfContext))
|
|
{
|
|
return SetupGetIntField( &InfContext, 1, piValue );
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL ReadStringFromAnsewerFile (LPCTSTR szSection, LPCTSTR szKey, LPTSTR szValue, DWORD dwBufferSize)
|
|
{
|
|
ASSERT(szSection);
|
|
ASSERT(szKey);
|
|
ASSERT(szValue);
|
|
ASSERT(dwBufferSize > 0);
|
|
|
|
HINF hInf = GetUnAttendedInfHandle();
|
|
|
|
if (hInf)
|
|
{
|
|
INFCONTEXT InfContext;
|
|
if (SetupFindFirstLine(hInf, szSection, szKey, &InfContext))
|
|
{
|
|
return SetupGetStringField (&InfContext, 1, szValue, dwBufferSize, NULL);
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL GetAllowConnectionFromAnswerFile (BOOL *pbAllowConnection)
|
|
{
|
|
ASSERT(pbAllowConnection);
|
|
int iValue;
|
|
if (ReadIntFromAnswerFile(TS_UNATTEND_SECTION, TS_ALLOW_CON_ENTRY, &iValue))
|
|
{
|
|
LOGMESSAGE2(_T("Found %s in unattended, Value = %d"), TS_ALLOW_CON_ENTRY, iValue);
|
|
if (iValue == 1)
|
|
{
|
|
*pbAllowConnection = TRUE;
|
|
}
|
|
else if (iValue == 0)
|
|
{
|
|
*pbAllowConnection = FALSE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%d)in answer file. Ignoring..."), TS_ALLOW_CON_ENTRY, iValue);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// if we did not find TS_ALLOW_CON_ENTRY in answer file, then look for TS_ALLOW_CON_ENTRY_2
|
|
if (ReadIntFromAnswerFile(TS_UNATTEND_SECTION, TS_ALLOW_CON_ENTRY_2, &iValue))
|
|
{
|
|
LOGMESSAGE2(_T("Found %s in unattended, Value = %d"), TS_ALLOW_CON_ENTRY_2, iValue);
|
|
if (iValue == 1)
|
|
{
|
|
*pbAllowConnection = TRUE;
|
|
}
|
|
else if (iValue == 0)
|
|
{
|
|
*pbAllowConnection = FALSE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%d)in answer file. Ignoring..."), TS_ALLOW_CON_ENTRY_2, iValue);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
LOGMESSAGE0(_T("answer file entry for allowconnection not found"));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL GetAppModeFromAnswerFile (BOOL *pbEnableAppCompat)
|
|
{
|
|
ASSERT(pbEnableAppCompat);
|
|
|
|
TCHAR szBuffer[256];
|
|
if (ReadStringFromAnsewerFile(_T("Components"), APPSRV_COMPONENT_NAME, szBuffer, 256))
|
|
{
|
|
ASSERT(szBuffer);
|
|
if (0 == _tcsicmp(_T("on"), szBuffer))
|
|
{
|
|
*pbEnableAppCompat = TRUE;
|
|
}
|
|
else if (0 == _tcsicmp(_T("off"), szBuffer))
|
|
{
|
|
*pbEnableAppCompat = FALSE;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%s) in answer file. Ignoring..."), APPSRV_COMPONENT_NAME, szBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
ETSLicensingMode GetLicensingModeFromAnswerFile()
|
|
{
|
|
TCHAR szBuffer[256];
|
|
|
|
if (ReadStringFromAnsewerFile(TS_UNATTEND_SECTION, TS_LICENSING_MODE, szBuffer, 256))
|
|
{
|
|
if (0 == _tcsicmp(_T("perdevice"), szBuffer))
|
|
{
|
|
return eLicPerDevice;
|
|
}
|
|
else if (0 == _tcsicmp(_T("persession"), szBuffer))
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%s) in answer file. Defaulting to PerUser..."), TS_UNATTEND_SECTION, szBuffer);
|
|
return eLicPerUser;
|
|
}
|
|
else if (0 == _tcsicmp(_T("peruser"), szBuffer))
|
|
{
|
|
return eLicPerUser;
|
|
}
|
|
else if (0 == _tcsicmp(_T("pts"), szBuffer))
|
|
{
|
|
return eLicPTS;
|
|
}
|
|
else if (0 == _tcsicmp(_T("remoteadmin"), szBuffer))
|
|
{
|
|
return eLicRemoteAdmin;
|
|
}
|
|
else if (0 == _tcsicmp(_T("internetconnector"), szBuffer))
|
|
{
|
|
return eLicInternetConnector;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%s) in answer file. Ignoring..."), TS_UNATTEND_SECTION, szBuffer);
|
|
return eLicUnset;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return eLicUnset;
|
|
}
|
|
|
|
}
|
|
|
|
BOOL GetPermissionsSettingsFromUnAttendedFile( EPermMode *pPermMode )
|
|
{
|
|
ASSERT(pPermMode);
|
|
|
|
int iValue;
|
|
if (ReadIntFromAnswerFile(TS_UNATTEND_SECTION, TS_UNATTEND_PERMKEY, &iValue))
|
|
{
|
|
if (iValue == PERM_TS4)
|
|
{
|
|
*pPermMode = PERM_TS4;
|
|
}
|
|
else if (iValue == PERM_WIN2K)
|
|
{
|
|
*pPermMode = PERM_WIN2K;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE2(_T("ERROR, Invalid value for %s (%d) in answer file, ignoring..."), TS_UNATTEND_PERMKEY, iValue);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
DWORD SetTSVersion (LPCTSTR pszVersion)
|
|
{
|
|
CRegistry pReg;
|
|
DWORD dwRet;
|
|
|
|
dwRet = pReg.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (dwRet == ERROR_SUCCESS)
|
|
{
|
|
dwRet = pReg.WriteRegString(REG_PRODUCT_VER_KEY, pszVersion);
|
|
}
|
|
|
|
return(dwRet);
|
|
}
|
|
|
|
BOOL WasTSInstalled (VOID)
|
|
{
|
|
return (StateObject.GetInstalltype() != eFreshInstallTS);
|
|
}
|
|
|
|
PSETUP_INIT_COMPONENT GetSetupData ()
|
|
{
|
|
ASSERT(StateObject.GetSetupData());
|
|
return(StateObject.GetSetupData());
|
|
}
|
|
|
|
|
|
ETSInstallType TSState::GetInstalltype () const
|
|
{
|
|
return m_eInstallType;
|
|
}
|
|
|
|
ETSMode TSState::OriginalTSMode () const
|
|
{
|
|
return m_eOriginalTSMode;
|
|
}
|
|
|
|
ETSMode TSState::CurrentTSMode () const
|
|
{
|
|
return m_eCurrentTSMode;
|
|
}
|
|
|
|
ETSLicensingMode TSState::NewLicMode () const
|
|
{
|
|
return m_eNewLicMode;
|
|
}
|
|
|
|
EPermMode TSState::OriginalPermMode () const
|
|
{
|
|
return m_eOriginalPermMode;
|
|
}
|
|
|
|
EPermMode TSState::CurrentPermMode () const
|
|
{
|
|
return m_eCurrentPermMode;
|
|
}
|
|
|
|
BOOL TSState::IsFreshInstall () const
|
|
{
|
|
return !IsStandAlone() && !IsUpgrade();
|
|
}
|
|
|
|
BOOL TSState::IsTSFreshInstall () const
|
|
{
|
|
return m_eInstallType == eFreshInstallTS;
|
|
}
|
|
|
|
BOOL TSState::IsUpgradeFrom40TS () const
|
|
{
|
|
return m_eInstallType == eUpgradeFrom40TS;
|
|
}
|
|
|
|
BOOL TSState::IsUpgradeFrom50TS () const
|
|
{
|
|
return m_eInstallType == eUpgradeFrom50TS;
|
|
}
|
|
|
|
BOOL TSState::IsUpgradeFrom51TS () const
|
|
{
|
|
return m_eInstallType == eUpgradeFrom51TS;
|
|
}
|
|
|
|
BOOL TSState::IsUpgradeFrom52TS () const
|
|
{
|
|
return m_eInstallType == eUpgradeFrom52TS;
|
|
}
|
|
|
|
|
|
BOOL TSState::IsUnattended () const
|
|
{
|
|
return (GetSetupData()->SetupData.OperationFlags & SETUPOP_BATCH) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL TSState::IsStandAlone () const
|
|
{
|
|
return (GetSetupData()->SetupData.OperationFlags & SETUPOP_STANDALONE) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL TSState::IsGuiModeSetup () const
|
|
{
|
|
return !IsStandAlone();
|
|
}
|
|
|
|
BOOL TSState::IsWorkstation () const
|
|
{
|
|
return m_osVersion.wProductType == VER_NT_WORKSTATION;
|
|
}
|
|
|
|
BOOL TSState::IsPersonal () const
|
|
{
|
|
return m_osVersion.wSuiteMask & VER_SUITE_PERSONAL;
|
|
}
|
|
|
|
BOOL TSState::IsProfessional() const
|
|
{
|
|
return IsWorkstation() && !IsPersonal();
|
|
}
|
|
|
|
BOOL TSState::IsServer () const
|
|
{
|
|
return !IsWorkstation();
|
|
}
|
|
|
|
BOOL TSState::IsAdvServerOrHigher () const
|
|
{
|
|
return IsServer() && ((m_osVersion.wSuiteMask & VER_SUITE_ENTERPRISE) || (m_osVersion.wSuiteMask & VER_SUITE_DATACENTER));
|
|
}
|
|
|
|
BOOL TSState::IsSBS () const
|
|
{
|
|
return IsServer () && (m_osVersion.wSuiteMask & VER_SUITE_SMALLBUSINESS);
|
|
}
|
|
|
|
BOOL TSState::IsBlade () const
|
|
{
|
|
if (m_osVersion.wSuiteMask & VER_SUITE_BLADE)
|
|
{
|
|
ASSERT(IsServer());
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL TSState::CanInstallAppServer () const
|
|
{
|
|
// we dont want to allow app server on blade.
|
|
return (IsServer () && !IsBlade() && !IsSBS());
|
|
}
|
|
|
|
BOOL TSState::WasTSInstalled () const
|
|
{
|
|
return !IsTSFreshInstall();
|
|
}
|
|
|
|
BOOL TSState::WasTSEnabled () const
|
|
{
|
|
return this->WasTSInstalled() && m_eOriginalTSMode != eTSDisabled;
|
|
}
|
|
|
|
BOOL TSState::IsUpgrade () const
|
|
{
|
|
return (GetSetupData()->SetupData.OperationFlags & (SETUPOP_NTUPGRADE |
|
|
SETUPOP_WIN95UPGRADE |
|
|
SETUPOP_WIN31UPGRADE)) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL TSState::WasItAppServer () const
|
|
{
|
|
return eAppServer == OriginalTSMode();
|
|
}
|
|
|
|
BOOL TSState::WasItRemoteAdmin () const
|
|
{
|
|
return eRemoteAdmin == OriginalTSMode();
|
|
}
|
|
|
|
BOOL TSState::IsItAppServer () const
|
|
{
|
|
//
|
|
// if its app server, we must have app server selected.
|
|
//
|
|
ASSERT((eAppServer != CurrentTSMode()) || IsAppServerSelected());
|
|
|
|
//
|
|
// if you cannot select app server,it cannot be app server.
|
|
//
|
|
ASSERT((eAppServer != CurrentTSMode()) || CanInstallAppServer());
|
|
return eAppServer == CurrentTSMode();
|
|
}
|
|
|
|
|
|
//
|
|
// this returns the app server selection state.
|
|
//
|
|
BOOL TSState::IsAppServerSelected () const
|
|
{
|
|
return(
|
|
GetHelperRoutines().QuerySelectionState(
|
|
GetHelperRoutines().OcManagerContext,
|
|
APPSRV_COMPONENT_NAME,
|
|
OCSELSTATETYPE_CURRENT
|
|
)
|
|
);
|
|
}
|
|
BOOL TSState::IsItRemoteAdmin () const
|
|
{
|
|
// if its RA we must not have app server selected.
|
|
ASSERT((eRemoteAdmin != CurrentTSMode()) || !IsAppServerSelected());
|
|
return eRemoteAdmin == CurrentTSMode();
|
|
}
|
|
|
|
BOOL TSState::IsAppSrvModeSwitch () const
|
|
{
|
|
ASSERT(m_bNewStateValid); // you can ask if this is mode switch only in after completeinstall
|
|
return WasItAppServer() != IsItAppServer();
|
|
|
|
// this functions return true if
|
|
// 1) its mode switch ( either in standlaone or upgrade )
|
|
// 2) if its fresh install of app server
|
|
|
|
}
|
|
|
|
BOOL TSState::IsStandAloneModeSwitch () const
|
|
{
|
|
ASSERT(m_bNewStateValid); // you can ask if this is mode switch only in after completeinstall
|
|
if (!IsServer())
|
|
return FALSE;
|
|
|
|
if (!IsStandAlone())
|
|
return FALSE;
|
|
|
|
return WasItAppServer() != IsItAppServer();
|
|
}
|
|
|
|
BOOL TSState::IsTSModeChanging () const
|
|
{
|
|
return CurrentTSMode() != OriginalTSMode();
|
|
}
|
|
|
|
BOOL TSState::HasChanged () const
|
|
{
|
|
return ((CurrentTSMode() != OriginalTSMode()) ||
|
|
(CurrentPermMode() != OriginalPermMode()));
|
|
}
|
|
|
|
BOOL TSState::IsTSEnableSelected () const
|
|
{
|
|
//
|
|
// For whistler we dont disable TS ever. OS is always TS Enabled.
|
|
// But for some reason if we want to privide TS Off facility. This function
|
|
// Should return accordingly.
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
void TSState::SetCurrentConnAllowed (BOOL bAllowed)
|
|
{
|
|
// we must not allow connections for personal.
|
|
ASSERT(!bAllowed || !IsPersonal());
|
|
m_bCurrentConnAllowed = bAllowed;
|
|
}
|
|
|
|
BOOL TSState::GetCurrentConnAllowed () const
|
|
{
|
|
return m_bCurrentConnAllowed;
|
|
}
|
|
|
|
BOOL TSState::GetOrigConnAllowed () const
|
|
{
|
|
return m_bOrigConnAllowed;
|
|
}
|
|
|
|
|
|
TSState::TSState ()
|
|
{
|
|
m_gpInitComponentData = NULL;
|
|
m_bNewStateValid = FALSE;
|
|
}
|
|
|
|
TSState::~TSState ()
|
|
{
|
|
if (m_gpInitComponentData)
|
|
LocalFree (m_gpInitComponentData);
|
|
|
|
}
|
|
|
|
const PSETUP_INIT_COMPONENT TSState::GetSetupData () const
|
|
{
|
|
ASSERT(m_gpInitComponentData);
|
|
return m_gpInitComponentData;
|
|
}
|
|
|
|
BOOL TSState::SetSetupData (PSETUP_INIT_COMPONENT pSetupData)
|
|
{
|
|
m_gpInitComponentData = (PSETUP_INIT_COMPONENT)LocalAlloc(LPTR, sizeof(SETUP_INIT_COMPONENT));
|
|
|
|
if (m_gpInitComponentData == NULL)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
CopyMemory(m_gpInitComponentData, pSetupData, sizeof(SETUP_INIT_COMPONENT));
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL TSState::GetNTType ()
|
|
{
|
|
|
|
ZeroMemory(&m_osVersion, sizeof(OSVERSIONINFOEX));
|
|
m_osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
|
|
if (GetVersionEx((LPOSVERSIONINFO )&m_osVersion))
|
|
{
|
|
return TRUE;
|
|
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("GetVersionEx failed, Error = %d"), GetLastError());
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL TSState::Initialize (PSETUP_INIT_COMPONENT pSetupData)
|
|
{
|
|
|
|
ASSERT(pSetupData);
|
|
|
|
if ( !SetSetupData(pSetupData))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// This is a necessary step.
|
|
//
|
|
|
|
if (GetComponentInfHandle())
|
|
SetupOpenAppendInfFile(NULL, GetComponentInfHandle(), NULL);
|
|
|
|
//
|
|
// now populate our state variables.
|
|
// first check if its a professional or server installation.
|
|
//
|
|
|
|
VERIFY( GetNTType() );
|
|
|
|
m_eInstallType = ReadInstallType();
|
|
|
|
// Set Original TS Mode.
|
|
switch (m_eInstallType)
|
|
{
|
|
case eFreshInstallTS:
|
|
m_eOriginalTSMode = eTSDisabled;
|
|
break;
|
|
|
|
case eUpgradeFrom40TS:
|
|
m_eOriginalTSMode = eAppServer;
|
|
break;
|
|
|
|
case eUpgradeFrom50TS:
|
|
case eUpgradeFrom51TS:
|
|
case eUpgradeFrom52TS:
|
|
case eStandAloneSetup:
|
|
m_eOriginalTSMode = ReadTSMode ();
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
m_eOriginalTSMode = eTSDisabled;
|
|
|
|
}
|
|
|
|
// Set Original Permission Modes.
|
|
if (m_eOriginalTSMode == eAppServer)
|
|
{
|
|
m_eOriginalPermMode = ReadPermMode();
|
|
}
|
|
else
|
|
{
|
|
m_eOriginalPermMode = PERM_WIN2K;
|
|
}
|
|
|
|
//
|
|
// Set Original Connection Allowed Status.
|
|
//
|
|
if (m_eInstallType == eFreshInstallTS)
|
|
{
|
|
m_bOrigConnAllowed = FALSE;
|
|
}
|
|
else
|
|
{
|
|
m_bOrigConnAllowed = AreConnectionsAllowed();
|
|
}
|
|
|
|
|
|
//
|
|
// now lets pick default values for the new installation.
|
|
//
|
|
if (m_eInstallType == eFreshInstallTS)
|
|
{
|
|
if (IsWorkstation())
|
|
{
|
|
SetCurrentTSMode (ePersonalTS);
|
|
}
|
|
else
|
|
{
|
|
SetCurrentTSMode (eRemoteAdmin);
|
|
}
|
|
|
|
SetCurrentConnAllowed (FALSE);
|
|
}
|
|
else
|
|
{
|
|
if (m_eOriginalTSMode == eTSDisabled)
|
|
{
|
|
//
|
|
// for whistler we have TS always on.
|
|
// so if ts was disabled perviously, set it to on after upgrade.
|
|
// just disallow connections for such upgrades.
|
|
//
|
|
SetCurrentPermMode (PERM_WIN2K);
|
|
SetCurrentTSMode (IsWorkstation() ? ePersonalTS : eRemoteAdmin);
|
|
SetCurrentConnAllowed (FALSE);
|
|
}
|
|
else if (m_eOriginalTSMode == eAppServer && !CanInstallAppServer())
|
|
{
|
|
//
|
|
// this is upgrade from an app server machine to whistler sku that does not support app server.
|
|
// we must downgrade this since app server is NOT supported on this sku
|
|
//
|
|
ASSERT(FALSE); // this upgrade is not a valid case.
|
|
|
|
SetCurrentPermMode (PERM_WIN2K);
|
|
SetCurrentTSMode (eRemoteAdmin);
|
|
SetCurrentConnAllowed (m_bOrigConnAllowed);
|
|
LOGMESSAGE0(_T("WARNING:Your Terminal Server is uninstalled since its not supported in Server product. Terminal Server is supported only on Advanced Server or Datacenter products"));
|
|
// LogErrorToSetupLog(OcErrLevWarning, IDS_STRING_TERMINAL_SERVER_UNINSTALLED);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// for all other upgrade cases, retain the original values.
|
|
//
|
|
SetCurrentTSMode (m_eOriginalTSMode);
|
|
SetCurrentPermMode (m_eOriginalPermMode);
|
|
if (!IsPersonal())
|
|
{
|
|
SetCurrentConnAllowed (m_bOrigConnAllowed);
|
|
}
|
|
else
|
|
{
|
|
SetCurrentConnAllowed (FALSE);
|
|
}
|
|
|
|
// TurnOffConnectionsForWhistlerServerBetaUpgrades();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//
|
|
// Lets see if we are given the unattended file, to overwrite our new state
|
|
//
|
|
if (StateObject.IsUnattended())
|
|
{
|
|
ASSERT(eTSDisabled != CurrentTSMode());
|
|
BOOL bAppServerMode;
|
|
if (GetAppModeFromAnswerFile(&bAppServerMode))
|
|
{
|
|
LOGMESSAGE1(_T("Mode Setting is %s in answer file"), bAppServerMode ? _T("AppServer") : _T("RemoteAdmin"));
|
|
if (!CanInstallAppServer())
|
|
{
|
|
// we support TS mode selection only on the adv server or data center.
|
|
LOGMESSAGE0(_T("WARNING:Your unattended terminal server mode setting, can not be respected on this installation."));
|
|
|
|
if (IsWorkstation())
|
|
{
|
|
SetCurrentTSMode (ePersonalTS);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(IsServer());
|
|
SetCurrentTSMode (eRemoteAdmin);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bAppServerMode)
|
|
{
|
|
SetCurrentTSMode (eAppServer);
|
|
SetCurrentConnAllowed(TRUE);
|
|
}
|
|
else
|
|
{
|
|
SetCurrentTSMode (eRemoteAdmin);
|
|
SetCurrentConnAllowed(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
EPermMode ePermMode;
|
|
if (GetPermissionsSettingsFromUnAttendedFile(&ePermMode))
|
|
{
|
|
if (ePermMode == PERM_TS4)
|
|
{
|
|
if (m_eCurrentTSMode != eAppServer)
|
|
{
|
|
LOGMESSAGE0(_T("WARNING:Your unattended setting:TS4 perm mode is inconsistent, can't be respected on professional or remote admin mode."));
|
|
}
|
|
else
|
|
{
|
|
SetCurrentPermMode (PERM_TS4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetCurrentPermMode (PERM_WIN2K);
|
|
}
|
|
}
|
|
|
|
// Read Connection Allowed Settings.
|
|
BOOL bAllowConnections;
|
|
if (!IsPersonal() && GetAllowConnectionFromAnswerFile (&bAllowConnections))
|
|
{
|
|
SetCurrentConnAllowed (bAllowConnections);
|
|
}
|
|
|
|
// Read licensing mode
|
|
ETSLicensingMode eLicMode;
|
|
|
|
if (eLicUnset != (eLicMode = GetLicensingModeFromAnswerFile()))
|
|
{
|
|
if (!CanInstallAppServer() || ((eLicMode != eLicPerDevice) && (eLicMode != eLicPerUser)))
|
|
{
|
|
LOGMESSAGE0(_T("WARNING:Your unattended setting:licensing mode is inconsistent, can't be respected."));
|
|
|
|
eLicMode = eLicUnset;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Licensing Mode Setting is %s in answer file"), (eLicMode == eLicPerDevice) ? _T("PerDevice") : _T("PerUser"));
|
|
}
|
|
}
|
|
SetNewLicMode(eLicMode);
|
|
|
|
} // StateObject.IsUnattended()
|
|
|
|
LogState();
|
|
ASSERT( this->Assert () );
|
|
return TRUE;
|
|
}
|
|
|
|
void TSState::UpdateState ()
|
|
{
|
|
m_bNewStateValid = TRUE;
|
|
if (IsAppServerSelected())
|
|
{
|
|
SetCurrentTSMode(eAppServer);
|
|
}
|
|
else
|
|
{
|
|
if (IsWorkstation())
|
|
{
|
|
SetCurrentTSMode(ePersonalTS);
|
|
}
|
|
else
|
|
{
|
|
SetCurrentTSMode(eRemoteAdmin);
|
|
}
|
|
}
|
|
|
|
ASSERT(StateObject.Assert());
|
|
UpdateConnectionAllowed();
|
|
}
|
|
|
|
//
|
|
// this really belongs in subtoggle, however we are doing it here, because the
|
|
// WriteDenyConnectionRegistry happens in subcore. we must set the correct connection
|
|
// value before we write that registry.
|
|
//
|
|
void TSState::UpdateConnectionAllowed ()
|
|
{
|
|
//
|
|
// whenever TS mode is switched,
|
|
// we enable/disable connections allowed.
|
|
// however for unattended setup dont need to do this,
|
|
// as unattended seutp could have explicitely disabled
|
|
// connections.
|
|
//
|
|
if (!IsUnattended())
|
|
{
|
|
if (IsStandAloneModeSwitch())
|
|
{
|
|
if (IsAppServerSelected())
|
|
{
|
|
SetCurrentConnAllowed(TRUE);
|
|
}
|
|
else
|
|
{
|
|
SetCurrentConnAllowed(FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TSState::SetCurrentTSMode (ETSMode eNewMode)
|
|
{
|
|
//
|
|
// we no more have ts disabled mode.
|
|
//
|
|
ASSERT(eNewMode != eTSDisabled);
|
|
|
|
//
|
|
// On server machine you cannot have Personal TS.
|
|
//
|
|
ASSERT(IsServer() || eNewMode == ePersonalTS);
|
|
|
|
// you can have app server only on advance server or higher.
|
|
ASSERT(CanInstallAppServer() || eNewMode != eAppServer);
|
|
|
|
m_eCurrentTSMode = eNewMode;
|
|
|
|
if (eNewMode != eAppServer)
|
|
{
|
|
SetCurrentPermMode (PERM_WIN2K);
|
|
}
|
|
}
|
|
|
|
void TSState::SetNewLicMode (ETSLicensingMode eNewMode)
|
|
{
|
|
//
|
|
// we no more have IC mode.
|
|
//
|
|
ASSERT(eNewMode != eLicInternetConnector);
|
|
|
|
m_eNewLicMode = eNewMode;
|
|
}
|
|
|
|
void TSState::SetCurrentPermMode (EPermMode eNewMode)
|
|
{
|
|
//
|
|
// if you want to set perm mode to PERM_TS4, you must first set AppServer Mode.
|
|
//
|
|
// ASSERT(eNewMode != PERM_TS4 || CurrentTSMode() == eAppServer);
|
|
|
|
m_eCurrentPermMode = eNewMode;
|
|
}
|
|
|
|
ETSInstallType TSState::ReadInstallType () const
|
|
{
|
|
DWORD dwError;
|
|
CRegistry oRegTermsrv;
|
|
if ( IsUpgrade() )
|
|
{
|
|
dwError = oRegTermsrv.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
//
|
|
// TS was installed originally
|
|
//
|
|
DWORD cbVersion = 0;
|
|
LPTSTR szVersion = NULL;
|
|
|
|
//
|
|
// Determine if this is a TS 4.0 upgrade.
|
|
//
|
|
dwError = oRegTermsrv.ReadRegString(REG_PRODUCT_VER_KEY, &szVersion, &cbVersion);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
if ((_tcsicmp(szVersion, _T("5.2")) == 0))
|
|
{
|
|
return eUpgradeFrom52TS;
|
|
}
|
|
else if ((_tcsicmp(szVersion, _T("5.1")) == 0))
|
|
{
|
|
return eUpgradeFrom51TS;
|
|
}
|
|
else if ((_tcsicmp(szVersion, _T("5.0")) == 0))
|
|
{
|
|
return eUpgradeFrom50TS;
|
|
}
|
|
else if ((_tcsicmp(szVersion, _T("4.0")) == 0) || (_tcsicmp(szVersion, _T("2.10")) == 0))
|
|
{
|
|
return eUpgradeFrom40TS;
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Error, dont recognize previous TS version (%s)"), szVersion);
|
|
return eFreshInstallTS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Error, Failed to retrive previous TS version, Errorcode = %d"), dwError);
|
|
return eFreshInstallTS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Could not Open TermSrv Registry, Must be Fresh TS install. Errorcode = %d"), dwError);
|
|
return eFreshInstallTS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if (IsStandAlone())
|
|
{
|
|
return eStandAloneSetup;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// this is fresh install.
|
|
//
|
|
return eFreshInstallTS;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
ETSMode TSState::ReadTSMode () const
|
|
{
|
|
DWORD dwError;
|
|
CRegistry oRegTermsrv;
|
|
|
|
dwError = oRegTermsrv.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
DWORD dwValue = 0;
|
|
dwError = oRegTermsrv.ReadRegDWord(TS_ENABLED_VALUE, &dwValue);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
if (dwValue == 1)
|
|
{
|
|
//
|
|
// ts was enabled, now find out the mode.
|
|
//
|
|
if (oRegTermsrv.ReadRegDWord(TS_APPCMP_VALUE, &dwValue) == ERROR_SUCCESS)
|
|
{
|
|
if (dwValue == 1)
|
|
{
|
|
ASSERT(IsServer());
|
|
return eAppServer;
|
|
}
|
|
else
|
|
{
|
|
if (IsWorkstation())
|
|
{
|
|
return ePersonalTS;
|
|
}
|
|
else
|
|
{
|
|
return eRemoteAdmin;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE0(_T("Error, TSMode registry is missing...Is it Beta version of W2k ?"));
|
|
return eAppServer;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return eTSDisabled;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE0(_T("Error, Failed to retrive previous TS enabled state, Is it TS40 Box??."));
|
|
return eTSDisabled;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Error Opening TermSrv Registry, ErrorCode = %d"), dwError);
|
|
return eTSDisabled;
|
|
|
|
}
|
|
}
|
|
|
|
BOOL TSState::AreConnectionsAllowed () const
|
|
{
|
|
DWORD dwError;
|
|
CRegistry oRegTermsrv;
|
|
|
|
dwError = oRegTermsrv.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
DWORD dwDenyConnect;
|
|
dwError = oRegTermsrv.ReadRegDWord(DENY_CONN_VALUE, &dwDenyConnect);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
return !dwDenyConnect;
|
|
}
|
|
}
|
|
|
|
//
|
|
// could not read registry, this means connections were allowed.
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
EPermMode TSState::ReadPermMode () const
|
|
{
|
|
DWORD dwError;
|
|
CRegistry oRegTermsrv;
|
|
|
|
dwError = oRegTermsrv.OpenKey(HKEY_LOCAL_MACHINE, REG_CONTROL_TS_KEY);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
DWORD dwPerm;
|
|
dwError = oRegTermsrv.ReadRegDWord(_T("TSUserEnabled"), &dwPerm);
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
switch(dwPerm)
|
|
{
|
|
case PERM_TS4:
|
|
case PERM_WIN2K:
|
|
return (EPermMode)dwPerm;
|
|
break;
|
|
|
|
default:
|
|
// The TSUserEnabled key exists with unrecognized value.
|
|
// So it's not an upgrade from TS40. Hence return PERM_WIN2K.
|
|
LOGMESSAGE1(_T("ERROR:Unrecognized, Permission value %d"), dwPerm);
|
|
return PERM_WIN2K;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The Read of TSUserEnabled failed. This key did not exist for TS40.
|
|
// So this could very well be upgrade from TS40.
|
|
// Check what upgrade it is and return PERM value accordingly.
|
|
LOGMESSAGE1(_T("Warning Failed to read Permissions registry, Is it 40 TS / Beta 2000 upgrade > "), dwError);
|
|
if (StateObject.IsUpgradeFrom40TS())
|
|
return PERM_TS4;
|
|
else
|
|
return PERM_WIN2K;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE1(_T("Error Opening TermSrv Registry, Errorcode = %d"), dwError);
|
|
return PERM_WIN2K;
|
|
|
|
}
|
|
}
|
|
|
|
BOOL TSState::LogState () const
|
|
{
|
|
static BOOL sbLoggedOnce = FALSE;
|
|
|
|
if (!sbLoggedOnce)
|
|
{
|
|
LOGMESSAGE0(_T("Setup Parameters ****************************"));
|
|
|
|
|
|
ETSInstallType eInstall = StateObject.GetInstalltype();
|
|
switch (eInstall)
|
|
{
|
|
case eFreshInstallTS:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eFreshInstallTS"));
|
|
break;
|
|
case eUpgradeFrom40TS:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eUpgradeFrom40TS (TS4 upgrade)"));
|
|
break;
|
|
case eUpgradeFrom50TS:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eUpgradeFrom50TS (win2k upgrade)"));
|
|
break;
|
|
case eUpgradeFrom51TS:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eUpgradeFrom51TS (xp upgrade)"));
|
|
break;
|
|
case eUpgradeFrom52TS:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eUpgradeFrom52TS (Windows Server 2003 upgrade)"));
|
|
break;
|
|
case eStandAloneSetup:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("eStandAloneSetup (standalone)"));
|
|
break;
|
|
default:
|
|
LOGMESSAGE1(_T("TS InstallType %s"), _T("ERROR:UNKNOWN"));
|
|
ASSERT(FALSE);
|
|
}
|
|
LOGMESSAGE0(_T("-------------------------------------------------------------------"));
|
|
|
|
LOGMESSAGE1(_T("We are running on = %s"), StateObject.IsWorkstation() ? _T("Wks") : _T("Srv"));
|
|
LOGMESSAGE1(_T("Is this adv server = %s"), StateObject.IsAdvServerOrHigher()? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("Is this Home Edition = %s"), StateObject.IsPersonal()? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("Is this SBS server = %s"), StateObject.IsSBS() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("Is this Blade = %s"), StateObject.IsBlade() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("IsStandAloneSetup = %s"), StateObject.IsStandAlone() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("IsFreshInstall = %s"), StateObject.IsFreshInstall() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("IsUnattended = %s"), StateObject.IsUnattended() ? _T("Yes") : _T("No"));
|
|
|
|
LOGMESSAGE0(_T("Original State ******************************"));
|
|
LOGMESSAGE1(_T("WasTSInstalled = %s"), StateObject.WasTSInstalled() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("WasTSEnabled = %s"), StateObject.WasTSEnabled() ? _T("Yes") : _T("No"));
|
|
LOGMESSAGE1(_T("OriginalPermMode = %s"), StateObject.OriginalPermMode() == PERM_TS4 ? _T("TS4") : _T("WIN2K"));
|
|
|
|
|
|
|
|
ETSMode eOriginalTSMode = StateObject.OriginalTSMode();
|
|
switch (eOriginalTSMode)
|
|
{
|
|
case eRemoteAdmin:
|
|
LOGMESSAGE1(_T("Original TS Mode = %s"), _T("Remote Admin"));
|
|
break;
|
|
case eAppServer:
|
|
LOGMESSAGE1(_T("Original TS Mode = %s"), _T("App Server"));
|
|
break;
|
|
case eTSDisabled:
|
|
LOGMESSAGE1(_T("Original TS Mode = %s"), _T("TS Disabled"));
|
|
break;
|
|
case ePersonalTS:
|
|
LOGMESSAGE1(_T("Original TS Mode = %s"), _T("Personal TS"));
|
|
break;
|
|
default:
|
|
LOGMESSAGE1(_T("Original TS Mode = %s"), _T("Unknown"));
|
|
}
|
|
|
|
sbLoggedOnce = TRUE;
|
|
}
|
|
|
|
|
|
LOGMESSAGE0(_T("Current State ******************************"));
|
|
|
|
ETSMode eCurrentMode = StateObject.CurrentTSMode();
|
|
switch (eCurrentMode)
|
|
{
|
|
case eRemoteAdmin:
|
|
LOGMESSAGE1(_T("New TS Mode = %s"), _T("Remote Admin"));
|
|
break;
|
|
case eAppServer:
|
|
LOGMESSAGE1(_T("New TS Mode = %s"), _T("App Server"));
|
|
break;
|
|
case eTSDisabled:
|
|
LOGMESSAGE1(_T("New TS Mode = %s"), _T("TS Disabled"));
|
|
break;
|
|
case ePersonalTS:
|
|
LOGMESSAGE1(_T("New TS Mode = %s"), _T("Personal TS"));
|
|
break;
|
|
default:
|
|
LOGMESSAGE1(_T("New TS Mode = %s"), _T("Unknown"));
|
|
}
|
|
|
|
EPermMode ePermMode = StateObject.CurrentPermMode();
|
|
switch (ePermMode)
|
|
{
|
|
case PERM_WIN2K:
|
|
LOGMESSAGE1(_T("New Permissions Mode = %s"), _T("PERM_WIN2K"));
|
|
break;
|
|
case PERM_TS4:
|
|
LOGMESSAGE1(_T("New Permissions Mode = %s"), _T("PERM_TS4"));
|
|
break;
|
|
default:
|
|
LOGMESSAGE1(_T("New Permissions Mode = %s"), _T("Unknown"));
|
|
}
|
|
|
|
LOGMESSAGE1(_T("New Connections Allowed = %s"), StateObject.GetCurrentConnAllowed() ? _T("True") : _T("False"));
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
BOOL TSState::IsX86 () const
|
|
{
|
|
SYSTEM_INFO sysInfo;
|
|
ZeroMemory(&sysInfo, sizeof(sysInfo));
|
|
GetSystemInfo(&sysInfo);
|
|
|
|
return sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL;
|
|
}
|
|
|
|
|
|
BOOL TSState::IsAMD64 () const
|
|
{
|
|
SYSTEM_INFO sysInfo;
|
|
ZeroMemory(&sysInfo, sizeof(sysInfo));
|
|
GetSystemInfo(&sysInfo);
|
|
|
|
return sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64;
|
|
}
|
|
|
|
|
|
BOOL TSState::Assert () const
|
|
{
|
|
|
|
// its assert !!
|
|
ASSERT(IsCheckedBuild());
|
|
|
|
// on professional there is no remote admin
|
|
ASSERT(IsServer() || !WasItRemoteAdmin());
|
|
|
|
// on professional there is no app server.
|
|
ASSERT(IsServer() || !WasItAppServer());
|
|
|
|
// if original perm was TS4 compatible, it must have been app server.
|
|
ASSERT((OriginalPermMode() != PERM_TS4) || WasItAppServer());
|
|
|
|
// make sure standalone is consistant.
|
|
ASSERT(IsStandAlone() == (GetInstalltype() == eStandAloneSetup));
|
|
|
|
if (m_bNewStateValid)
|
|
{
|
|
// we no more have disable ts state.
|
|
ASSERT(CurrentTSMode() != eTSDisabled);
|
|
|
|
// AppServer mode is available only for adv server, datacenter
|
|
ASSERT(CanInstallAppServer() || !IsItAppServer());
|
|
|
|
// we cannot be in RA mode for Professional.
|
|
ASSERT(IsServer() || !IsItRemoteAdmin());
|
|
|
|
// if permissions mode is TS4 compatible, it must be appserver
|
|
ASSERT((CurrentPermMode() != PERM_TS4) || IsItAppServer());
|
|
|
|
// we should never allwe connections on Personal
|
|
ASSERT(!IsPersonal() || !GetCurrentConnAllowed ());
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSState::CanShowStartupPopup() const
|
|
{
|
|
if (!StateObject.IsUnattended())
|
|
return TRUE;
|
|
|
|
int iValue = 0;
|
|
if (ReadIntFromAnswerFile(TS_UNATTEND_SECTION, TS_DENY_POPUP, &iValue))
|
|
{
|
|
if (iValue != 0)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSState::IsCheckedBuild () const
|
|
{
|
|
#ifdef DBG
|
|
return TRUE;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|