Leaked source code of windows server 2003
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.
 
 
 
 
 
 

2723 lines
61 KiB

/**MOD+**********************************************************************/
/* Module: advset.cpp */
/* */
/* Class : CMstscAdvSettings */
/* */
/* Purpose: Implements advanced settings for RDP ActiveX control */
/* */
/* Copyright(C) Microsoft Corporation 1999-2000 */
/* */
/* Author : Nadim Abdo (nadima) */
/****************************************************************************/
#include "stdafx.h"
#include "advset.h"
#include "atlwarn.h"
#include "securedset.h"
BEGIN_EXTERN_C
#define TRC_GROUP TRC_GROUP_UI
#define TRC_FILE "advset"
#include <atrcapi.h>
END_EXTERN_C
CMstscAdvSettings::CMstscAdvSettings()
{
m_pUI=NULL;
m_bLockedForWrite=FALSE;
_pAxControl = NULL;
//
// Default is to make self safe for scripting
//
m_bMakeSafeForScripting = TRUE;
}
CMstscAdvSettings::~CMstscAdvSettings()
{
}
BOOL CMstscAdvSettings::SetUI(CUI* pUI)
{
ATLASSERT(pUI);
if(!pUI)
{
return FALSE;
}
m_pUI = pUI;
return TRUE;
}
//
// SmoothScroll property
//
STDMETHODIMP CMstscAdvSettings::put_SmoothScroll(LONG smoothScroll)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.smoothScrolling = smoothScroll != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_SmoothScroll(LONG* psmoothScroll)
{
ATLASSERT(m_pUI);
if(!psmoothScroll)
{
return E_POINTER;
}
*psmoothScroll = m_pUI->_UI.smoothScrolling;
return S_OK;
}
//
// AcceleratorPassthrough property
//
STDMETHODIMP CMstscAdvSettings::put_AcceleratorPassthrough(LONG acceleratorPassthrough)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.acceleratorCheckState = acceleratorPassthrough != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_AcceleratorPassthrough(LONG* pacceleratorPassthrough)
{
ATLASSERT(m_pUI);
if(!pacceleratorPassthrough)
{
return E_POINTER;
}
*pacceleratorPassthrough = m_pUI->_UI.acceleratorCheckState;
return S_OK;
}
//
// ShadowBitmap property
//
STDMETHODIMP CMstscAdvSettings::put_ShadowBitmap(LONG shadowBitmap)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.shadowBitmapEnabled = shadowBitmap != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_ShadowBitmap(LONG* pshadowBitmap)
{
ATLASSERT(m_pUI);
if(!pshadowBitmap)
{
return E_POINTER;
}
*pshadowBitmap = m_pUI->_UI.shadowBitmapEnabled;
return S_OK;
}
//
// TransportType property
//
STDMETHODIMP CMstscAdvSettings::put_TransportType(LONG transportType)
{
HRESULT hr = E_FAIL;
if(GetLockedForWrite())
{
return E_FAIL;
}
//
// Validate - property is redundant today because we only have
// one allowed transport but we keep it for future extensibility
//
if (transportType == UI_TRANSPORT_TYPE_TCP) {
m_pUI->_UI.transportType = (DCUINT16)transportType;
hr = S_OK;
}
else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_TransportType(LONG* ptransportType)
{
ATLASSERT(m_pUI);
if(!ptransportType)
{
return E_POINTER;
}
*ptransportType = m_pUI->_UI.transportType;
return S_OK;
}
//
// SasSequence property
//
STDMETHODIMP CMstscAdvSettings::put_SasSequence(LONG sasSequence)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.sasSequence = (DCUINT16)sasSequence;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_SasSequence(LONG* psasSequence)
{
ATLASSERT(m_pUI);
if(!psasSequence)
{
return E_POINTER;
}
*psasSequence = m_pUI->_UI.sasSequence;
return S_OK;
}
//
// EncryptionEnabled property
//
STDMETHODIMP CMstscAdvSettings::put_EncryptionEnabled(LONG encryptionEnabled)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.encryptionEnabled = encryptionEnabled != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_EncryptionEnabled(LONG* pencryptionEnabled)
{
ATLASSERT(m_pUI);
if(!pencryptionEnabled)
{
return E_POINTER;
}
*pencryptionEnabled = m_pUI->_UI.encryptionEnabled;
return S_OK;
}
//
// DedicatedTerminal property
//
STDMETHODIMP CMstscAdvSettings::put_DedicatedTerminal(LONG dedicatedTerminal)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.dedicatedTerminal = dedicatedTerminal != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_DedicatedTerminal(LONG* pdedicatedTerminal)
{
ATLASSERT(m_pUI);
if(!pdedicatedTerminal)
{
return E_POINTER;
}
*pdedicatedTerminal = m_pUI->_UI.dedicatedTerminal;
return S_OK;
}
//
// MCSPort property
//
STDMETHODIMP CMstscAdvSettings::put_RDPPort(LONG RDPPort)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
if(RDPPort < 0 || RDPPort > 65535)
{
return E_INVALIDARG;
}
m_pUI->_UI.MCSPort = (DCUINT16)RDPPort;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_RDPPort(LONG* pRDPPort)
{
if(!pRDPPort)
{
return E_POINTER;
}
*pRDPPort = m_pUI->_UI.MCSPort;
return S_OK;
}
//
// EnableMouse property
//
STDMETHODIMP CMstscAdvSettings::put_EnableMouse(LONG enableMouse)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_EnableMouse(LONG* penableMouse)
{
//
// Deprecated
//
return S_FALSE;
}
//
// DisableCtrlAltDel property
//
STDMETHODIMP CMstscAdvSettings::put_DisableCtrlAltDel(LONG disableCtrlAltDel)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.fDisableCtrlAltDel = disableCtrlAltDel != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_DisableCtrlAltDel(LONG* pdisableCtrlAltDel)
{
ATLASSERT(m_pUI);
if(!pdisableCtrlAltDel)
{
return E_POINTER;
}
*pdisableCtrlAltDel = m_pUI->_UI.fDisableCtrlAltDel;
return S_OK;
}
//
// EnableWindowsKey property
//
STDMETHODIMP CMstscAdvSettings::put_EnableWindowsKey(LONG enableWindowsKey)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.fEnableWindowsKey = enableWindowsKey != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_EnableWindowsKey(LONG* penableWindowsKey)
{
ATLASSERT(m_pUI);
if(!penableWindowsKey)
{
return E_POINTER;
}
*penableWindowsKey = m_pUI->_UI.fEnableWindowsKey;
return S_OK;
}
//
// DoubleClickDetect property
//
STDMETHODIMP CMstscAdvSettings::put_DoubleClickDetect(LONG doubleClickDetect)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.fDoubleClickDetect = doubleClickDetect != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_DoubleClickDetect(LONG* pdoubleClickDetect)
{
ATLASSERT(m_pUI);
if(!pdoubleClickDetect)
{
return E_POINTER;
}
*pdoubleClickDetect = m_pUI->_UI.fDoubleClickDetect;
return S_OK;
}
//
// MaximizeShell property
//
STDMETHODIMP CMstscAdvSettings::put_MaximizeShell(LONG maximizeShell)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.fMaximizeShell = maximizeShell != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_MaximizeShell(LONG* pmaximizeShell)
{
ATLASSERT(m_pUI);
if(!pmaximizeShell)
{
return E_POINTER;
}
*pmaximizeShell = m_pUI->_UI.fMaximizeShell;
return S_OK;
}
//
// HotKeyFullScreen property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyFullScreen(LONG hotKeyFullScreen)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.fullScreen = hotKeyFullScreen;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyFullScreen(LONG* photKeyFullScreen)
{
ATLASSERT(m_pUI);
if(!photKeyFullScreen)
{
return E_POINTER;
}
*photKeyFullScreen = m_pUI->_UI.hotKey.fullScreen;
return S_OK;
}
//
// HotKeyCtrlEsc property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyCtrlEsc(LONG hotKeyCtrlEsc)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.ctrlEsc = hotKeyCtrlEsc;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyCtrlEsc(LONG* photKeyCtrlEsc)
{
ATLASSERT(m_pUI);
if(!photKeyCtrlEsc)
{
return E_POINTER;
}
*photKeyCtrlEsc = m_pUI->_UI.hotKey.ctrlEsc;
return S_OK;
}
//
// HotKeyAltEsc property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyAltEsc(LONG hotKeyAltEsc)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.altEsc = hotKeyAltEsc;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyAltEsc(LONG* photKeyAltEsc)
{
ATLASSERT(m_pUI);
if(!photKeyAltEsc)
{
return E_POINTER;
}
*photKeyAltEsc = m_pUI->_UI.hotKey.altEsc;
return S_OK;
}
//
// HotKeyAltTab property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyAltTab(LONG hotKeyAltTab)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.altTab = hotKeyAltTab;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyAltTab(LONG* photKeyAltTab)
{
ATLASSERT(m_pUI);
if(!photKeyAltTab)
{
return E_POINTER;
}
*photKeyAltTab = m_pUI->_UI.hotKey.altTab;
return S_OK;
}
//
// HotKeyAltShiftTab property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyAltShiftTab(LONG hotKeyAltShiftTab)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.altShifttab = hotKeyAltShiftTab;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyAltShiftTab(LONG* photKeyAltShiftTab)
{
ATLASSERT(m_pUI);
if(!photKeyAltShiftTab)
{
return E_POINTER;
}
*photKeyAltShiftTab = m_pUI->_UI.hotKey.altShifttab;
return S_OK;
}
//
// HotKeyAltSpace property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyAltSpace(LONG hotKeyAltSpace)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.altSpace = hotKeyAltSpace;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyAltSpace(LONG* photKeyAltSpace)
{
ATLASSERT(m_pUI);
if(!photKeyAltSpace)
{
return E_POINTER;
}
*photKeyAltSpace = m_pUI->_UI.hotKey.altSpace;
return S_OK;
}
//
// HotKeyCtrlAltDel property
//
STDMETHODIMP CMstscAdvSettings::put_HotKeyCtrlAltDel(LONG hotKeyCtrlAltDel)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.hotKey.ctlrAltdel = hotKeyCtrlAltDel;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_HotKeyCtrlAltDel(LONG* photKeyCtrlAltDel)
{
ATLASSERT(m_pUI);
if(!photKeyCtrlAltDel)
{
return E_POINTER;
}
*photKeyCtrlAltDel = m_pUI->_UI.hotKey.ctlrAltdel;
return S_OK;
}
//
// Compress property
//
STDMETHODIMP CMstscAdvSettings::put_Compress(LONG compress)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->UI_SetCompress(compress != 0);
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_Compress(LONG* pcompress)
{
ATLASSERT(m_pUI);
if(!pcompress)
{
return E_POINTER;
}
*pcompress = m_pUI->UI_GetCompress();
return S_OK;
}
//
// BitmapPeristence property
//
STDMETHODIMP CMstscAdvSettings::put_BitmapPeristence(LONG bitmapPeristence)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.fBitmapPersistence = (bitmapPeristence != 0);
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_BitmapPeristence(LONG* pbitmapPeristence)
{
ATLASSERT(m_pUI);
if(!pbitmapPeristence)
{
return E_POINTER;
}
*pbitmapPeristence = m_pUI->_UI.fBitmapPersistence;
return S_OK;
}
//
// BitmapPersistence property
//
STDMETHODIMP CMstscAdvSettings::put_BitmapPersistence(LONG bitmapPersistence)
{
//Call on older incorrectly spelled property
return put_BitmapPeristence(bitmapPersistence);
}
STDMETHODIMP CMstscAdvSettings::get_BitmapPersistence(LONG* pbitmapPersistence)
{
//Call on older incorrectly spelled property
return get_BitmapPeristence(pbitmapPersistence);
}
//
////////////////////////////////////////////////////////////////////////////////////
//
// orderDrawThreshold property
//
STDMETHODIMP CMstscAdvSettings::put_orderDrawThreshold(LONG orderDrawThreshold)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_orderDrawThreshold(LONG* porderDrawThreshold)
{
//
// Deprecated
//
return S_FALSE;
}
//
// BitmapCacheSize property
//
STDMETHODIMP CMstscAdvSettings::put_BitmapCacheSize(LONG bitmapCacheSize)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
#ifndef OS_WINCE
if (bitmapCacheSize > 0 && bitmapCacheSize <= TSC_MAX_BITMAPCACHESIZE)
#else //bitmap cache size is measured in KB and TSC_MAX_BITMAPCACHESIZE is in MB
if (bitmapCacheSize > 0 && bitmapCacheSize <= TSC_MAX_BITMAPCACHESIZE*1024)
#endif
{
m_pUI->_UI.RegBitmapCacheSize = bitmapCacheSize;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
STDMETHODIMP CMstscAdvSettings::get_BitmapCacheSize(LONG* pbitmapCacheSize)
{
ATLASSERT(m_pUI);
if(!pbitmapCacheSize)
{
return E_POINTER;
}
*pbitmapCacheSize = m_pUI->_UI.RegBitmapCacheSize;
return S_OK;
}
//
// BitmapVirtualCacheSize property
//
// TSAC's v1.0 only property for cache file size.
// In whistler applies to 8bpp cache file
// See BitmapVirtualCache16BppSize/24BppSize methods
//
STDMETHODIMP CMstscAdvSettings::put_BitmapVirtualCacheSize(
LONG bitmapVirtualCacheSize)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
if (bitmapVirtualCacheSize > 0 &&
bitmapVirtualCacheSize <= TSC_MAX_BITMAPCACHESIZE)
{
m_pUI->_UI.RegBitmapVirtualCache8BppSize = bitmapVirtualCacheSize;
}
else
{
return E_INVALIDARG;
}
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_BitmapVirtualCacheSize(
LONG* pbitmapVirtualCacheSize)
{
if(!pbitmapVirtualCacheSize)
{
return E_POINTER;
}
*pbitmapVirtualCacheSize = m_pUI->_UI.RegBitmapVirtualCache8BppSize;
return S_OK;
}
//
// ScaleBitmapCachesByBPP property
//
STDMETHODIMP CMstscAdvSettings::put_ScaleBitmapCachesByBPP(LONG bScale)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_ScaleBitmapCachesByBPP(LONG *pbScale)
{
//
// Deprecated
//
return S_FALSE;
}
//
// NumBitmapCaches property
//
STDMETHODIMP CMstscAdvSettings::put_NumBitmapCaches(LONG numBitmapCaches)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_NumBitmapCaches(LONG* pnumBitmapCaches)
{
//
// Deprecated
//
return S_FALSE;
}
//
// CachePersistenceActive property
//
STDMETHODIMP CMstscAdvSettings::put_CachePersistenceActive(LONG cachePersistenceActive)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.RegPersistenceActive = cachePersistenceActive != 0;
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_CachePersistenceActive(LONG* pcachePersistenceActive)
{
ATLASSERT(m_pUI);
if(!pcachePersistenceActive)
{
return E_POINTER;
}
*pcachePersistenceActive = m_pUI->_UI.RegPersistenceActive;
return S_OK;
}
//
// brushSupportLevel property
//
STDMETHODIMP CMstscAdvSettings::put_brushSupportLevel(LONG brushSupportLevel)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_brushSupportLevel(LONG* pbrushSupportLevel)
{
//
// Deprecated
//
return S_FALSE;
}
//
// put_PersistCacheDirectory property (Set only)
//
STDMETHODIMP CMstscAdvSettings::put_PersistCacheDirectory(BSTR PersistCacheDirectory)
{
//
// Deprecated
//
return S_FALSE;
}
//
// minInputSendInterval property
//
STDMETHODIMP CMstscAdvSettings::put_minInputSendInterval(LONG minInputSendInterval)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_minInputSendInterval(LONG* pminInputSendInterval)
{
//
// Deprecated
//
return S_FALSE;
}
//
// InputEventsAtOnce property
//
STDMETHODIMP CMstscAdvSettings::put_InputEventsAtOnce(LONG inputEventsAtOnce)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_InputEventsAtOnce(LONG* pinputEventsAtOnce)
{
//
// Deprecated
//
return S_FALSE;
}
//
// maxEventCount property
//
STDMETHODIMP CMstscAdvSettings::put_maxEventCount(LONG maxEventCount)
{
//
// Deprecated
//
return S_FALSE;
}
STDMETHODIMP CMstscAdvSettings::get_maxEventCount(LONG* pmaxEventCount)
{
//
// Deprecated
//
return S_FALSE;
}
//
// keepAliveInterval property
//
STDMETHODIMP CMstscAdvSettings::put_keepAliveInterval(LONG keepAliveInterval)
{
HRESULT hr;
if(GetLockedForWrite()) {
return E_FAIL;
}
if (keepAliveInterval >= MIN_KEEP_ALIVE_INTERVAL ||
KEEP_ALIVE_INTERVAL_OFF == keepAliveInterval) {
m_pUI->_UI.keepAliveInterval = keepAliveInterval;
hr = S_OK;
}
else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_keepAliveInterval(LONG* pkeepAliveInterval)
{
ATLASSERT(m_pUI);
if(!pkeepAliveInterval)
{
return E_POINTER;
}
*pkeepAliveInterval = m_pUI->_UI.keepAliveInterval;
return S_OK;
}
//
// allowBackgroundInput property
//
STDMETHODIMP CMstscAdvSettings::put_allowBackgroundInput(LONG allowBackgroundInput)
{
if (!m_bMakeSafeForScripting) {
if(GetLockedForWrite()) {
return E_FAIL;
}
m_pUI->_UI.allowBackgroundInput = allowBackgroundInput != 0;
return S_OK;
}
else {
//
// Deprecated when SFS
//
return S_FALSE;
}
}
STDMETHODIMP CMstscAdvSettings::get_allowBackgroundInput(LONG* pallowBackgroundInput)
{
if (!m_bMakeSafeForScripting) {
if(!pallowBackgroundInput) {
return E_POINTER;
}
*pallowBackgroundInput = m_pUI->_UI.allowBackgroundInput;
return S_OK;
}
else {
//
// Deprecated when SFS
//
return S_FALSE;
}
}
//
// KeyBoardLayoutStr property (put only)
//
STDMETHODIMP CMstscAdvSettings::put_KeyBoardLayoutStr(BSTR KeyBoardLayoutStr)
{
HRESULT hr = E_FAIL;
if(GetLockedForWrite())
{
return E_FAIL;
}
if (KeyBoardLayoutStr) {
hr = CUT::StringPropPut(m_pUI->_UI.szKeyBoardLayoutStr,
SIZE_TCHARS(m_pUI->_UI.szKeyBoardLayoutStr),
KeyBoardLayoutStr);
}
else {
m_pUI->_UI.szKeyBoardLayoutStr[0] = NULL;
hr = S_OK;
}
return hr;
}
//
// shutdownTimeout property
//
STDMETHODIMP CMstscAdvSettings::put_shutdownTimeout(LONG shutdownTimeout)
{
HRESULT hr;
if(GetLockedForWrite()) {
return E_FAIL;
}
if (shutdownTimeout < MAX_TIMEOUT_SECONDS) {
m_pUI->_UI.shutdownTimeout = shutdownTimeout;
hr = S_OK;
}
else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_shutdownTimeout(LONG* pshutdownTimeout)
{
ATLASSERT(m_pUI);
if(!pshutdownTimeout)
{
return E_POINTER;
}
*pshutdownTimeout = m_pUI->_UI.shutdownTimeout;
return S_OK;
}
//
// overallConnectionTimeout property
//
STDMETHODIMP CMstscAdvSettings::put_overallConnectionTimeout(LONG overallConnectionTimeout)
{
HRESULT hr;
if(GetLockedForWrite()) {
return E_FAIL;
}
if (overallConnectionTimeout < MAX_TIMEOUT_SECONDS) {
m_pUI->_UI.connectionTimeOut = overallConnectionTimeout;
hr = S_OK;
}
else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_overallConnectionTimeout(LONG* poverallConnectionTimeout)
{
ATLASSERT(m_pUI);
if(!poverallConnectionTimeout)
{
return E_POINTER;
}
*poverallConnectionTimeout = m_pUI->_UI.connectionTimeOut;
return S_OK;
}
//
// singleConnectionTimeout property
//
STDMETHODIMP CMstscAdvSettings::put_singleConnectionTimeout(LONG singleConnectionTimeout)
{
HRESULT hr;
if(GetLockedForWrite()) {
return E_FAIL;
}
if (singleConnectionTimeout < MAX_TIMEOUT_SECONDS) {
m_pUI->_UI.singleTimeout = singleConnectionTimeout;
hr = S_OK;
}
else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_singleConnectionTimeout(LONG* psingleConnectionTimeout)
{
ATLASSERT(m_pUI);
if(!psingleConnectionTimeout)
{
return E_POINTER;
}
*psingleConnectionTimeout = m_pUI->_UI.singleTimeout;
return S_OK;
}
//
// KeyboardType property
//
STDMETHODIMP CMstscAdvSettings::put_KeyboardType(LONG keyboardType)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(keyboardType);
return E_NOTIMPL;
#else
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.winceKeyboardType = keyboardType;
return S_OK;
#endif
}
STDMETHODIMP CMstscAdvSettings::get_KeyboardType(LONG* pkeyboardType)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(pkeyboardType);
return E_NOTIMPL;
#else
if(!pkeyboardType)
{
return E_POINTER;
}
*pkeyboardType = m_pUI->_UI.winceKeyboardType;
return S_OK;
#endif
}
//
// KeyboardSubType property
//
STDMETHODIMP CMstscAdvSettings::put_KeyboardSubType(LONG keyboardSubType)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(keyboardSubType);
return E_NOTIMPL;
#else
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.winceKeyboardSubType = keyboardSubType;
return S_OK;
#endif
}
STDMETHODIMP CMstscAdvSettings::get_KeyboardSubType(LONG* pkeyboardSubType)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(pkeyboardSubType);
return E_NOTIMPL;
#else
if(!pkeyboardSubType)
{
return E_POINTER;
}
*pkeyboardSubType = m_pUI->_UI.winceKeyboardSubType;
return S_OK;
#endif
}
//
// KeyboardFunctionKey property
//
STDMETHODIMP CMstscAdvSettings::put_KeyboardFunctionKey(LONG keyboardFunctionKey)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(keyboardFunctionKey);
return E_NOTIMPL;
#else
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.winceKeyboardFunctionKey = keyboardFunctionKey;
return S_OK;
#endif
}
STDMETHODIMP CMstscAdvSettings::get_KeyboardFunctionKey(LONG* pkeyboardFunctionKey)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(pkeyboardFunctionKey);
return E_NOTIMPL;
#else
if(!pkeyboardFunctionKey)
{
return E_POINTER;
}
*pkeyboardFunctionKey = m_pUI->_UI.winceKeyboardFunctionKey;
return S_OK;
#endif
}
//
// WinceFixedPalette property
//
STDMETHODIMP CMstscAdvSettings::put_WinceFixedPalette(LONG WinceFixedPalette)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(WinceFixedPalette);
return E_NOTIMPL;
#else
//
// Fix for WINCE
//
return E_NOTIMPL;
#endif
}
STDMETHODIMP CMstscAdvSettings::get_WinceFixedPalette(LONG* pWinceFixedPalette)
{
#ifndef OS_WINCE
UNREFERENCED_PARAMETER(pWinceFixedPalette);
return E_NOTIMPL;
#else
//
// Fix for WINCE
//
return E_NOTIMPL;
#endif
}
//
// PluginDlls
//
STDMETHODIMP CMstscAdvSettings::put_PluginDlls(BSTR PluginDlls)
{
DC_BEGIN_FN("put_PluginDlls");
if(GetLockedForWrite())
{
return E_FAIL;
}
if (PluginDlls)
{
LPTSTR szPlugins = (LPTSTR)(PluginDlls);
//
//SECURITY!!!
//If we are safe for scripting, the plugin list
//must be verified to ensure it contains just dll names (no paths)
//Then a system defined base path is prepended to each dll name
//
if(m_bMakeSafeForScripting)
{
BOOL bIsSecureDllList = IsSecureDllList(szPlugins);
if(bIsSecureDllList)
{
LPTSTR szExplicitPathDllList =
CreateExplicitPathList(szPlugins);
if(szExplicitPathDllList)
{
m_pUI->UI_SetVChanAddinList(szExplicitPathDllList);
LocalFree(szExplicitPathDllList);
}
else
{
//
// Unable to create an explicit path list
//
TRC_ERR((TB,_T("CreateExplicitPathList failed for %s"),
szPlugins));
return E_FAIL;
}
}
else
{
TRC_ERR((TB,_T("IsSecureDllList failed for %s"), szPlugins));
return E_FAIL;
}
}
else
{
//
// Don't need to be safe for an untrusted caller
// just pass in the vcahn plugin list directly to the core
//
m_pUI->UI_SetVChanAddinList( szPlugins);
}
}
else
{
m_pUI->UI_SetVChanAddinList(NULL);
}
DC_END_FN();
return S_OK;
}
//
// IsSecureDllList
// determines if the CSV list of dlls in szDllList is secure
// the criteria we use are
// only dll names can be specified. NO PATHS, NO NETWORK SHARES.
//
BOOL CMstscAdvSettings::IsSecureDllList(LPCTSTR szDllList)
{
ATLASSERT(szDllList);
if(szDllList)
{
//
// The only allowed values are alphanumeric characters
// '.' and ','.
//
LPCTSTR psz = szDllList;
while (*psz) {
if (!(iswalnum(*psz) || *psz == _T(',') || *psz == _T('.'))) {
return FALSE;
}
psz++;
}
//
// Check for evil characters '/\%'
//
if(_tcspbrk( szDllList, TEXT("/\\%")))
{
return FALSE;
}
//
// Now check for '..'
//
if(_tcsstr( szDllList, TEXT("..")))
{
return FALSE;
}
return TRUE;
}
else
{
return FALSE;
}
}
#define TS_VDLLPATH_KEYNAME TEXT("SOFTWARE\\Microsoft\\Terminal Server Client")
#define TS_VDLLPATH TEXT("vdllpath")
//
// CreateExplicitPathList
// params:
// szDllList - CSV list of dll names
// returns:
// CSV list of Dlls with explicit paths. Or NULL on error.
// ******CALLER MUST FREE RETURN STRING****
//
// Path prefix is taken from registry, or default value of system32
// if no registry setting is specified
//
//
LPTSTR CMstscAdvSettings::CreateExplicitPathList(LPCTSTR szDllList)
{
HKEY hKey;
LONG retVal;
BOOL bGotPathPrefix = FALSE;
int i;
LPTSTR szExplicitPathList = NULL;
LPTSTR szDllListTmp = NULL;
HRESULT hr;
TCHAR szPathPrefix[MAX_PATH];
if(!szDllList || !*szDllList)
{
return NULL;
}
//
// Try to get a path prefix from the registry
//
retVal = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TS_VDLLPATH_KEYNAME,
0,
KEY_READ,
&hKey);
if(ERROR_SUCCESS == retVal)
{
DWORD cbData = sizeof(szPathPrefix);
DWORD dwType;
retVal = RegQueryValueEx(hKey, TS_VDLLPATH, NULL, &dwType,
(PBYTE)&szPathPrefix,
&cbData);
if(ERROR_SUCCESS == retVal && REG_SZ == dwType)
{
//
// validate that the vdllpath does not contain any '\\'
// we don't just check the first char because someone
// could just pad with whitespace.
// This is done because network shares are not allowed
// for the dll path prefix
//
if((cbData >= 2 * sizeof(TCHAR)) &&
(_tcsstr( szPathPrefix, TEXT("\\\\"))))
{
//security violation, return failure
return NULL;
}
else
{
bGotPathPrefix = TRUE;
}
}
RegCloseKey(hKey);
}
if(!bGotPathPrefix)
{
#ifndef OS_WINCE
//Use default value of the system32 directory
if(!GetSystemDirectory( szPathPrefix, sizeof(szPathPrefix)/sizeof(TCHAR)))
{
return NULL;
}
else
{
bGotPathPrefix = TRUE;
}
#else
//CE doesn't have a GetSystemDirectory directory
return NULL;
#endif
}
int cbDllListLen = _tcslen(szDllList) * sizeof(TCHAR) + sizeof(TCHAR);
szDllListTmp = (LPTSTR) LocalAlloc(LPTR, cbDllListLen);
if(NULL == szDllListTmp)
{
return NULL;
}
//
// szDllListTmp is allocated large enough to hold
// the szDllList so no need to length validate the copy
//
hr = StringCbCopy(szDllListTmp, cbDllListLen, szDllList);
if (FAILED(hr)) {
LocalFree(szDllListTmp);
return NULL;
}
int countDlls = 0;
LPTSTR DllNames[CHANNEL_MAX_COUNT];
for(i=0; i<CHANNEL_MAX_COUNT; i++)
{
DllNames[i] = NULL;
}
//
// Create an array of dllnames
// pointers in DllNames point inplace to substrings in szDllListTmp
//
BOOL bCurCharIsStart = FALSE;
DllNames[0] = szDllListTmp;
countDlls = 1;
LPTSTR sz = szDllListTmp;
while(*sz)
{
if(bCurCharIsStart)
{
DllNames[countDlls++] = sz;
if(countDlls > CHANNEL_MAX_COUNT)
{
//ABORT
LocalFree(szDllListTmp);
return NULL;
}
//Reset
bCurCharIsStart = FALSE;
}
if(TCHAR(',') == *sz)
{
*sz = NULL;
bCurCharIsStart = TRUE;
}
sz++;
}
//
// bytes needed for the explicit path version
// is at most MAX_PATH * number of dlls (20 is added to give us extra space)
//
int cbExplicitPath = countDlls * (MAX_PATH + 20) * sizeof(TCHAR);
szExplicitPathList = (LPTSTR) LocalAlloc(LPTR,
cbExplicitPath);
if(NULL == szExplicitPathList)
{
LocalFree(szDllListTmp);
return NULL;
}
memset(szExplicitPathList, 0 , cbExplicitPath);
//
// Construct the explicit path list
// by splatting in the prefix followed by '\' followed by the dll name
// ensure that none of the dll paths exceed MAX_PATH..If any do, return FAILURE
//
int lenPrefix = _tcslen(szPathPrefix);
for(i=0; i<countDlls;i++)
{
int lenPath = lenPrefix;
lenPath += _tcslen(DllNames[i]);
lenPath += 1; // for '\'
if(lenPath >= MAX_PATH - 1)
{
LocalFree(szExplicitPathList);
LocalFree(szDllListTmp);
return NULL;
}
hr = StringCbCat(szExplicitPathList,
cbExplicitPath,
szPathPrefix);
if (SUCCEEDED(hr)) {
hr = StringCbCat(szExplicitPathList,
cbExplicitPath,
_T("\\"));
if (SUCCEEDED(hr)) {
hr = StringCbCat(szExplicitPathList,
cbExplicitPath,
DllNames[i]);
if (SUCCEEDED(hr)) {
if (i != (countDlls -1)) {
//Last DLL, no trailing ","
hr = StringCbCat(szExplicitPathList,
cbExplicitPath,
_T(","));
}
}
}
}
if (FAILED(hr)) {
LocalFree(szExplicitPathList);
LocalFree(szDllListTmp);
return NULL;
}
}
LocalFree(szDllListTmp);
//caller must free
return szExplicitPathList;
}
//
// IconFile
//
STDMETHODIMP CMstscAdvSettings::put_IconFile(BSTR IconFile)
{
HRESULT hr = E_FAIL;
//
// Don't allow this property to be set in the web control case
// for attack surface reduction as we don't want to allow a script
// caller access to the local file system.
//
#if (defined(OS_WINCE) || defined(REDIST_CONTROL))
return S_FALSE;
#else
if(GetLockedForWrite())
{
return E_FAIL;
}
if (IconFile) {
hr = CUT::StringPropPut(m_pUI->_UI.szIconFile,
SIZE_TCHARS(m_pUI->_UI.szIconFile),
(LPTSTR)IconFile);
}
else {
m_pUI->_UI.szIconFile[0] = NULL;
hr = S_OK;
}
return hr;
#endif
}
//
// Icon Index
//
STDMETHODIMP CMstscAdvSettings::put_IconIndex(LONG IconIndex)
{
//
// Don't allow this property to be set in the web control case
// for attack surface reduction as we don't want to allow a script
// caller access to the local file system.
//
#if (defined(OS_WINCE) || defined(REDIST_CONTROL))
return S_FALSE;
#else
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->_UI.iconIndex = IconIndex;
return S_OK;
#endif
}
//
// Container handled full screen mode
//
STDMETHODIMP CMstscAdvSettings::put_ContainerHandledFullScreen(BOOL ContainerHandledFullScreen)
{
HRESULT hr = E_FAIL;
DC_BEGIN_FN("put_ContainerHandledFullScreen");
if(GetLockedForWrite()) {
return E_FAIL;
}
if (!m_bMakeSafeForScripting) {
m_pUI->_UI.fContainerHandlesFullScreenToggle =
(ContainerHandledFullScreen != 0);
hr = S_OK;
}
else {
hr = S_FALSE;
}
DC_END_FN();
return hr;
}
STDMETHODIMP CMstscAdvSettings::get_ContainerHandledFullScreen(BOOL* pContainerHandledFullScreen)
{
HRESULT hr = E_FAIL;
DC_BEGIN_FN("get_ContainerHandledFullScreen");
if(!pContainerHandledFullScreen) {
return E_INVALIDARG;
}
if (!m_bMakeSafeForScripting) {
*pContainerHandledFullScreen = m_pUI->_UI.fContainerHandlesFullScreenToggle ?
VB_TRUE : VB_FALSE;
hr = S_OK;
}
else {
hr = S_FALSE;
}
DC_END_FN();
return hr;
}
//
// Disable loading RDPDR on first initialization
//
STDMETHODIMP CMstscAdvSettings::put_DisableRdpdr(BOOL DisableRdpdr)
{
if(!GetLockedForWrite())
{
if(!m_pUI->UI_IsCoreInitialized())
{
m_pUI->_UI.fDisableInternalRdpDr = (DisableRdpdr != 0);
return S_OK;
}
else
{
return E_FAIL;
}
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::get_DisableRdpdr(BOOL* pDisableRdpdr)
{
if( pDisableRdpdr )
{
*pDisableRdpdr = m_pUI->_UI.fDisableInternalRdpDr ? VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::put_ConnectToServerConsole(VARIANT_BOOL connectToConsole)
{
if(!GetLockedForWrite())
{
m_pUI->UI_SetConnectToServerConsole(connectToConsole != 0);
return S_OK;
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::get_ConnectToServerConsole(VARIANT_BOOL* pConnectToConsole)
{
if(pConnectToConsole)
{
*pConnectToConsole = (m_pUI->UI_GetConnectToServerConsole() ? VB_TRUE : VB_FALSE);
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
STDMETHODIMP CMstscAdvSettings::put_MinutesToIdleTimeout(
LONG minutesToIdleTimeout)
{
DC_BEGIN_FN("put_MinutesToIdleTimeout");
if(!GetLockedForWrite())
{
if(minutesToIdleTimeout > MAX_MINS_TOIDLETIMEOUT)
{
TRC_ERR((TB,_T("idle timeout out of range: %d"),
minutesToIdleTimeout));
return E_INVALIDARG;
}
if(m_pUI->UI_SetMinsToIdleTimeout( minutesToIdleTimeout ))
{
return S_OK;
}
else
{
return E_FAIL;
}
}
else
{
return E_FAIL;
}
DC_END_FN();
}
STDMETHODIMP CMstscAdvSettings::get_MinutesToIdleTimeout(
LONG* pminutesToIdleTimeout)
{
DC_BEGIN_FN("get_MinutesToIdleTimeout");
if(pminutesToIdleTimeout)
{
*pminutesToIdleTimeout = m_pUI->UI_GetMinsToIdleTimeout();
return S_OK;
}
else
{
return E_INVALIDARG;
}
DC_END_FN();
}
#ifdef SMART_SIZING
/**PROC+*********************************************************************/
/* Name: get_SmartSize
/*
/* Purpose: get smart sizing property
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::get_SmartSizing(VARIANT_BOOL* pfSmartSize)
{
ATLASSERT(m_pUI);
if(!pfSmartSize)
{
return E_INVALIDARG;
}
*pfSmartSize = m_pUI->UI_GetSmartSizing() ? VB_TRUE : VB_FALSE;
return S_OK;
}
/**PROC+*********************************************************************/
/* Name: put_SmartSize
/*
/* Purpose: put smart sizing property
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::put_SmartSizing(VARIANT_BOOL fSmartSize)
{
OSVERSIONINFOA OsVer;
memset(&OsVer, 0x0, sizeof(OSVERSIONINFOA));
OsVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
GetVersionExA(&OsVer);
HRESULT hr = S_OK;
if ((VER_PLATFORM_WIN32_NT != OsVer.dwPlatformId) && fSmartSize) {
//
// Win9x doesn't support halftoning, so no smart sizing for them!
//
return E_NOTIMPL;
}
//no, these lines of code are not as bad as they look
//vb's true is 0xFFFFFFF so don't just blindy assign
hr = m_pUI->UI_SetSmartSizing( fSmartSize != 0);
return hr;
}
#endif // SMART_SIZING
//
// Pass in the local printing doc name string to RDPDR
// this method's main purpose is so we don't need to add
// a localizable string to the control. There is a default
// english string built into the control, a container can
// pass in any replacement (i.e localized) string it pleases
//
STDMETHODIMP CMstscAdvSettings::put_RdpdrLocalPrintingDocName(
BSTR RdpdrLocalPrintingDocName)
{
DC_BEGIN_FN("put_RdpdrLocalPrintingDocName");
DC_END_FN();
return S_FALSE; //deprecated
}
//
// Return the currently selected string
// for the local printing doc name. This is just a string
// RDPDR uses but we want to avoid localizing the control
// so the string is passed in from the container.
//
STDMETHODIMP CMstscAdvSettings::get_RdpdrLocalPrintingDocName(
BSTR *pRdpdrLocalPrintingDocName)
{
DC_BEGIN_FN("get_RdpdrLocalPrintingDocName");
DC_END_FN();
return S_FALSE; //deprecated
}
STDMETHODIMP CMstscAdvSettings::put_RdpdrClipCleanTempDirString(
BSTR RdpdrClipCleanTempDirString)
{
DC_BEGIN_FN("put_RdpdrClipCleanTempDirString");
DC_END_FN();
return S_FALSE; //deprecated
}
STDMETHODIMP CMstscAdvSettings::get_RdpdrClipCleanTempDirString(
BSTR *pRdpdrClipCleanTempDirString)
{
DC_BEGIN_FN("get_RdpdrClipCleanTempDirString");
DC_END_FN();
return S_FALSE; //deprecated
}
STDMETHODIMP CMstscAdvSettings::put_RdpdrClipPasteInfoString(
BSTR RdpdrClipPasteInfoString)
{
DC_BEGIN_FN("put_RdpdrClipPasteInfoString");
DC_END_FN();
return S_FALSE; //deprecated
}
STDMETHODIMP CMstscAdvSettings::get_RdpdrClipPasteInfoString(
BSTR *pRdpdrClipPasteInfoString)
{
DC_BEGIN_FN("get_RdpdrClipPasteInfoString");
DC_END_FN();
return S_FALSE; //deprecated
}
//
// New Whistler scriptable access to password API
// this just delegates to the non-scriptable API from TSAC
//
STDMETHODIMP CMstscAdvSettings::put_ClearTextPassword(BSTR clearTextPassword)
{
DC_BEGIN_FN("put_ClearTextPassword");
TRC_ASSERT(_pAxControl,
(TB,_T("_pAxControl is NULL")));
if(!GetLockedForWrite() && _pAxControl)
{
if(clearTextPassword)
{
return _pAxControl->put_ClearTextPassword( clearTextPassword );
}
else
{
return E_INVALIDARG;
}
}
else
{
return E_FAIL;
}
DC_END_FN();
}
/**PROC+*********************************************************************/
/* Name: put_DisplayConnectionBar
/*
/* Purpose: Set display connection bar prop
/* cannot be set in web control (it is always true there)
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::put_DisplayConnectionBar(
VARIANT_BOOL fDisplayConnectionBar)
{
ATLASSERT(m_pUI);
#if (!defined (OS_WINCE)) || (!defined (WINCE_SDKBUILD))
if(!m_bMakeSafeForScripting && !GetLockedForWrite())
{
m_pUI->UI_SetEnableBBar( fDisplayConnectionBar != 0);
}
else
{
//
// Not allowed to toggle this
// if need to be safe for scripting as the bbar
// prevents spoofing attacks because people
// can always realize this is a TS session.
//
return E_FAIL;
}
return S_OK;
#else
return E_NOTIMPL;
#endif
}
/**PROC+*********************************************************************/
/* Name: get_DisplayConnectionBar
/*
/* Purpose: put start connected property
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::get_DisplayConnectionBar(
VARIANT_BOOL* pfDisplayConnectionBar)
{
#if (!defined (OS_WINCE)) || (!defined (WINCE_SDKBUILD))
if(pfDisplayConnectionBar)
{
*pfDisplayConnectionBar =
m_pUI->UI_GetEnableBBar() ? VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
#else
return E_NOTIMPL;
#endif
}
/**PROC+*********************************************************************/
/* Name: put_PinConnectionBar
/*
/* Purpose: Set Pin connection bar prop
/* cannot be set in web control (it is always true there)
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::put_PinConnectionBar(
VARIANT_BOOL fPinConnectionBar)
{
#if (!defined (OS_WINCE)) || (!defined (WINCE_SDKBUILD))
if (!m_bMakeSafeForScripting) {
if (!GetLockedForWrite())
{
m_pUI->UI_SetBBarPinned( fPinConnectionBar != 0);
}
else
{
//
// Not allowed to toggle this
// if need to be safe for scripting as the bbar
// prevents spoofing attacks because people
// can always realize this is a TS session.
//
return E_FAIL;
}
return S_OK;
}
else {
return E_NOTIMPL;
}
#else
return E_NOTIMPL;
#endif
}
/**PROC+*********************************************************************/
/* Name: get_PinConnectionBar
/*
/* Purpose: put start connected property
/*
/**PROC-*********************************************************************/
STDMETHODIMP CMstscAdvSettings::get_PinConnectionBar(
VARIANT_BOOL* pfPinConnectionBar)
{
#if (!defined (OS_WINCE)) || (!defined (WINCE_SDKBUILD))
if (!m_bMakeSafeForScripting) {
if(pfPinConnectionBar)
{
*pfPinConnectionBar =
m_pUI->UI_GetBBarPinned() ? VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
else {
return E_NOTIMPL;
}
#else
return E_NOTIMPL;
#endif
}
//
// GrabFocusOnConnect (defaults to true)
// can turn this off to allow containers to control
// when the client gets the focus (e.g the MMC snapin)
// needs to manage this for multiple instances
//
STDMETHODIMP CMstscAdvSettings::put_GrabFocusOnConnect(
VARIANT_BOOL fGrabFocusOnConnect)
{
DC_BEGIN_FN("put_GrabFocusOnConnect");
ATLASSERT(m_pUI);
if(!GetLockedForWrite())
{
m_pUI->UI_SetGrabFocusOnConnect( fGrabFocusOnConnect != 0);
return S_OK;
}
else
{
return E_FAIL;
}
DC_END_FN();
}
STDMETHODIMP CMstscAdvSettings::get_GrabFocusOnConnect(
VARIANT_BOOL* pfGrabFocusOnConnect)
{
DC_BEGIN_FN("get_GrabFocusOnConnect");
if(pfGrabFocusOnConnect)
{
*pfGrabFocusOnConnect =
m_pUI->UI_GetGrabFocusOnConnect() ? VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
DC_END_FN();
}
//
// Name: put_LoadBalanceInfo
//
// Purpose: LoadBalance info property input function.
//
#define LBINFO_MAX_LENGTH 256
STDMETHODIMP CMstscAdvSettings::put_LoadBalanceInfo(BSTR newLBInfo)
{
DC_BEGIN_FN("put_LoadBalanceInfo");
if(!GetLockedForWrite())
{
if (newLBInfo)
{
if (SysStringByteLen(newLBInfo) <= LBINFO_MAX_LENGTH)
m_pUI->UI_SetLBInfo((PBYTE)newLBInfo, SysStringByteLen(newLBInfo));
else
return E_INVALIDARG;
}
else
{
m_pUI->UI_SetLBInfo(NULL, 0);
}
}
else {
return E_FAIL;
}
DC_END_FN();
return S_OK;
}
//
// Name: get_LoadBalanceInfo
//
// Purpose: LoadBalance info property get function.
//
STDMETHODIMP CMstscAdvSettings::get_LoadBalanceInfo(BSTR* pLBInfo)
{
DC_BEGIN_FN("get_LoadBalanceInfo");
if(!pLBInfo)
{
return E_INVALIDARG;
}
*pLBInfo = SysAllocStringByteLen((LPCSTR)(m_pUI->_UI.bstrScriptedLBInfo),
SysStringByteLen(m_pUI->_UI.bstrScriptedLBInfo));
if(!*pLBInfo)
{
return E_OUTOFMEMORY;
}
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::put_RedirectDrives(VARIANT_BOOL redirectDrives)
{
DC_BEGIN_FN("put_RedirectDrives");
if(!GetLockedForWrite())
{
if (CMsTscSecuredSettings::IsDriveRedirGloballyDisabled())
{
m_pUI->UI_SetDriveRedirectionEnabled(FALSE);
return S_FALSE;
}
else
{
m_pUI->UI_SetDriveRedirectionEnabled( (redirectDrives != 0));
return S_OK;
}
}
else
{
return E_FAIL;
}
DC_END_FN();
}
STDMETHODIMP CMstscAdvSettings::get_RedirectDrives(VARIANT_BOOL *pRedirectDrives)
{
if(pRedirectDrives)
{
*pRedirectDrives = m_pUI->UI_GetDriveRedirectionEnabled() ?
VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
STDMETHODIMP CMstscAdvSettings::put_RedirectPrinters(VARIANT_BOOL redirectPrinters)
{
if(!GetLockedForWrite())
{
m_pUI->UI_SetPrinterRedirectionEnabled( (redirectPrinters != 0));
return S_OK;
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::get_RedirectPrinters(VARIANT_BOOL *pRedirectPrinters)
{
if(pRedirectPrinters)
{
*pRedirectPrinters = m_pUI->UI_GetPrinterRedirectionEnabled() ?
VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
STDMETHODIMP CMstscAdvSettings::put_RedirectPorts(VARIANT_BOOL redirectPorts)
{
if(!GetLockedForWrite())
{
m_pUI->UI_SetPortRedirectionEnabled( (redirectPorts != 0));
return S_OK;
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::get_RedirectPorts(VARIANT_BOOL *pRedirectPorts)
{
if(pRedirectPorts)
{
*pRedirectPorts = m_pUI->UI_GetPortRedirectionEnabled() ?
VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
STDMETHODIMP CMstscAdvSettings::put_RedirectSmartCards(VARIANT_BOOL redirectScard)
{
if(!GetLockedForWrite())
{
m_pUI->UI_SetSCardRedirectionEnabled(redirectScard != 0);
return S_OK;
}
else
{
return E_FAIL;
}
}
STDMETHODIMP CMstscAdvSettings::get_RedirectSmartCards(VARIANT_BOOL *pRedirectScard)
{
if(pRedirectScard)
{
*pRedirectScard = m_pUI->UI_GetSCardRedirectionEnabled() ?
VB_TRUE : VB_FALSE;
return S_OK;
}
else
{
return E_INVALIDARG;
}
}
//
// BitmapVirtualCache16BppSize property
//
// Applies to 15/16Bpp cache file size
//
STDMETHODIMP CMstscAdvSettings::put_BitmapVirtualCache16BppSize(
LONG bitmapVirtualCache16BppSize)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
if (bitmapVirtualCache16BppSize > 0 &&
bitmapVirtualCache16BppSize <= TSC_MAX_BITMAPCACHESIZE)
{
m_pUI->_UI.RegBitmapVirtualCache16BppSize =
bitmapVirtualCache16BppSize;
}
else
{
return E_INVALIDARG;
}
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_BitmapVirtualCache16BppSize(
LONG* pbitmapVirtualCache16BppSize)
{
if(!pbitmapVirtualCache16BppSize)
{
return E_POINTER;
}
*pbitmapVirtualCache16BppSize =
m_pUI->_UI.RegBitmapVirtualCache16BppSize;
return S_OK;
}
//
// BitmapVirtualCache24BppSize property
//
// Applies to 24Bpp cache file size
//
STDMETHODIMP CMstscAdvSettings::put_BitmapVirtualCache24BppSize(
LONG bitmapVirtualCache24BppSize)
{
if(GetLockedForWrite())
{
return E_FAIL;
}
if (bitmapVirtualCache24BppSize > 0 &&
bitmapVirtualCache24BppSize <= TSC_MAX_BITMAPCACHESIZE)
{
m_pUI->_UI.RegBitmapVirtualCache24BppSize =
bitmapVirtualCache24BppSize;
}
else
{
return E_INVALIDARG;
}
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_BitmapVirtualCache24BppSize(
LONG* pbitmapVirtualCache24BppSize)
{
if(!pbitmapVirtualCache24BppSize)
{
return E_POINTER;
}
*pbitmapVirtualCache24BppSize =
m_pUI->_UI.RegBitmapVirtualCache24BppSize;
return S_OK;
}
//
// Sets the disabled feature list (for perf reasons can disable
// certain features at the server e.g wallpaper)
//
STDMETHODIMP CMstscAdvSettings::put_PerformanceFlags(
LONG DisableFeatList)
{
DC_BEGIN_FN("put_PerformanceFlags");
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->UI_SetPerformanceFlags((DWORD)DisableFeatList);
DC_END_FN();
return S_OK;
}
STDMETHODIMP CMstscAdvSettings::get_PerformanceFlags(
LONG* pDisableFeatList)
{
DC_BEGIN_FN("get_PerformanceFlags");
if(!pDisableFeatList)
{
return E_POINTER;
}
*pDisableFeatList = (LONG)
m_pUI->UI_GetPerformanceFlags();
DC_END_FN();
return S_OK;
}
/*****************************************************************************/
/* Purpose : This is Remote Assistance specific call to support reverse */
/* connection pcHealth must have invoke necessary routine in Salem *
/* to connection with TermSrv and then instruct Salem to pass this */
/* connection to ActiveX control to begin login sequence */
/* */
/* Param : IN pConnectionEndPoint - Connected socket */
/*****************************************************************************/
STDMETHODIMP
CMstscAdvSettings::put_ConnectWithEndpoint(
VARIANT* pConnectionEndpoint
)
{
#if REDIST_CONTROL
return E_NOTIMPL;
#else
HRESULT hr = S_OK;
DC_BEGIN_FN( "ConnectionEndpoint" );
if( pConnectionEndpoint->vt != VT_BYREF )
{
hr = E_HANDLE;
}
else
{
hr = _pAxControl->SetConnectWithEndpoint(
(SOCKET)pConnectionEndpoint->byref );
}
DC_END_FN();
return hr;
#endif
}
/*****************************************************************************/
/* Purpose : This is Remote Assistance specific call to notify TS public */
/* key uses in generate session encryption key. */
/* */
/* Param : IN fNotify - TRUE to notify public key, FALSE otherwise */
/*****************************************************************************/
STDMETHODIMP
CMstscAdvSettings::put_NotifyTSPublicKey(
VARIANT_BOOL fNotify
)
{
#if REDIST_CONTROL
return E_NOTIMPL;
#else
#ifndef OS_WINCE
HRESULT hr;
#endif
if(GetLockedForWrite())
{
return E_FAIL;
}
m_pUI->UI_SetNotifyTSPublicKey( fNotify );
return S_OK;
#endif
}
/*****************************************************************************/
/* Purpose : Get current setting on whether ActiveX control will notify */
/* container when it received TS public key */
/* */
/* Returns : TRUE to notify public key, FALSE otherwise */
/*****************************************************************************/
STDMETHODIMP
CMstscAdvSettings::get_NotifyTSPublicKey(
VARIANT_BOOL* pfNotifyTSPublicKey
)
{
#if REDIST_CONTROL
return E_NOTIMPL;
#else
BOOL fNotify;
if(!pfNotifyTSPublicKey)
{
return E_POINTER;
}
fNotify = m_pUI->UI_GetNotifyTSPublicKey();
return S_OK;
#endif
}
//
// Retrieves VARIANT_TRUE if we can autoreconnect
// i.e. the core has received an autoreconnect cookie
// from the server from a previous connection and the
// server has not been changed
//
STDMETHODIMP
CMstscAdvSettings::get_CanAutoReconnect(
VARIANT_BOOL* pfCanAutoReconnect
)
{
HRESULT hr;
DC_BEGIN_FN("get_CanAutoReconnect");
if (pfCanAutoReconnect)
{
*pfCanAutoReconnect =
m_pUI->UI_CanAutoReconnect() ? VB_TRUE : VB_FALSE;
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
DC_END_FN();
return hr;
}
//
// Sets w/not any autoreconnection information
// will be used for the next connection. Also specifies
// if we should store any autoreconnection information
// the server sends down.
//
STDMETHODIMP
CMstscAdvSettings::put_EnableAutoReconnect(
VARIANT_BOOL fEnableAutoReconnect
)
{
HRESULT hr;
DC_BEGIN_FN("put_EnableAutoReconnect");
if (!GetLockedForWrite() && m_pUI)
{
m_pUI->UI_SetEnableAutoReconnect(fEnableAutoReconnect != 0);
hr = S_OK;
}
else
{
hr = E_FAIL;
}
DC_END_FN();
return hr;
}
//
// Retrieves state of w/not we should use autoreconnection
//
//
STDMETHODIMP
CMstscAdvSettings::get_EnableAutoReconnect(
VARIANT_BOOL* pfEnableAutoReconnect
)
{
HRESULT hr;
DC_BEGIN_FN("get_EnableAutoReconnect");
if (pfEnableAutoReconnect)
{
*pfEnableAutoReconnect =
m_pUI->UI_GetEnableAutoReconnect() ? VB_TRUE : VB_FALSE;
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
DC_END_FN();
return hr;
}
//
// Specify the max number of ARC retries
//
STDMETHODIMP
CMstscAdvSettings::put_MaxReconnectAttempts(
LONG MaxReconnectAttempts
)
{
HRESULT hr;
DC_BEGIN_FN("put_MaxReconnectAttempts");
if (!GetLockedForWrite() && m_pUI)
{
if (MaxReconnectAttempts > 200) {
MaxReconnectAttempts = 200;
}
else if (MaxReconnectAttempts < 0) {
MaxReconnectAttempts = 0;
}
m_pUI->UI_SetMaxArcAttempts(MaxReconnectAttempts);
hr = S_OK;
}
else
{
hr = E_FAIL;
}
DC_END_FN();
return hr;
}
//
// Retrieves state of w/not we should use autoreconnection
//
//
STDMETHODIMP
CMstscAdvSettings::get_MaxReconnectAttempts(
LONG* pMaxReconnectAttempts
)
{
HRESULT hr;
DC_BEGIN_FN("get_MaxReconnectAttempts");
if (pMaxReconnectAttempts)
{
*pMaxReconnectAttempts =
m_pUI->UI_GetMaxArcAttempts();
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
DC_END_FN();
return hr;
}
//
// Display BBar minimize button
//
STDMETHODIMP
CMstscAdvSettings::put_ConnectionBarShowMinimizeButton(
VARIANT_BOOL fShowMinimizeButton
)
{
HRESULT hr;
DC_BEGIN_FN("put_EnableAutoReconnect");
if (!GetLockedForWrite() && m_pUI)
{
m_pUI->UI_SetBBarShowMinimize(fShowMinimizeButton != 0);
hr = S_OK;
}
else
{
hr = E_FAIL;
}
DC_END_FN();
return hr;
}
//
// get display bbar minimize button
//
STDMETHODIMP
CMstscAdvSettings::get_ConnectionBarShowMinimizeButton(
VARIANT_BOOL* pfShowMinimizeButton
)
{
HRESULT hr;
DC_BEGIN_FN("get_ConnectionBarShowMinimizeButton");
if (pfShowMinimizeButton)
{
*pfShowMinimizeButton =
m_pUI->UI_GetBBarShowMinimize() ? VB_TRUE : VB_FALSE;
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
DC_END_FN();
return hr;
}
//
// set bbar restore button
//
STDMETHODIMP
CMstscAdvSettings::put_ConnectionBarShowRestoreButton(
VARIANT_BOOL fShowRestoreButton
)
{
HRESULT hr;
DC_BEGIN_FN("put_EnableAutoReconnect");
if (!GetLockedForWrite() && m_pUI)
{
m_pUI->UI_SetBBarShowRestore(fShowRestoreButton != 0);
hr = S_OK;
}
else
{
hr = E_FAIL;
}
DC_END_FN();
return hr;
}
//
// get bbar restore button
//
STDMETHODIMP
CMstscAdvSettings::get_ConnectionBarShowRestoreButton(
VARIANT_BOOL* pfShowRestoreButton
)
{
HRESULT hr;
DC_BEGIN_FN("get_ConnectionBarShowRestoreButton");
if (pfShowRestoreButton)
{
*pfShowRestoreButton =
m_pUI->UI_GetBBarShowRestore() ? VB_TRUE : VB_FALSE;
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
DC_END_FN();
return hr;
}