2724 lines
61 KiB
C++
2724 lines
61 KiB
C++
/**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;
|
|
}
|
|
|