1145 lines
38 KiB
C++
1145 lines
38 KiB
C++
// --------------------------------------------------------------------------
|
|
// Module Name: SystemSettings.cpp
|
|
//
|
|
// Copyright (c) 1999-2000, Microsoft Corporation
|
|
//
|
|
// A class to handle opening and reading/writing from the Winlogon key.
|
|
//
|
|
// History: 1999-09-09 vtan created
|
|
// 1999-11-16 vtan separate file
|
|
// 2000-02-01 vtan moved from Neptune to Whistler
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include "StandardHeader.h"
|
|
#include "SystemSettings.h"
|
|
|
|
#include <regstr.h>
|
|
#include <safeboot.h>
|
|
#include <winsta.h>
|
|
#include <allproc.h> // TS_COUNTER
|
|
#include <shlwapi.h>
|
|
|
|
#include "RegistryResources.h"
|
|
|
|
const TCHAR CSystemSettings::s_szSafeModeKeyName[] = TEXT("SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\Option");
|
|
const TCHAR CSystemSettings::s_szSafeModeOptionValueName[] = TEXT("OptionValue");
|
|
const TCHAR CSystemSettings::s_szWinlogonKeyName[] = TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon");
|
|
const TCHAR CSystemSettings::s_szSystemPolicyKeyName[] = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
|
|
const TCHAR CSystemSettings::s_szTerminalServerKeyName[] = TEXT("SYSTEM\\CurrentControlSet\\Control\\Terminal Server");
|
|
const TCHAR CSystemSettings::s_szTerminalServerPolicyKeyName[] = TEXT("SOFTWARE\\Policies\\Microsoft\\Windows NT\\Terminal Services");
|
|
const TCHAR CSystemSettings::s_szNetwareClientKeyName[] = TEXT("SYSTEM\\CurrentControlSet\\Control\\NetworkProvider\\Order");
|
|
const TCHAR CSystemSettings::s_szLogonTypeValueName[] = TEXT("LogonType");
|
|
const TCHAR CSystemSettings::s_szBackgroundValueName[] = TEXT("Background");
|
|
const TCHAR CSystemSettings::s_szMultipleUsersValueName[] = TEXT("AllowMultipleTSSessions");
|
|
const TCHAR CSystemSettings::s_szDenyRemoteConnectionsValueName[] = TEXT("fDenyTSConnections");
|
|
|
|
int CSystemSettings::s_iIsSafeModeMinimal = -1;
|
|
int CSystemSettings::s_iIsSafeModeNetwork = -1;
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsSafeMode
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Was the machine started in safe mode (minimal or network) ?
|
|
//
|
|
// History: 2000-03-06 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsSafeMode (void)
|
|
|
|
{
|
|
return(IsSafeModeMinimal() || IsSafeModeNetwork());
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsSafeModeMinimal
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Was the machine started in safe mode minimal?
|
|
//
|
|
// History: 1999-09-13 vtan created
|
|
// 2000-05-25 vtan cache result in static member variable
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsSafeModeMinimal (void)
|
|
|
|
{
|
|
if (-1 == s_iIsSafeModeMinimal)
|
|
{
|
|
bool fResult;
|
|
CRegKey regKey;
|
|
|
|
fResult = false;
|
|
if (ERROR_SUCCESS == regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szSafeModeKeyName,
|
|
KEY_QUERY_VALUE))
|
|
{
|
|
DWORD dwValue, dwValueSize;
|
|
|
|
dwValueSize = sizeof(dwValue);
|
|
if (ERROR_SUCCESS == regKey.GetDWORD(s_szSafeModeOptionValueName,
|
|
dwValue))
|
|
{
|
|
fResult = (dwValue == SAFEBOOT_MINIMAL);
|
|
}
|
|
}
|
|
s_iIsSafeModeMinimal = fResult;
|
|
}
|
|
return(s_iIsSafeModeMinimal != 0);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsSafeModeNetwork
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Was the machine started in safe mode with networking?
|
|
//
|
|
// History: 1999-11-09 vtan created
|
|
// 2000-05-25 vtan cache result in static member variable
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsSafeModeNetwork (void)
|
|
|
|
{
|
|
if (-1 == s_iIsSafeModeNetwork)
|
|
{
|
|
bool fResult;
|
|
CRegKey regKey;
|
|
|
|
fResult = false;
|
|
if (ERROR_SUCCESS == regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szSafeModeKeyName,
|
|
KEY_QUERY_VALUE))
|
|
{
|
|
DWORD dwValue, dwValueSize;
|
|
|
|
dwValueSize = sizeof(dwValue);
|
|
if (ERROR_SUCCESS == regKey.GetDWORD(s_szSafeModeOptionValueName,
|
|
dwValue))
|
|
{
|
|
fResult = (dwValue == SAFEBOOT_NETWORK);
|
|
}
|
|
}
|
|
s_iIsSafeModeNetwork = fResult;
|
|
}
|
|
return(s_iIsSafeModeNetwork != 0);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsNetwareActive
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether this machine is a workstation running
|
|
// Netware client services or not.
|
|
//
|
|
// History: 2001-05-16 cevans created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsNetwareActive (void)
|
|
{
|
|
bool fResult;
|
|
LONG lErrorCode;
|
|
TCHAR szProviders[MAX_PATH] = {0};
|
|
CRegKey regKey;
|
|
|
|
fResult = false;
|
|
lErrorCode = regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szNetwareClientKeyName,
|
|
KEY_QUERY_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
if((regKey.GetString(TEXT("ProviderOrder"), szProviders, ARRAYSIZE(szProviders)) == ERROR_SUCCESS))
|
|
{
|
|
if (StrStrI(szProviders, TEXT("NWCWorkstation")) != NULL)
|
|
{
|
|
fResult = true;
|
|
}
|
|
else if (StrStrI(szProviders, TEXT("NetwareWorkstation")) != NULL)
|
|
{
|
|
fResult = true;
|
|
}
|
|
}
|
|
}
|
|
return fResult;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsWorkStationProduct
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether this machine is a workstation product vs.
|
|
// a server product.
|
|
//
|
|
// History: 2000-08-30 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsWorkStationProduct (void)
|
|
|
|
{
|
|
OSVERSIONINFOEXA osVersionInfo;
|
|
|
|
ZeroMemory(&osVersionInfo, sizeof(osVersionInfo));
|
|
osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
|
|
return((GetVersionExA(reinterpret_cast<OSVERSIONINFOA*>(&osVersionInfo)) != FALSE) &&
|
|
(VER_NT_WORKSTATION == osVersionInfo.wProductType));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsDomainMember
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Is this machine a member of a domain? Use the LSA to get this
|
|
// information.
|
|
//
|
|
// History: 1999-09-14 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsDomainMember (void)
|
|
|
|
{
|
|
bool fResult;
|
|
int iCounter;
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
LSA_HANDLE lsaHandle;
|
|
SECURITY_QUALITY_OF_SERVICE securityQualityOfService;
|
|
PPOLICY_DNS_DOMAIN_INFO pDNSDomainInfo;
|
|
|
|
fResult = false;
|
|
securityQualityOfService.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
|
|
securityQualityOfService.ImpersonationLevel = SecurityImpersonation;
|
|
securityQualityOfService.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
|
|
securityQualityOfService.EffectiveOnly = FALSE;
|
|
InitializeObjectAttributes(&objectAttributes, NULL, 0, NULL, NULL);
|
|
objectAttributes.SecurityQualityOfService = &securityQualityOfService;
|
|
iCounter = 0;
|
|
do
|
|
{
|
|
status = LsaOpenPolicy(NULL, &objectAttributes, POLICY_VIEW_LOCAL_INFORMATION, &lsaHandle);
|
|
if (RPC_NT_SERVER_TOO_BUSY == status)
|
|
{
|
|
Sleep(10);
|
|
}
|
|
} while ((RPC_NT_SERVER_TOO_BUSY == status) && (++iCounter < 10));
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = LsaQueryInformationPolicy(lsaHandle, PolicyDnsDomainInformation, reinterpret_cast<void**>(&pDNSDomainInfo));
|
|
if (NT_SUCCESS(status) && (pDNSDomainInfo != NULL))
|
|
{
|
|
fResult = ((pDNSDomainInfo->DnsDomainName.Length != 0) ||
|
|
(pDNSDomainInfo->DnsForestName.Length != 0) ||
|
|
(pDNSDomainInfo->Sid != NULL));
|
|
TSTATUS(LsaFreeMemory(pDNSDomainInfo));
|
|
}
|
|
TSTATUS(LsaClose(lsaHandle));
|
|
}
|
|
return(fResult);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsActiveConsoleSession
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether current process session is the active console
|
|
// session.
|
|
//
|
|
// History: 2001-03-04 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsActiveConsoleSession (void)
|
|
|
|
{
|
|
return(NtCurrentPeb()->SessionId == USER_SHARED_DATA->ActiveConsoleId);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsTerminalServicesEnabled
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Does this machine have an enabled terminal services service?
|
|
// This function is for Windows 2000 and later ONLY.
|
|
//
|
|
// History: 2000-03-02 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsTerminalServicesEnabled (void)
|
|
|
|
{
|
|
OSVERSIONINFOEX osVersionInfo;
|
|
DWORDLONG dwlConditionMask;
|
|
|
|
dwlConditionMask = 0;
|
|
ZeroMemory(&osVersionInfo, sizeof(osVersionInfo));
|
|
osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
|
|
osVersionInfo.wSuiteMask = VER_SUITE_TERMINAL | VER_SUITE_SINGLEUSERTS;
|
|
VER_SET_CONDITION(dwlConditionMask, VER_SUITENAME, VER_OR);
|
|
return((VerifyVersionInfo(&osVersionInfo, VER_SUITENAME, dwlConditionMask) != FALSE) &&
|
|
!IsSCMTerminalServicesDisabled());
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsFriendlyUIActive
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\LogonType and if this value is 0x01
|
|
// then activate the external UI host. This function returns the
|
|
// setting. This can never be true for domain member machines.
|
|
//
|
|
// History: 2000-02-04 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsFriendlyUIActive (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return(IsWorkStationProduct() &&
|
|
(!IsDomainMember() || IsForceFriendlyUI()) &&
|
|
IsMicrosoftGINA() &&
|
|
!IsNetwareActive() &&
|
|
(ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
s_szLogonTypeValueName,
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsMultipleUsersEnabled
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\AllowMultipleTSSessions and if the
|
|
// value is 0x01 *AND* terminal services is installed on this
|
|
// machine then the conditions are satisfied.
|
|
//
|
|
// History: 2000-03-02 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsMultipleUsersEnabled (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return(IsTerminalServicesEnabled() &&
|
|
!IsSafeMode() &&
|
|
(ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
s_szMultipleUsersValueName,
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsRemoteConnectionsEnabled
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\System\CurrentControlSet\Control\
|
|
// Terminal Server\fDenyTSConnections and returns the
|
|
// value back to the caller.
|
|
//
|
|
// History: 2000-07-28 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsRemoteConnectionsEnabled (void)
|
|
|
|
{
|
|
int iResult;
|
|
CRegKey regKey;
|
|
|
|
return(IsTerminalServicesEnabled() &&
|
|
(ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szTerminalServerKeyName,
|
|
s_szTerminalServerPolicyKeyName,
|
|
s_szDenyRemoteConnectionsValueName,
|
|
iResult)) &&
|
|
(iResult == 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsRemoteConnectionPresent
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether there is a remote connection active on the
|
|
// current system.
|
|
//
|
|
// History: 2000-07-28 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsRemoteConnectionPresent (void)
|
|
|
|
{
|
|
bool fRemoteConnectionPresent;
|
|
HANDLE hServer;
|
|
PLOGONID pLogonID, pLogonIDs;
|
|
ULONG ul, ulEntries;
|
|
|
|
fRemoteConnectionPresent = false;
|
|
|
|
// Open a connection to terminal services and get the number of sessions.
|
|
|
|
hServer = WinStationOpenServerW(reinterpret_cast<WCHAR*>(SERVERNAME_CURRENT));
|
|
if (hServer != NULL)
|
|
{
|
|
if (WinStationEnumerate(hServer, &pLogonIDs, &ulEntries) != FALSE)
|
|
{
|
|
|
|
// Iterate the sessions looking for active and shadow sessions only.
|
|
|
|
for (ul = 0, pLogonID = pLogonIDs; !fRemoteConnectionPresent && (ul < ulEntries); ++ul, ++pLogonID)
|
|
{
|
|
if ((pLogonID->State == State_Active) || (pLogonID->State == State_Shadow))
|
|
{
|
|
fRemoteConnectionPresent = (lstrcmpi(pLogonID->WinStationName, TEXT("console")) != 0);
|
|
}
|
|
}
|
|
|
|
// Free any resources used.
|
|
|
|
(BOOLEAN)WinStationFreeMemory(pLogonIDs);
|
|
}
|
|
(BOOLEAN)WinStationCloseServer(hServer);
|
|
}
|
|
|
|
// Return result.
|
|
|
|
return(fRemoteConnectionPresent);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsShutdownWithoutLogonAllowed
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\ShutdownWithoutLogon and returns the
|
|
// value back to the caller.
|
|
//
|
|
// History: 2000-04-27 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsShutdownWithoutLogonAllowed (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return((ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
TEXT("ShutdownWithoutLogon"),
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsUndockWithoutLogonAllowed
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\UndockWithoutLogon and returns the
|
|
// value back to the caller.
|
|
//
|
|
// History: 2001-03-17 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsUndockWithoutLogonAllowed (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return((ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
REGSTR_VAL_UNDOCK_WITHOUT_LOGON,
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsForceFriendlyUI
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\ForceFriendlyUI and returns the
|
|
// value back to the caller.
|
|
//
|
|
// History: 2000-04-27 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsForceFriendlyUI (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return((ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
TEXT("ForceFriendlyUI"),
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::GetUIHost
|
|
//
|
|
// Arguments: pszPath = TCHAR array to receive UI host path.
|
|
//
|
|
// Returns: LONG
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\UIHost and returns the value.
|
|
//
|
|
// History: 2000-04-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
LONG CSystemSettings::GetUIHost (TCHAR *pszPath)
|
|
|
|
{
|
|
return(GetEffectivePath(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
TEXT("UIHost"),
|
|
pszPath));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsUIHostStatic
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Read the registry HKLM\Software\Microsoft\Windows NT\
|
|
// CurrentVersion\Winlogon\UIHostStatic and returns the
|
|
// value.
|
|
//
|
|
// History: 2000-04-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsUIHostStatic (void)
|
|
|
|
{
|
|
int iResult;
|
|
|
|
return((ERROR_SUCCESS == GetEffectiveInteger(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
s_szSystemPolicyKeyName,
|
|
TEXT("UIHostStatic"),
|
|
iResult)) &&
|
|
(iResult != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::EnableFriendlyUI
|
|
//
|
|
// Arguments: fEnable = Enable friendly UI.
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Enable friendly UI. This should only be allowed on workgroup
|
|
// machines. Check the machine status to enforce this.
|
|
//
|
|
// ERROR_NOT_SUPPORTED is returned when the machine is joined to
|
|
// a domain.
|
|
//
|
|
// History: 2000-08-01 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::EnableFriendlyUI (bool fEnable)
|
|
|
|
{
|
|
LONG lErrorCode;
|
|
|
|
if (!IsDomainMember() || !fEnable)
|
|
{
|
|
CRegKey regKey;
|
|
|
|
lErrorCode = regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
KEY_SET_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
lErrorCode = regKey.SetDWORD(s_szLogonTypeValueName,
|
|
fEnable);
|
|
if (fEnable)
|
|
{
|
|
lErrorCode = regKey.SetString(s_szBackgroundValueName,
|
|
TEXT("0 0 0"));
|
|
}
|
|
else
|
|
{
|
|
(LONG)regKey.DeleteValue(s_szBackgroundValueName);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lErrorCode = ERROR_NOT_SUPPORTED;
|
|
}
|
|
SetLastError(static_cast<DWORD>(lErrorCode));
|
|
return(ERROR_SUCCESS == lErrorCode);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::EnableMultipleUsers
|
|
//
|
|
// Arguments: fEnable = Enable multiple users.
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Enable the multiple users feature. This sets
|
|
// AllowMultipleTSSessions to 1 but only does so if remote
|
|
// connections are disabled. This allows multiple console
|
|
// sessions but no remote sessions. If there is a remote
|
|
// connection active this call is rejected.
|
|
//
|
|
// ERROR_ACCESS_DENIED is returned when there are more than one
|
|
// users active and being disabled.
|
|
//
|
|
// ERROR_CTX_NOT_CONSOLE is returned when being disabled from
|
|
// a remote session (disabling only allowed from the console).
|
|
//
|
|
// ERROR_NOT_SUPPORTED is returned when being disabled from
|
|
// the console, remote connections are enabled, and the current
|
|
// session is not session 0.
|
|
//
|
|
// History: 2000-07-28 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::EnableMultipleUsers (bool fEnable)
|
|
|
|
{
|
|
LONG lErrorCode;
|
|
|
|
// If disabling multiple users with more than one users active
|
|
// reject the call. Return ERROR_ACCESS_DENIED.
|
|
|
|
if (!fEnable && (GetLoggedOnUserCount() > 1))
|
|
{
|
|
lErrorCode = ERROR_ACCESS_DENIED;
|
|
}
|
|
|
|
// If disabling and not on the console, reject the call.
|
|
// Return ERROR_CTX_NOT_CONSOLE.
|
|
|
|
else if (!fEnable && !IsActiveConsoleSession())
|
|
{
|
|
lErrorCode = ERROR_CTX_NOT_CONSOLE;
|
|
}
|
|
|
|
// If disabling from the console and remote connections are enabled and
|
|
// the current session is not session 0, reject the call. Otherwise, a
|
|
// a remote connection with FUS disabled causes strange results because
|
|
// it expects to connect to session 0.
|
|
// Return ERROR_NOT_SUPPORTED.
|
|
|
|
else if (!fEnable && IsRemoteConnectionsEnabled() && NtCurrentPeb()->SessionId != 0)
|
|
{
|
|
lErrorCode = ERROR_NOT_SUPPORTED;
|
|
}
|
|
else
|
|
{
|
|
CRegKey regKey;
|
|
|
|
lErrorCode = regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
KEY_SET_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
lErrorCode = regKey.SetDWORD(s_szMultipleUsersValueName,
|
|
fEnable);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
(DWORD)AdjustFUSCompatibilityServiceState(NULL);
|
|
}
|
|
}
|
|
}
|
|
SetLastError(static_cast<DWORD>(lErrorCode));
|
|
return(ERROR_SUCCESS == lErrorCode);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::EnableRemoteConnections
|
|
//
|
|
// Arguments: fEnable = Enable remote connections.
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Enable the remote connections feature. This sets
|
|
// fDenyTSConnections to 0 but only does so if there is a one
|
|
// user logged onto the system. This allows the single
|
|
// connection to be remotely connected but not allow multiple
|
|
// console sessions. This conforms to the single user per CPU
|
|
// license of the workstation product. To get multiple users
|
|
// you need the server product.
|
|
//
|
|
// ERROR_NOT_SUPPORTED is returned when enabling remote
|
|
// connections with FUS disabled and the current session != 0.
|
|
//
|
|
// History: 2000-07-28 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::EnableRemoteConnections (bool fEnable)
|
|
|
|
{
|
|
LONG lErrorCode;
|
|
|
|
// If enabling remote connections, FUS is disabled, and we are not on
|
|
// session 0 (can happen immediately after disabling FUS), then a remote
|
|
// connection will fail. With FUS disabled, the connection must go to
|
|
// session 0. This is a fringe case, but disallow enabling remote
|
|
// connections if it happens.
|
|
|
|
if (fEnable && !IsMultipleUsersEnabled() && NtCurrentPeb()->SessionId != 0)
|
|
{
|
|
lErrorCode = ERROR_NOT_SUPPORTED;
|
|
}
|
|
else
|
|
{
|
|
CRegKey regKey;
|
|
|
|
lErrorCode = regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szTerminalServerKeyName,
|
|
KEY_SET_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
lErrorCode = regKey.SetDWORD(s_szDenyRemoteConnectionsValueName,
|
|
!fEnable);
|
|
}
|
|
}
|
|
SetLastError(static_cast<DWORD>(lErrorCode));
|
|
return(ERROR_SUCCESS == lErrorCode);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::GetLoggedOnUserCount
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: int
|
|
//
|
|
// Purpose: Returns the count of logged on users on this machine. Ripped
|
|
// straight out of shtdndlg.c in msgina.
|
|
//
|
|
// History: 2000-03-29 vtan created
|
|
// 2000-04-21 vtan copied from taskmgr
|
|
// 2000-07-28 vtan moved from userlist.cpp
|
|
// --------------------------------------------------------------------------
|
|
|
|
int CSystemSettings::GetLoggedOnUserCount (void)
|
|
|
|
{
|
|
int iCount;
|
|
HANDLE hServer;
|
|
|
|
iCount = 0;
|
|
|
|
// Open a connection to terminal services and get the number of sessions.
|
|
|
|
hServer = WinStationOpenServerW(reinterpret_cast<WCHAR*>(SERVERNAME_CURRENT));
|
|
if (hServer != NULL)
|
|
{
|
|
TS_COUNTER tsCounters[2] = {0};
|
|
|
|
tsCounters[0].counterHead.dwCounterID = TERMSRV_CURRENT_DISC_SESSIONS;
|
|
tsCounters[1].counterHead.dwCounterID = TERMSRV_CURRENT_ACTIVE_SESSIONS;
|
|
|
|
if (WinStationGetTermSrvCountersValue(hServer, ARRAYSIZE(tsCounters), tsCounters))
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAYSIZE(tsCounters); i++)
|
|
{
|
|
if (tsCounters[i].counterHead.bResult)
|
|
{
|
|
iCount += tsCounters[i].dwValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
(BOOLEAN)WinStationCloseServer(hServer);
|
|
}
|
|
|
|
// Return result.
|
|
|
|
return(iCount);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::CheckDomainMembership
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Checks the consistency of domain membership and allowing
|
|
// multiple TS sessions. The check is only for domain membership
|
|
// true not false.
|
|
//
|
|
// History: 2000-04-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CSystemSettings::CheckDomainMembership (void)
|
|
|
|
{
|
|
if (IsDomainMember() && !IsForceFriendlyUI() && IsProfessionalTerminalServer())
|
|
{
|
|
TBOOL(EnableFriendlyUI(false));
|
|
(BOOL)EnableMultipleUsers(false);
|
|
}
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::AdjustFUSCompatibilityServiceState
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Turns on or off the FUS compatbility service based on the
|
|
// FUS configuration.
|
|
//
|
|
// History: 2001-02-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
DWORD WINAPI CSystemSettings::AdjustFUSCompatibilityServiceState (void *pV)
|
|
|
|
{
|
|
UNREFERENCED_PARAMETER(pV);
|
|
|
|
#ifdef _X86_
|
|
|
|
if (IsWorkStationProduct())
|
|
{
|
|
bool fMultipleUsersEnabled;
|
|
SC_HANDLE hSCManager;
|
|
|
|
fMultipleUsersEnabled = IsMultipleUsersEnabled();
|
|
|
|
// Connect to the service control manager.
|
|
|
|
hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (hSCManager != NULL)
|
|
{
|
|
SC_HANDLE hSCService;
|
|
|
|
// Open the "FastUserSwitchingCompatibility" service.
|
|
|
|
hSCService = OpenService(hSCManager,
|
|
TEXT("FastUserSwitchingCompatibility"),
|
|
SERVICE_START | SERVICE_STOP | SERVICE_QUERY_STATUS);
|
|
if (hSCService != NULL)
|
|
{
|
|
SERVICE_STATUS serviceStatus;
|
|
|
|
// Find out the status of the service.
|
|
|
|
if (QueryServiceStatus(hSCService, &serviceStatus) != FALSE)
|
|
{
|
|
if (fMultipleUsersEnabled && (serviceStatus.dwCurrentState == SERVICE_STOPPED))
|
|
{
|
|
|
|
// If it's supposed to be started and it is not
|
|
// running then start the service. This can fail
|
|
// because the service is set to disabled. Ignore it.
|
|
|
|
(BOOL)StartService(hSCService, 0, NULL);
|
|
}
|
|
else if (!fMultipleUsersEnabled && (serviceStatus.dwCurrentState == SERVICE_RUNNING))
|
|
{
|
|
|
|
// If it's supposed to be stopped and it is
|
|
// running then stop the service.
|
|
|
|
TBOOL(ControlService(hSCService, SERVICE_CONTROL_STOP, &serviceStatus));
|
|
}
|
|
}
|
|
TBOOL(CloseServiceHandle(hSCService));
|
|
}
|
|
TBOOL(CloseServiceHandle(hSCManager));
|
|
}
|
|
}
|
|
|
|
#endif /* _X86_ */
|
|
|
|
return(0);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::GetEffectiveInteger
|
|
//
|
|
// Arguments: hKey = HKEY to read.
|
|
// pszKeyName = Subkey name to read.
|
|
// pszPolicyKeyName = Policy subkey name to read.
|
|
// pszValueName = Value name in subkey to read.
|
|
// iResult = int result.
|
|
//
|
|
// Returns: LONG
|
|
//
|
|
// Purpose: Reads the effective setting from the registry. The effective
|
|
// setting is whatever the user chooses as the regular setting
|
|
// overriden by policy. The policy setting is always returned if
|
|
// present.
|
|
//
|
|
// History: 2000-04-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
LONG CSystemSettings::GetEffectiveInteger (HKEY hKey, const TCHAR *pszKeyName, const TCHAR *pszPolicyKeyName, const TCHAR *pszValueName, int& iResult)
|
|
|
|
{
|
|
CRegKey regKey;
|
|
|
|
// Start with a typical initialized value.
|
|
|
|
iResult = 0;
|
|
|
|
// First check the regular location.
|
|
|
|
if (ERROR_SUCCESS == regKey.Open(hKey,
|
|
pszKeyName,
|
|
KEY_QUERY_VALUE))
|
|
{
|
|
(LONG)regKey.GetInteger(pszValueName, iResult);
|
|
}
|
|
|
|
// Then check the policy.
|
|
|
|
if (ERROR_SUCCESS == regKey.Open(hKey,
|
|
pszPolicyKeyName,
|
|
KEY_QUERY_VALUE))
|
|
{
|
|
(LONG)regKey.GetInteger(pszValueName, iResult);
|
|
}
|
|
|
|
// Always return ERROR_SUCCESS.
|
|
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::GetEffectivePath
|
|
//
|
|
// Arguments: hKey = HKEY to read.
|
|
// pszKeyName = Subkey name to read.
|
|
// pszPolicyKeyName = Policy subkey name to read.
|
|
// pszValueName = Value name in subkey to read.
|
|
// pszPath = TCHAR array to receive effect path.
|
|
//
|
|
// Returns: LONG
|
|
//
|
|
// Purpose: Reads the effective setting from the registry. The effective
|
|
// setting is whatever the user chooses as the regular setting
|
|
// overriden by policy. The policy setting is always returned if
|
|
// present. The buffer must be at least MAX_PATH characters.
|
|
//
|
|
// History: 2000-04-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
LONG CSystemSettings::GetEffectivePath (HKEY hKey, const TCHAR *pszKeyName, const TCHAR *pszPolicyKeyName, const TCHAR *pszValueName, TCHAR *pszPath)
|
|
|
|
{
|
|
LONG lErrorCode;
|
|
|
|
if (IsBadWritePtr(pszPath, MAX_PATH * sizeof(TCHAR)))
|
|
{
|
|
lErrorCode = ERROR_INVALID_PARAMETER;
|
|
}
|
|
else
|
|
{
|
|
LONG lPolicyErrorCode;
|
|
CRegKey regKey;
|
|
|
|
// Start with a typical initialized value.
|
|
|
|
*pszPath = TEXT('\0');
|
|
|
|
// First check the regular location.
|
|
|
|
lErrorCode = regKey.Open(hKey,
|
|
pszKeyName,
|
|
KEY_QUERY_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
lErrorCode = regKey.GetPath(pszValueName,
|
|
pszPath);
|
|
}
|
|
|
|
// Then check the policy.
|
|
|
|
lPolicyErrorCode = regKey.Open(hKey,
|
|
pszPolicyKeyName,
|
|
KEY_QUERY_VALUE);
|
|
if (ERROR_SUCCESS == lPolicyErrorCode)
|
|
{
|
|
lPolicyErrorCode = regKey.GetPath(pszValueName,
|
|
pszPath);
|
|
}
|
|
|
|
// If either error code is ERROR_SUCCESS then return that
|
|
// error code. Otherwise return the non policy error code.
|
|
|
|
if ((ERROR_SUCCESS == lErrorCode) || (ERROR_SUCCESS == lPolicyErrorCode))
|
|
{
|
|
lErrorCode = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
return(lErrorCode);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsProfessionalTerminalServer
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether this machine is a personal terminal server.
|
|
// That is workstation with single user TS.
|
|
//
|
|
// History: 2000-08-09 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsProfessionalTerminalServer (void)
|
|
|
|
{
|
|
OSVERSIONINFOEX osVersion;
|
|
|
|
ZeroMemory(&osVersion, sizeof(osVersion));
|
|
osVersion.dwOSVersionInfoSize = sizeof(osVersion);
|
|
return((GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&osVersion)) != FALSE) &&
|
|
(osVersion.wProductType == VER_NT_WORKSTATION) &&
|
|
((osVersion.wSuiteMask & VER_SUITE_PERSONAL) == 0) &&
|
|
((osVersion.wSuiteMask & VER_SUITE_SINGLEUSERTS) != 0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsMicrosoftGINA
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether the current GINA is the Microsoft GINA.
|
|
//
|
|
// History: 2001-01-05 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsMicrosoftGINA (void)
|
|
|
|
{
|
|
bool fResult;
|
|
LONG lErrorCode;
|
|
TCHAR szGinaDLL[MAX_PATH];
|
|
CRegKey regKey;
|
|
|
|
fResult = true;
|
|
lErrorCode = regKey.Open(HKEY_LOCAL_MACHINE,
|
|
s_szWinlogonKeyName,
|
|
KEY_QUERY_VALUE);
|
|
if (ERROR_SUCCESS == lErrorCode)
|
|
{
|
|
fResult = (regKey.GetString(TEXT("GinaDLL"), szGinaDLL, ARRAYSIZE(szGinaDLL)) != ERROR_SUCCESS);
|
|
}
|
|
return(fResult);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CSystemSettings::IsSCMTerminalServicesDisabled
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether terminal services is disabled via the service
|
|
// control manager.
|
|
//
|
|
// History: 2001-04-13 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CSystemSettings::IsSCMTerminalServicesDisabled (void)
|
|
|
|
{
|
|
bool fResult;
|
|
SC_HANDLE hSCManager;
|
|
|
|
fResult = false;
|
|
hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (hSCManager != NULL)
|
|
{
|
|
SC_HANDLE hSCService;
|
|
|
|
hSCService = OpenService(hSCManager,
|
|
TEXT("TermService"),
|
|
SERVICE_QUERY_CONFIG);
|
|
if (hSCService != NULL)
|
|
{
|
|
DWORD dwBytesNeeded;
|
|
QUERY_SERVICE_CONFIG *pQueryServiceConfig;
|
|
|
|
(BOOL)QueryServiceConfig(hSCService, NULL, 0, &dwBytesNeeded);
|
|
pQueryServiceConfig = static_cast<QUERY_SERVICE_CONFIG*>(LocalAlloc(LMEM_FIXED, dwBytesNeeded));
|
|
if (pQueryServiceConfig != NULL)
|
|
{
|
|
fResult = ((QueryServiceConfig(hSCService,
|
|
pQueryServiceConfig,
|
|
dwBytesNeeded,
|
|
&dwBytesNeeded) != FALSE) &&
|
|
(pQueryServiceConfig->dwStartType == SERVICE_DISABLED));
|
|
(HLOCAL)LocalFree(pQueryServiceConfig);
|
|
}
|
|
TBOOL(CloseServiceHandle(hSCService));
|
|
}
|
|
TBOOL(CloseServiceHandle(hSCManager));
|
|
}
|
|
return(fResult);
|
|
}
|
|
|