3066 lines
75 KiB
C++
3066 lines
75 KiB
C++
/*++
|
|
|
|
Copyright (c) 1999-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
TSRDPRemoteDesktopClient
|
|
|
|
Abstract:
|
|
|
|
This is the TS/RDP implementation of the Remote Desktop Client class.
|
|
|
|
The Remote Desktop Client class hierarchy provides a pluggable C++
|
|
interface for remote desktop access, by abstracting the implementation
|
|
specific details of remote desktop access for the client-side
|
|
|
|
The TSRDPRemoteDesktopClass implements remote-desktopping
|
|
with the help of an instance of the MSTSC ActiveX client control.
|
|
|
|
Author:
|
|
|
|
Tad Brockway 02/00
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#ifdef TRC_FILE
|
|
#undef TRC_FILE
|
|
#endif
|
|
|
|
#define TRC_FILE "_tsrdpc"
|
|
|
|
#include "RDCHost.h"
|
|
#include "TSRDPRemoteDesktopClient.h"
|
|
#include <RemoteDesktopChannels.h>
|
|
#include <mstsax_i.c>
|
|
#include <TSRDPRemoteDesktop.h>
|
|
#include "pchannel.h"
|
|
#include <tsremdsk.h>
|
|
#include <sessmgr.h>
|
|
#include <sessmgr_i.c>
|
|
#include <regapi.h>
|
|
#include "parseaddr.h"
|
|
#include "icshelpapi.h"
|
|
#include <tsperf.h>
|
|
#include "base64.h"
|
|
|
|
#define ISRCSTATUSCODE(code) ((code) > SAFERROR_SHADOWEND_BASE)
|
|
|
|
//
|
|
// Variable to manage WinSock and ICS library startup/shutdown
|
|
//
|
|
LONG CTSRDPRemoteDesktopClient::gm_ListeningLibraryRefCount = 0; // Number of time that WinSock is intialized
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::InitListeningLibrary()
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Function to initialize WinSock and ICS library for StartListen(), function add
|
|
reference count to library if WinSock/ICS library already initialized.
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
WSADATA wsaData;
|
|
WORD versionRequested;
|
|
INT intRC;
|
|
DWORD dwStatus;
|
|
HRESULT hr = S_OK;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::InitListeningLibrary");
|
|
|
|
|
|
// Our COM object is apartment-threaded model, need a critical section if
|
|
// we switch to multi-threaded
|
|
if( gm_ListeningLibraryRefCount == 0 )
|
|
{
|
|
//
|
|
// Initialize WinSock.
|
|
//
|
|
versionRequested = MAKEWORD(1, 1);
|
|
intRC = WSAStartup(versionRequested, &wsaData);
|
|
if( intRC != 0 )
|
|
{
|
|
intRC = WSAGetLastError();
|
|
|
|
TRC_ERR((TB, _T("WSAStartup failed %d"), intRC));
|
|
TRC_ASSERT( (intRC == 0), (TB, _T("WSAStartup failed...\n")) );
|
|
|
|
hr = HRESULT_FROM_WIN32( intRC );
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Now confirm that this WinSock supports version 1.1. Note that if */
|
|
/* the DLL supports versions greater than 1.1 in addition to 1.1 then */
|
|
/* it will still return 1.1 in the version information as that is the */
|
|
/* version requested. */
|
|
/************************************************************************/
|
|
if ((LOBYTE(wsaData.wVersion) != 1) ||
|
|
(HIBYTE(wsaData.wVersion) != 1))
|
|
{
|
|
/********************************************************************/
|
|
/* Oops - this WinSock doesn't support version 1.1. */
|
|
/********************************************************************/
|
|
TRC_ERR((TB, _T("WinSock doesn't support version 1.1")));
|
|
|
|
WSACleanup();
|
|
|
|
hr = HRESULT_FROM_WIN32( WSAVERNOTSUPPORTED );
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Initialize ICS library.
|
|
//
|
|
dwStatus = StartICSLib();
|
|
if( ERROR_SUCCESS != dwStatus )
|
|
{
|
|
// Shutdown WinSock so that we have a matching WSAStatup() and StartICSLib().
|
|
WSACleanup();
|
|
|
|
hr = HRESULT_FROM_WIN32( dwStatus );
|
|
|
|
TRC_ERR((TB, _T("StartICSLib() failed with %d"), dwStatus));
|
|
TRC_ASSERT( (ERROR_SUCCESS == dwStatus), (TB, _T("StartICSLib() failed...\n")) );
|
|
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
}
|
|
|
|
InterlockedIncrement( &gm_ListeningLibraryRefCount );
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::TerminateListeningLibrary()
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Function to shutdown ICS libaray and WinSock, decrement reference count
|
|
if more than one object is referencing WinSock/ICS library.
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code
|
|
|
|
Note:
|
|
|
|
Not multi-thread safe, need CRITICAL_SECTION if we switch to multi-threaded
|
|
model.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::TerminateListeningLibrary");
|
|
|
|
|
|
ASSERT( gm_ListeningLibraryRefCount > 0 );
|
|
if( gm_ListeningLibraryRefCount <= 0 )
|
|
{
|
|
TRC_ERR((TB, _T("TerminateListeningLibrary() called before InitListeningLibrary()")));
|
|
|
|
hr = HRESULT_FROM_WIN32(WSANOTINITIALISED);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
|
|
if( 0 == InterlockedDecrement( &gm_ListeningLibraryRefCount ) )
|
|
{
|
|
// Stop ICS libray.
|
|
StopICSLib();
|
|
|
|
// Shutdown WinSock
|
|
WSACleanup();
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// CMSTSCClientEventSink Methods
|
|
//
|
|
|
|
CMSTSCClientEventSink::~CMSTSCClientEventSink()
|
|
{
|
|
DC_BEGIN_FN("CMSTSCClientEventSink::~CMSTSCClientEventSink");
|
|
|
|
if (m_Obj) {
|
|
ASSERT(m_Obj->IsValid());
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Event Sinks
|
|
//
|
|
HRESULT __stdcall
|
|
CMSTSCClientEventSink::OnRDPConnected()
|
|
{
|
|
m_Obj->OnRDPConnected();
|
|
return S_OK;
|
|
}
|
|
HRESULT __stdcall
|
|
CMSTSCClientEventSink::OnLoginComplete()
|
|
{
|
|
m_Obj->OnLoginComplete();
|
|
return S_OK;
|
|
}
|
|
HRESULT __stdcall
|
|
CMSTSCClientEventSink::OnDisconnected(
|
|
long disconReason
|
|
)
|
|
{
|
|
m_Obj->OnDisconnected(disconReason);
|
|
return S_OK;
|
|
}
|
|
void __stdcall CMSTSCClientEventSink::OnReceiveData(
|
|
BSTR chanName,
|
|
BSTR data
|
|
)
|
|
{
|
|
m_Obj->OnMSTSCReceiveData(data);
|
|
}
|
|
void __stdcall CMSTSCClientEventSink::OnReceivedTSPublicKey(
|
|
BSTR publicKey,
|
|
VARIANT_BOOL* pfbContinueLogon
|
|
)
|
|
{
|
|
m_Obj->OnReceivedTSPublicKey(publicKey, pfbContinueLogon);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// CCtlChannelEventSink Methods
|
|
//
|
|
|
|
CCtlChannelEventSink::~CCtlChannelEventSink()
|
|
{
|
|
DC_BEGIN_FN("CCtlChannelEventSink::~CCtlChannelEventSink");
|
|
|
|
if (m_Obj) {
|
|
ASSERT(m_Obj->IsValid());
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Event Sinks
|
|
//
|
|
void __stdcall
|
|
CCtlChannelEventSink::DataReady(BSTR channelName)
|
|
{
|
|
m_Obj->HandleControlChannelMsg();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// CTSRDPRemoteDesktopClient Methods
|
|
//
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::FinalConstruct()
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::FinalConstruct");
|
|
|
|
HRESULT hr = S_OK;
|
|
if (!AtlAxWinInit()) {
|
|
TRC_ERR((TB, L"AtlAxWinInit failed."));
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
CTSRDPRemoteDesktopClient::~CTSRDPRemoteDesktopClient()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The Destructor
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::~CTSRDPRemoteDesktopClient");
|
|
|
|
if (m_ChannelMgr) {
|
|
m_CtlChannelEventSink.DispEventUnadvise(m_CtlChannel);
|
|
}
|
|
|
|
if (m_TSClient != NULL) {
|
|
m_TSClient->Release();
|
|
m_TSClient = NULL;
|
|
}
|
|
|
|
if( m_TimerId > 0 ) {
|
|
KillTimer( m_TimerId );
|
|
}
|
|
|
|
ListenConnectCleanup();
|
|
|
|
if( m_InitListeningLibrary )
|
|
{
|
|
// Dereference listening library.
|
|
TerminateListeningLibrary();
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::Initialize(
|
|
LPCREATESTRUCT pCreateStruct
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Final Initialization
|
|
|
|
Arguments:
|
|
|
|
pCreateStruct - WM_CREATE, create struct.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::Initialize");
|
|
|
|
RECT rcClient = { 0, 0, pCreateStruct->cx, pCreateStruct->cy };
|
|
HRESULT hr;
|
|
IUnknown *pUnk = NULL;
|
|
DWORD result;
|
|
IMsRdpClientAdvancedSettings2 *advancedSettings;
|
|
CComBSTR bstr;
|
|
HKEY hKey = NULL;
|
|
HRESULT hrIgnore;
|
|
|
|
ASSERT(!m_Initialized);
|
|
|
|
//
|
|
// Create the client Window.
|
|
//
|
|
m_TSClientWnd = m_TSClientAxView.Create(
|
|
m_hWnd, rcClient, MSTSCAX_TEXTGUID,
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, 0
|
|
);
|
|
|
|
if (m_TSClientWnd == NULL) {
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
TRC_ERR((TB, L"Window Create: %08X", GetLastError()));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Get IUnknown
|
|
//
|
|
hr = AtlAxGetControl(m_TSClientWnd, &pUnk);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"AtlAxGetControl: %08X", hr));
|
|
pUnk = NULL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Initialize the event sink.
|
|
//
|
|
m_TSClientEventSink.m_Obj = this;
|
|
|
|
//
|
|
// Add the event sink.
|
|
//
|
|
hr = m_TSClientEventSink.DispEventAdvise(pUnk);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"DispEventAdvise: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Get the control.
|
|
//
|
|
hr = pUnk->QueryInterface(__uuidof(IMsRdpClient2), (void**)&m_TSClient);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"QueryInterface: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Specify that the MSTSC input handler window should accept background
|
|
// events.
|
|
//
|
|
hr = m_TSClient->get_AdvancedSettings3(&advancedSettings);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"IMsTscAdvancedSettings: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
hr = advancedSettings->put_allowBackgroundInput(1);
|
|
|
|
|
|
//
|
|
// Disable autoreconnect it doesn't apply to Salem
|
|
//
|
|
hr = advancedSettings->put_EnableAutoReconnect(VARIANT_FALSE);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_EnableAutoReconnect: %08X", hr));
|
|
result = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Disable advanced desktop features for the help session.
|
|
// An error here is not critical, so we ignore it.
|
|
//
|
|
LONG flags = TS_PERF_DISABLE_WALLPAPER | TS_PERF_DISABLE_THEMING;
|
|
hrIgnore = advancedSettings->put_PerformanceFlags(flags);
|
|
if (!SUCCEEDED(hrIgnore)) {
|
|
TRC_ERR((TB, L"put_PerformanceFlags: %08X", hrIgnore));
|
|
}
|
|
|
|
//
|
|
// Disable CTRL_ALT_BREAK, ignore error
|
|
//
|
|
hrIgnore = advancedSettings->put_HotKeyFullScreen(0);
|
|
if (!SUCCEEDED(hrIgnore)) {
|
|
TRC_ERR((TB, L"put_HotKeyFullScreen: %08X", hrIgnore));
|
|
}
|
|
|
|
//
|
|
// Don't allow mstscax to grab input focus on connect. Ignore error
|
|
// on failure.
|
|
//
|
|
hrIgnore = advancedSettings->put_GrabFocusOnConnect(FALSE);
|
|
if (!SUCCEEDED(hrIgnore)) {
|
|
TRC_ERR((TB, L"put_HotKeyFullScreen: %08X", hrIgnore));
|
|
}
|
|
|
|
advancedSettings->Release();
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_allowBackgroundInput: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Create the "remote desktop" virtual channel with the TS Client.
|
|
//
|
|
bstr = TSRDPREMOTEDESKTOP_VC_CHANNEL;
|
|
hr = m_TSClient->CreateVirtualChannels(bstr);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"CreateVirtualChannels: %08X", hr));
|
|
result = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Set the Shadow Persistent option
|
|
//
|
|
hr = m_TSClient->SetVirtualChannelOptions(bstr, CHANNEL_OPTION_REMOTE_CONTROL_PERSISTENT);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"SetVirtualChannelOptions: %08X", hr));
|
|
result = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//initialize timer-related stuff
|
|
m_PrevTimer = GetTickCount();
|
|
//
|
|
//get the time interval for pings from the registry
|
|
//
|
|
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
REG_CONTROL_SALEM,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
) == ERROR_SUCCESS ) {
|
|
|
|
DWORD dwSize = sizeof(DWORD);
|
|
DWORD dwType;
|
|
if((RegQueryValueEx(hKey,
|
|
RDC_CONNCHECK_ENTRY,
|
|
NULL,
|
|
&dwType,
|
|
(PBYTE) &m_RdcConnCheckTimeInterval,
|
|
&dwSize
|
|
) == ERROR_SUCCESS) && dwType == REG_DWORD ) {
|
|
|
|
m_RdcConnCheckTimeInterval *= 1000; //we need this in millisecs
|
|
}
|
|
else
|
|
{
|
|
//
|
|
//fall back to default, if reg lookup failed
|
|
//
|
|
m_RdcConnCheckTimeInterval = RDC_CHECKCONN_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if(NULL != hKey )
|
|
RegCloseKey(hKey);
|
|
//
|
|
// m_TSClient keeps our reference to the client object until
|
|
// the destructor is called.
|
|
//
|
|
if (pUnk != NULL) {
|
|
pUnk->Release();
|
|
}
|
|
|
|
SetValid(SUCCEEDED(hr));
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::SendData(
|
|
BSTR data
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
IDataChannelIO Data Channel Send Method
|
|
|
|
Arguments:
|
|
|
|
data - Data to send.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::SendData");
|
|
|
|
CComBSTR channelName;
|
|
HRESULT hr;
|
|
|
|
ASSERT(IsValid());
|
|
|
|
channelName = TSRDPREMOTEDESKTOP_VC_CHANNEL;
|
|
hr = m_TSClient->SendOnVirtualChannel(
|
|
channelName,
|
|
(BSTR)data
|
|
);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"SendOnVirtualChannel: %08X", hr));
|
|
}
|
|
|
|
//
|
|
//update timer
|
|
//
|
|
m_PrevTimer = GetTickCount();
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::put_EnableSmartSizing(
|
|
BOOL val
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enable/Disable Smart Sizing
|
|
|
|
Arguments:
|
|
|
|
val - TRUE for enable. FALSE, otherwise.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
IMsRdpClientAdvancedSettings *pAdvSettings = NULL;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_EnableSmartSizing");
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings2(&pAdvSettings);
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"get_AdvancedSettings2: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
hr = pAdvSettings->put_SmartSizing(val ? VARIANT_TRUE : VARIANT_FALSE);
|
|
pAdvSettings->Release();
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::get_EnableSmartSizing(
|
|
BOOL *pVal
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enable/Disable Smart Sizing
|
|
|
|
Arguments:
|
|
|
|
val - TRUE for enable. FALSE, otherwise.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
VARIANT_BOOL vb;
|
|
IMsRdpClientAdvancedSettings *pAdvSettings = NULL;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_EnableSmartSizing");
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings2(&pAdvSettings);
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"get_AdvancedSettings2: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = pAdvSettings->get_SmartSizing(&vb);
|
|
*pVal = (vb != 0);
|
|
pAdvSettings->Release();
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::put_ChannelMgr(
|
|
ISAFRemoteDesktopChannelMgr *newVal
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Assign the data channel manager interface.
|
|
|
|
Arguments:
|
|
|
|
newVal - Data Channel Manager
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_ChannelMgr");
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// We should get called one time.
|
|
//
|
|
ASSERT(m_ChannelMgr == NULL);
|
|
m_ChannelMgr = newVal;
|
|
|
|
//
|
|
// Register the Remote Desktop control channel
|
|
//
|
|
hr = m_ChannelMgr->OpenDataChannel(
|
|
REMOTEDESKTOP_RC_CONTROL_CHANNEL, &m_CtlChannel
|
|
);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Register an event sink with the channel manager.
|
|
//
|
|
m_CtlChannelEventSink.m_Obj = this;
|
|
|
|
//
|
|
// Add the event sink.
|
|
//
|
|
hr = m_CtlChannelEventSink.DispEventAdvise(m_CtlChannel);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"DispEventAdvise: %08X", hr));
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::ConnectServerWithOpenedSocket()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Connects the client component to the server-side Remote Desktop Host COM
|
|
Object with already opened socket.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::ConnectServerWithSocket");
|
|
|
|
IMsRdpClientAdvancedSettings* ptsAdvSettings = NULL;
|
|
|
|
TRC_NRM((TB, L"ConnectServerWithOpenedSocket"));
|
|
|
|
ASSERT( INVALID_SOCKET != m_TSConnectSocket );
|
|
|
|
//
|
|
// Direct the MSTSCAX control to connect.
|
|
//
|
|
hr = m_TSClient->put_Server( m_ConnectedServer );
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_Server: %ld", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings2( &ptsAdvSettings );
|
|
if( SUCCEEDED(hr) && ptsAdvSettings ) {
|
|
VARIANT var;
|
|
|
|
VariantClear(&var);
|
|
var.vt = VT_BYREF;
|
|
var.byref = (PVOID)m_TSConnectSocket;
|
|
|
|
hr = ptsAdvSettings->put_ConnectWithEndpoint( &var );
|
|
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, _T("put_ConnectWithEndpoint failed - GLE:%x"), hr));
|
|
}
|
|
|
|
VariantClear(&var);
|
|
ptsAdvSettings->Release();
|
|
}
|
|
|
|
if( FAILED(hr) ) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// mstscax owns this socket and will close it
|
|
//
|
|
m_TSConnectSocket = INVALID_SOCKET;
|
|
|
|
hr = m_TSClient->Connect();
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"Connect: 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::ConnectServerPort(
|
|
BSTR bstrServer,
|
|
LONG portNumber
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Connects the client component to the server-side Remote Desktop Host COM
|
|
Object with specific port number
|
|
|
|
Arguments:
|
|
|
|
bstrServer : Name or IP address of server.
|
|
portNumber : optional port number.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::ConnectServerPort");
|
|
|
|
HRESULT hr;
|
|
IMsRdpClientAdvancedSettings* ptsAdvSettings = NULL;
|
|
|
|
TRC_NRM((TB, L"ConnectServerPort %s %d", bstrServer, portNumber));
|
|
|
|
//
|
|
// Direct the MSTSCAX control to connect.
|
|
//
|
|
hr = m_TSClient->put_Server( bstrServer );
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_Server: %ld", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings2( &ptsAdvSettings );
|
|
if( SUCCEEDED(hr) && ptsAdvSettings ) {
|
|
//
|
|
// Previous ConnectServerPort() might have set this port number
|
|
// other than 3389
|
|
//
|
|
hr = ptsAdvSettings->put_RDPPort(
|
|
(0 != portNumber) ? portNumber : TERMSRV_TCPPORT
|
|
);
|
|
|
|
if (FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_RDPPort failed: 0x%08x", hr));
|
|
}
|
|
|
|
ptsAdvSettings->Release();
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"get_AdvancedSettings2 failed: 0x%08x", hr));
|
|
}
|
|
|
|
//
|
|
// Failed the connection if we can't set the port number
|
|
//
|
|
if( FAILED(hr) )
|
|
{
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
m_ConnectedServer = bstrServer;
|
|
m_ConnectedPort = (0 != portNumber) ? portNumber : TERMSRV_TCPPORT;
|
|
|
|
hr = m_TSClient->Connect();
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"Connect: 0x%08x", hr));
|
|
}
|
|
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::SetupConnectionInfo(
|
|
BOOL bListenConnectInfo,
|
|
BSTR bstrExpertBlob
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Connects the client component to the server-side Remote Desktop Host COM
|
|
Object.
|
|
|
|
Arguments:
|
|
|
|
bstrExpertBlob : Optional parameter to be transmitted to SAF resolver.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::SetupConnectionInfo");
|
|
|
|
HRESULT hr = S_OK;
|
|
DWORD result;
|
|
DWORD protocolType;
|
|
IMsTscNonScriptable* ptsns = NULL;
|
|
IMsRdpClientAdvancedSettings* ptsAdvSettings = NULL;
|
|
IMsRdpClientSecuredSettings* ptsSecuredSettings = NULL;
|
|
CComBSTR bstrAssistantAccount;
|
|
CComBSTR bstrAccountDomainName;
|
|
CComBSTR machineAddressList;
|
|
VARIANT_BOOL bNotifyTSPublicKey;
|
|
|
|
//
|
|
// Parse the connection parameters.
|
|
//
|
|
result = ParseConnectParmsString(
|
|
m_ConnectParms,
|
|
&m_ConnectParmVersion,
|
|
&protocolType,
|
|
machineAddressList,
|
|
bstrAssistantAccount,
|
|
m_AssistantAccountPwd,
|
|
m_HelpSessionID,
|
|
m_HelpSessionName,
|
|
m_HelpSessionPwd,
|
|
m_TSSecurityBlob
|
|
);
|
|
if (result != ERROR_SUCCESS) {
|
|
hr = HRESULT_FROM_WIN32(result);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// If the protocol type doesn't match, then fail.
|
|
//
|
|
if (protocolType != REMOTEDESKTOP_TSRDP_PROTOCOL) {
|
|
TRC_ERR((TB, L"Invalid connection protocol %ld", protocolType));
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_USER_BUFFER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (bListenConnectInfo) {
|
|
m_ServerAddressList.clear();
|
|
}
|
|
else {
|
|
//
|
|
// Parse address list in connect parm.
|
|
//
|
|
result = ParseAddressList( machineAddressList, m_ServerAddressList );
|
|
if( ERROR_SUCCESS != result ) {
|
|
TRC_ERR((TB, L"Invalid address list 0x%08x", result));
|
|
hr = HRESULT_FROM_WIN32(result);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( 0 == m_ServerAddressList.size() ) {
|
|
TRC_ERR((TB, L"Invalid connection address list"));
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_USER_BUFFER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
}
|
|
|
|
hr = m_TSClient->put_UserName(SALEMHELPASSISTANTACCOUNT_NAME);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_UserName: %ld", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings2( &ptsAdvSettings );
|
|
if( SUCCEEDED(hr) && ptsAdvSettings ) {
|
|
hr = ptsAdvSettings->put_DisableRdpdr( TRUE );
|
|
|
|
if (FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_DisableRdpdr failed: 0x%08x", hr));
|
|
}
|
|
|
|
// older version does not have security blob so don't notify us about
|
|
// TS public key.
|
|
bNotifyTSPublicKey = (VARIANT_BOOL)(m_ConnectParmVersion >= SALEM_CONNECTPARM_SECURITYBLOB_VERSION);
|
|
|
|
// tell activeX control to notify us TS public key
|
|
hr = ptsAdvSettings->put_NotifyTSPublicKey(bNotifyTSPublicKey);
|
|
if (FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_NotifyTSPublicKey failed: 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
ptsAdvSettings->Release();
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"QueryInterface IID_IMsRdpClientAdvancedSettings: %ld", hr));
|
|
}
|
|
|
|
//
|
|
// Setting connection timeout, ICS might take sometime to routine
|
|
// opened port to actual TS server, neither is critical error.
|
|
//
|
|
hr = ptsAdvSettings->put_singleConnectionTimeout( 60 * 2 ); // try two mins timeout
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_singleConnectionTimeout : 0x%x", hr));
|
|
}
|
|
|
|
hr = ptsAdvSettings->put_overallConnectionTimeout( 60 * 2 );
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_overallConnectionTimeout : 0x%x", hr));
|
|
}
|
|
|
|
|
|
// Password encryption is based on encyption cycle key + help session ID
|
|
hr = m_TSClient->get_SecuredSettings2( &ptsSecuredSettings );
|
|
|
|
if( FAILED(hr) || !ptsSecuredSettings ) {
|
|
TRC_ERR((TB, L"get_IMsTscSecuredSettings : 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// TermSrv invoke sessmgr to check if help session is valid
|
|
// before kicking off rdsaddin.exe, we need to send over
|
|
// help session ID and password, only place available and big
|
|
// enough is on WorkDir and StartProgram property, TermSrv will
|
|
// ignore these and fill appropriate value for it
|
|
//
|
|
hr = ptsSecuredSettings->put_WorkDir( m_HelpSessionID );
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_WorkDir: 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = ptsSecuredSettings->put_StartProgram( m_HelpSessionPwd );
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"put_StartProgram: 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
ptsSecuredSettings->Release();
|
|
|
|
|
|
// we only use this to disable redirection, not a critical
|
|
// error, just ugly
|
|
|
|
hr = m_TSClient->QueryInterface(IID_IMsTscNonScriptable,
|
|
(void**)&ptsns);
|
|
if(!SUCCEEDED(hr) || !ptsns){
|
|
TRC_ERR((TB, L"QueryInterface IID_IMsTscNonScriptable: %ld", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
// password in workdir, stuff something into password field
|
|
hr = ptsns->put_ClearTextPassword( m_AssistantAccountPwd );
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"put_ClearTextPassword: 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
m_ExpertBlob = bstrExpertBlob;
|
|
|
|
//
|
|
// Instruct mstscax to connect with certain screen resolution,
|
|
// mstscax will default to 200x20 (???), min. is VGA size.
|
|
//
|
|
{
|
|
RECT rect;
|
|
LONG cx;
|
|
LONG cy;
|
|
|
|
GetClientRect(&rect);
|
|
cx = rect.right - rect.left;
|
|
cy = rect.bottom - rect.top;
|
|
|
|
if( cx < 640 || cy < 480 )
|
|
{
|
|
cx = 640;
|
|
cy = 480;
|
|
}
|
|
|
|
m_TSClient->put_DesktopWidth(cx);
|
|
m_TSClient->put_DesktopHeight(cy);
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if(ptsns)
|
|
{
|
|
ptsns->Release();
|
|
ptsns = NULL;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::AcceptListenConnection(
|
|
BSTR bstrExpertBlob
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Establish reverse connection with TS server, TS server must be connected
|
|
wia reverse connection.
|
|
|
|
Parameters:
|
|
|
|
bstrExpertBlob : Same as ConnectToServer().
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::AcceptListenConnection");
|
|
|
|
//
|
|
// If we are already connected or not valid, then just
|
|
// return.
|
|
//
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_ConnectedToServer || m_ConnectionInProgress) {
|
|
TRC_ERR((TB, L"Connection active"));
|
|
hr = HRESULT_FROM_WIN32(ERROR_CONNECTION_ACTIVE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( !ListenConnectInProgress() ) {
|
|
TRC_ERR((TB, L"Connection in-active"));
|
|
hr = HRESULT_FROM_WIN32(ERROR_CONNECTION_INVALID);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( INVALID_SOCKET == m_TSConnectSocket ) {
|
|
TRC_ERR((TB, L"Socket is not connected"));
|
|
hr = HRESULT_FROM_WIN32(ERROR_CONNECTION_INVALID);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = SetupConnectionInfo(TRUE, bstrExpertBlob);
|
|
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"SetupConnectionInfo() failed with 0x%08x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = ConnectServerWithOpenedSocket();
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
m_ConnectionInProgress = SUCCEEDED(hr);
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::ConnectToServer(BSTR bstrExpertBlob)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Connects the client component to the server-side Remote Desktop Host COM
|
|
Object.
|
|
|
|
Arguments:
|
|
|
|
bstrExpertBlob : Optional parameter to be transmitted to SAF resolver.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
Params--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::ConnectToServer");
|
|
|
|
HRESULT hr = S_OK;
|
|
ServerAddress address;
|
|
|
|
//
|
|
// If we are already connected or not valid, then just
|
|
// return.
|
|
//
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_ConnectedToServer || m_ConnectionInProgress) {
|
|
TRC_ERR((TB, L"Connection active"));
|
|
hr = HRESULT_FROM_WIN32(ERROR_CONNECTION_ACTIVE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = SetupConnectionInfo(FALSE, bstrExpertBlob);
|
|
|
|
address = m_ServerAddressList.front();
|
|
m_ServerAddressList.pop_front();
|
|
|
|
hr = ConnectServerPort(address.ServerName, address.portNumber);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, L"ConnectServerPort: %08X", hr));
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
//
|
|
// If we succeeded, remember that we are in a state of connecting.
|
|
//
|
|
m_ConnectionInProgress = SUCCEEDED(hr);
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::DisconnectFromServer()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Disconnects the client from the server to which we are currently
|
|
connected.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
return DisconnectFromServerInternal(
|
|
SAFERROR_LOCALNOTERROR
|
|
);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::DisconnectFromServerInternal(
|
|
LONG errorCode
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Disconnects the client from the server to which we are currently
|
|
connected.
|
|
|
|
Arguments:
|
|
|
|
reason - Reason for disconnect.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::DisconnectFromServerInternal");
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Make sure our window is hidden.
|
|
//
|
|
//ShowWindow(SW_HIDE);
|
|
|
|
ListenConnectCleanup();
|
|
|
|
if (m_ConnectedToServer || m_ConnectionInProgress) {
|
|
hr = m_TSClient->Disconnect();
|
|
if (SUCCEEDED(hr)) {
|
|
|
|
m_ConnectionInProgress = FALSE;
|
|
m_ConnectedToServer = FALSE;
|
|
|
|
if (m_RemoteControlRequestInProgress) {
|
|
m_RemoteControlRequestInProgress = FALSE;
|
|
Fire_RemoteControlRequestComplete(SAFERROR_SHADOWEND_UNKNOWN);
|
|
}
|
|
|
|
//
|
|
// Fire the server disconnect event.
|
|
//
|
|
Fire_Disconnected(errorCode);
|
|
}
|
|
}
|
|
else {
|
|
TRC_NRM((TB, L"Not connected."));
|
|
hr = S_OK;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::ConnectRemoteDesktop()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Once "remote desktop mode" has been enabled for the server-side Remote
|
|
Desktop Host COM Object and we are connected to the server, the
|
|
ConnectRemoteDesktop method can be invoked to take control of the remote
|
|
user's desktop.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::ConnectRemoteDesktop");
|
|
|
|
HRESULT hr = S_OK;
|
|
DWORD result;
|
|
BSTR rcRequest = NULL;
|
|
|
|
//
|
|
// Fail if we are not valid or not connected to the server.
|
|
//
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
if (!m_ConnectedToServer) {
|
|
hr = HRESULT_FROM_WIN32(ERROR_DEVICE_NOT_CONNECTED);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Succeed if a remote control request is already in progress.
|
|
//
|
|
if (m_RemoteControlRequestInProgress) {
|
|
hr = S_OK;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Generate the remote control connect request message.
|
|
//
|
|
hr = GenerateRCRequest(&rcRequest);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Send it.
|
|
//
|
|
hr = m_CtlChannel->SendChannelData(rcRequest);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// A request is in progress, if we successfully sent the request.
|
|
//
|
|
m_RemoteControlRequestInProgress = TRUE;
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if (rcRequest != NULL) {
|
|
SysFreeString(rcRequest);
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::DisconnectRemoteDesktop()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Once "remote desktop mode" has been enabled for the server-side Remote
|
|
Desktop Host COM Object and we are connected to the server, the
|
|
ConnectRemoteDesktop method can be invoked to take control of the remote
|
|
user's desktop.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::DisconnectRemoteDesktop");
|
|
|
|
HRESULT hr = S_OK;
|
|
CComBSTR rcRequest;
|
|
|
|
//
|
|
// Fail if we are not valid or not connected.
|
|
//
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
if (!m_ConnectedToServer) {
|
|
hr = HRESULT_FROM_WIN32(ERROR_DEVICE_NOT_CONNECTED);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Generate the terminate remote control key sequence and sent it to the
|
|
// server.
|
|
//
|
|
if (m_RemoteControlRequestInProgress) {
|
|
hr = SendTerminateRCKeysToServer();
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// ISAFRemoteDesktopTestExtension
|
|
//
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::put_TestExtDllName(/*[in]*/ BSTR newVal)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
IMsTscAdvancedSettings *pMstscAdvSettings = NULL;
|
|
IMsTscDebug *pMstscDebug = NULL;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_TestExtDllName" );
|
|
|
|
if ( NULL == m_TSClient )
|
|
{
|
|
TRC_ERR((TB, L"m_TSClient is NULL" ));
|
|
hr = E_NOINTERFACE;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_AdvancedSettings( &pMstscAdvSettings );
|
|
if (FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"m_TSClient->get_AdvancedSettings failed %08X", hr ));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_Debugger( &pMstscDebug );
|
|
if ( FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"m_TSClient->get_Debugger failed %08X", hr ));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = pMstscAdvSettings->put_allowBackgroundInput( 1 );
|
|
if (FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"put_allowBackgroundInput failed %08X", hr ));
|
|
}
|
|
pMstscDebug->put_CLXDll( newVal );
|
|
|
|
CLEANUPANDEXIT:
|
|
if ( NULL != pMstscAdvSettings )
|
|
pMstscAdvSettings->Release();
|
|
|
|
if ( NULL != pMstscDebug )
|
|
pMstscDebug->Release();
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::put_TestExtParams(/*[in]*/ BSTR newVal)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
IMsTscDebug *pMstscDebug = NULL;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_TestExtParams" );
|
|
|
|
if ( NULL == m_TSClient )
|
|
{
|
|
TRC_ERR((TB, L"m_TSClient is NULL" ));
|
|
hr = E_NOINTERFACE;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_Debugger( &pMstscDebug );
|
|
if (FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"m_TSClient->get_Debugger failed %08X", hr ));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = pMstscDebug->put_CLXCmdLine( newVal );
|
|
|
|
CLEANUPANDEXIT:
|
|
if ( NULL != pMstscDebug )
|
|
pMstscDebug->Release();
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::OnMSTSCReceiveData(
|
|
BSTR data
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handle Remote Control Control Channel messages.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnMSTSCReceiveData");
|
|
|
|
//
|
|
//we got some data, so we must be connected, update timer
|
|
//
|
|
m_PrevTimer = GetTickCount();
|
|
|
|
//
|
|
// Fire the data ready event.
|
|
//
|
|
Fire_DataReady(data);
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::HandleControlChannelMsg()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handle Remote Control Control Channel messages.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::HandleControlChannelMsg");
|
|
|
|
PREMOTEDESKTOP_CTL_BUFHEADER msgHeader;
|
|
BSTR msg = NULL;
|
|
LONG *pResult;
|
|
BSTR authenticateReq = NULL;
|
|
BSTR versionInfoPacket = NULL;
|
|
HRESULT hr;
|
|
|
|
DWORD result;
|
|
|
|
ASSERT(IsValid());
|
|
|
|
//
|
|
// Read the next message.
|
|
//
|
|
result = m_CtlChannel->ReceiveChannelData(&msg);
|
|
if (result != ERROR_SUCCESS) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Dispatch, based on the message type.
|
|
//
|
|
msgHeader = (PREMOTEDESKTOP_CTL_BUFHEADER)msg;
|
|
|
|
//
|
|
// If the server-side of the VC link is alive.
|
|
//
|
|
//
|
|
if ((msgHeader->msgType == REMOTEDESKTOP_CTL_SERVER_ANNOUNCE) &&
|
|
m_ConnectionInProgress) {
|
|
|
|
//
|
|
// Send version information to the server.
|
|
//
|
|
hr = GenerateVersionInfoPacket(
|
|
&versionInfoPacket
|
|
);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
hr = m_CtlChannel->SendChannelData(versionInfoPacket);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Request client authentication.
|
|
//
|
|
hr = GenerateClientAuthenticateRequest(
|
|
&authenticateReq
|
|
);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
hr = m_CtlChannel->SendChannelData(authenticateReq);
|
|
}
|
|
//
|
|
// If the message is from the server, indicating that it is
|
|
// disconnecting. This can happen if the RDSRemoteDesktopServer
|
|
// is directed to exit listening mode.
|
|
//
|
|
else if (msgHeader->msgType == REMOTEDESKTOP_CTL_DISCONNECT) {
|
|
TRC_NRM((TB, L"Server indicated a disconnect."));
|
|
DisconnectFromServerInternal(SAFERROR_BYSERVER);
|
|
}
|
|
//
|
|
// If the message is a message result.
|
|
//
|
|
else if (msgHeader->msgType == REMOTEDESKTOP_CTL_RESULT) {
|
|
|
|
pResult = (LONG *)(msgHeader+1);
|
|
|
|
//
|
|
// If a remote control request is in progress, then we should check
|
|
// for a remote control complete status.
|
|
//
|
|
if (m_RemoteControlRequestInProgress && ISRCSTATUSCODE(*pResult)) {
|
|
|
|
TRC_ERR((TB, L"Received RC terminate status code."));
|
|
|
|
m_RemoteControlRequestInProgress = FALSE;
|
|
Fire_RemoteControlRequestComplete(*pResult);
|
|
}
|
|
//
|
|
// Otherwise, if a connection is in progress, then the client
|
|
// authentication request must have succeeded.
|
|
//
|
|
else if (m_ConnectionInProgress) {
|
|
|
|
//
|
|
// Should not be getting a remote control status here.
|
|
//
|
|
ASSERT(!ISRCSTATUSCODE(*pResult));
|
|
|
|
//
|
|
// Fire connect request succeeded message.
|
|
//
|
|
if (*pResult == SAFERROR_NOERROR ) {
|
|
m_ConnectedToServer = TRUE;
|
|
m_ConnectionInProgress = FALSE;
|
|
|
|
//
|
|
//set the timer to check if the user is still connected
|
|
//ignore errors, worst case - the ui is up even after the user disconnects
|
|
//
|
|
if( m_RdcConnCheckTimeInterval )
|
|
m_TimerId = SetTimer(WM_CONNECTCHECK_TIMER, m_RdcConnCheckTimeInterval);
|
|
|
|
//
|
|
// Not in progress once connected
|
|
//
|
|
m_ListenConnectInProgress = FALSE;
|
|
m_TSConnectSocket = INVALID_SOCKET;
|
|
|
|
Fire_Connected();
|
|
}
|
|
//
|
|
// Otherwise, fire a disconnected event.
|
|
//
|
|
else {
|
|
DisconnectFromServerInternal(*pResult);
|
|
m_ConnectionInProgress = FALSE;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// We will ignore other packets to support forward compatibility.
|
|
//
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
//
|
|
// Release the message.
|
|
//
|
|
if (msg != NULL) {
|
|
SysFreeString(msg);
|
|
}
|
|
|
|
if (versionInfoPacket != NULL) {
|
|
SysFreeString(versionInfoPacket);
|
|
}
|
|
|
|
if (authenticateReq != NULL) {
|
|
SysFreeString(authenticateReq);
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::GenerateRCRequest(
|
|
BSTR *rcRequest
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Generate a remote control request message for the
|
|
server.
|
|
|
|
TODO: We might need to be able to push this up
|
|
to the parent class, if it makes sense for
|
|
NetMeeting.
|
|
|
|
Arguments:
|
|
|
|
rcRequest - Returned request message.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::GenerateRCRequest");
|
|
|
|
PREMOTEDESKTOP_CTL_BUFHEADER msgHeader;
|
|
PBYTE ptr;
|
|
HRESULT hr;
|
|
DWORD len;
|
|
|
|
len = sizeof(REMOTEDESKTOP_CTL_BUFHEADER) + ((m_ConnectParms.Length()+1) * sizeof(WCHAR));
|
|
|
|
msgHeader = (PREMOTEDESKTOP_CTL_BUFHEADER)SysAllocStringByteLen(NULL, len);
|
|
if (msgHeader != NULL) {
|
|
msgHeader->msgType = REMOTEDESKTOP_CTL_REMOTE_CONTROL_DESKTOP;
|
|
ptr = (PBYTE)(msgHeader + 1);
|
|
memcpy(ptr, (BSTR)m_ConnectParms,
|
|
((m_ConnectParms.Length()+1) * sizeof(WCHAR)));
|
|
*rcRequest = (BSTR)msgHeader;
|
|
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"SysAllocStringByteLen failed for %ld bytes", len));
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::GenerateClientAuthenticateRequest(
|
|
BSTR *authenticateReq
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Generate a 'client authenticate' request.
|
|
|
|
TODO: We might need to be able to push this up
|
|
to the parent class, if it makes sense for
|
|
NetMeeting.
|
|
|
|
Arguments:
|
|
|
|
rcRequest - Returned request message.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::GenerateClientAuthenticateRequest");
|
|
|
|
PREMOTEDESKTOP_CTL_BUFHEADER msgHeader;
|
|
PBYTE ptr;
|
|
HRESULT hr;
|
|
DWORD len;
|
|
|
|
len = sizeof(REMOTEDESKTOP_CTL_BUFHEADER) + ((m_ConnectParms.Length()+1) * sizeof(WCHAR));
|
|
|
|
#if FEATURE_USERBLOBS
|
|
|
|
if( m_ExpertBlob.Length() > 0 ) {
|
|
len += ((m_ExpertBlob.Length() + 1) * sizeof(WCHAR));
|
|
}
|
|
|
|
#endif
|
|
|
|
msgHeader = (PREMOTEDESKTOP_CTL_BUFHEADER)SysAllocStringByteLen(NULL, len);
|
|
if (msgHeader != NULL) {
|
|
msgHeader->msgType = REMOTEDESKTOP_CTL_AUTHENTICATE;
|
|
ptr = (PBYTE)(msgHeader + 1);
|
|
memcpy(ptr, (BSTR)m_ConnectParms,
|
|
((m_ConnectParms.Length()+1) * sizeof(WCHAR)));
|
|
|
|
#if FEATURE_USERBLOBS
|
|
|
|
if( m_ExpertBlob.Length() > 0 ) {
|
|
ptr += ((m_ConnectParms.Length()+1) * sizeof(WCHAR));
|
|
memcpy(ptr, (BSTR)m_ExpertBlob,
|
|
((m_ExpertBlob.Length()+1) * sizeof(WCHAR)));
|
|
}
|
|
|
|
#endif
|
|
|
|
*authenticateReq = (BSTR)msgHeader;
|
|
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"SysAllocStringByteLen failed for %ld bytes", len));
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::GenerateVersionInfoPacket(
|
|
BSTR *versionInfoPacket
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Generate a version information packet.
|
|
|
|
Arguments:
|
|
|
|
versionInfoPacket - Version Information Returned Packet
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::GenerateVersionInfoPacket");
|
|
|
|
PREMOTEDESKTOP_CTL_BUFHEADER msgHeader;
|
|
PDWORD ptr;
|
|
HRESULT hr;
|
|
DWORD len;
|
|
|
|
len = sizeof(REMOTEDESKTOP_CTL_BUFHEADER) + (sizeof(DWORD) * 2);
|
|
|
|
msgHeader = (PREMOTEDESKTOP_CTL_BUFHEADER)SysAllocStringByteLen(NULL, len);
|
|
if (msgHeader != NULL) {
|
|
msgHeader->msgType = REMOTEDESKTOP_CTL_VERSIONINFO;
|
|
ptr = (PDWORD)(msgHeader + 1);
|
|
*ptr = REMOTEDESKTOP_VERSION_MAJOR; ptr++;
|
|
*ptr = REMOTEDESKTOP_VERSION_MINOR;
|
|
*versionInfoPacket = (BSTR)msgHeader;
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"SysAllocStringByteLen failed for %ld bytes", len));
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::OnReceivedTSPublicKey(BSTR bstrPublicKey, VARIANT_BOOL* pfContinue)
|
|
{
|
|
DWORD dwStatus;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnReceivedPublicKey");
|
|
CComBSTR bstrTSPublicKey;
|
|
|
|
if( m_ConnectParmVersion >= SALEM_CONNECTPARM_SECURITYBLOB_VERSION ) {
|
|
|
|
//
|
|
// hash TS public key send from client activeX control, reverse
|
|
// hashing from what we got in connect parm might not give us
|
|
// back the original value.
|
|
//
|
|
dwStatus = HashSecurityData(
|
|
(PBYTE) bstrPublicKey,
|
|
::SysStringByteLen(bstrPublicKey),
|
|
bstrTSPublicKey
|
|
);
|
|
|
|
if( ERROR_SUCCESS != dwStatus )
|
|
{
|
|
TRC_ERR((TB, L"Hashed Public Key Send from TS %s", bstrPublicKey));
|
|
TRC_ERR((TB, L"Hashed public Key in parm %s", m_TSSecurityBlob));
|
|
TRC_ERR((TB, L"HashSecurityData() failed with %d", dwStatus));
|
|
*pfContinue = FALSE;
|
|
}
|
|
else if( !(bstrTSPublicKey == m_TSSecurityBlob) )
|
|
{
|
|
TRC_ERR((TB, L"Hashed Public Key Send from TS %s", bstrPublicKey));
|
|
TRC_ERR((TB, L"Hashed public Key in parm %s", m_TSSecurityBlob));
|
|
|
|
*pfContinue = FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pfContinue = TRUE;
|
|
}
|
|
}
|
|
else {
|
|
*pfContinue = TRUE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::OnRDPConnected()
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnRDPConnected");
|
|
|
|
Fire_BeginConnect();
|
|
DC_END_FN();
|
|
}
|
|
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::OnLoginComplete()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnLoginComplete");
|
|
|
|
//
|
|
// Clear server address list
|
|
//
|
|
m_ServerAddressList.clear();
|
|
|
|
//
|
|
// We got some event from the mstsc, so we must be connected, update timer
|
|
//
|
|
m_PrevTimer = GetTickCount();
|
|
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
LONG
|
|
CTSRDPRemoteDesktopClient::TranslateMSTSCDisconnectCode(
|
|
DisconnectReasonCode disconReason,
|
|
ExtendedDisconnectReasonCode extendedReasonCode
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Translate an MSTSC disconnect code into a Salem disconnect
|
|
code.
|
|
|
|
Arguments:
|
|
|
|
disconReason - Disconnect Reason
|
|
extendedReasonCode - MSTSCAX Extended Reason Code
|
|
|
|
Return Value:
|
|
|
|
Salem disconnect code.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::TranslateMSTSCDisconnectCode");
|
|
|
|
LONG ret;
|
|
BOOL handled;
|
|
|
|
//
|
|
// First check the extended error information.
|
|
// TODO: Need to keep track of additional values added by NadimA
|
|
// and company, here, before we ship.
|
|
//
|
|
if (extendedReasonCode != exDiscReasonNoInfo) {
|
|
//
|
|
// Record the extended error code, if given. Note that this may be
|
|
// overridden below if we have better information.
|
|
//
|
|
m_LastExtendedErrorInfo = extendedReasonCode;
|
|
|
|
//
|
|
// Check for a protocol error.
|
|
//
|
|
if ((extendedReasonCode >= exDiscReasonProtocolRangeStart) &&
|
|
(extendedReasonCode <= exDiscReasonProtocolRangeEnd)) {
|
|
ret = SAFERROR_RCPROTOCOLERROR;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the extended error information didn't help us.
|
|
//
|
|
switch(disconReason)
|
|
{
|
|
case disconnectReasonNoInfo : ret = SAFERROR_NOINFO;
|
|
break;
|
|
|
|
case 0xb08: // UI_ERR_NORMAL_DISCONNECT not defined in mstsax.idl
|
|
case disconnectReasonLocalNotError : ret = SAFERROR_LOCALNOTERROR;
|
|
break;
|
|
|
|
case disconnectReasonRemoteByUser : ret = SAFERROR_REMOTEBYUSER;
|
|
break;
|
|
|
|
case disconnectReasonByServer : ret = SAFERROR_BYSERVER;
|
|
break;
|
|
|
|
case disconnectReasonDNSLookupFailed2 : m_LastExtendedErrorInfo = disconReason;
|
|
case disconnectReasonDNSLookupFailed : ret = SAFERROR_DNSLOOKUPFAILED;
|
|
break;
|
|
|
|
case disconnectReasonOutOfMemory3 :
|
|
case disconnectReasonOutOfMemory2 : m_LastExtendedErrorInfo = disconReason;
|
|
case disconnectReasonOutOfMemory : ret = SAFERROR_OUTOFMEMORY;
|
|
break;
|
|
|
|
case disconnectReasonConnectionTimedOut : ret = SAFERROR_CONNECTIONTIMEDOUT;
|
|
break;
|
|
|
|
case disconnectReasonSocketConnectFailed :
|
|
case 0x904 : ret = SAFERROR_SOCKETCONNECTFAILED; // NadimA is adding to
|
|
// MSTSCAX IDL. This is a
|
|
// NL_ERR_TDFDCLOSE error.
|
|
break;
|
|
|
|
case disconnectReasonHostNotFound : ret = SAFERROR_HOSTNOTFOUND;
|
|
break;
|
|
|
|
case disconnectReasonWinsockSendFailed : ret = SAFERROR_WINSOCKSENDFAILED;
|
|
break;
|
|
|
|
case disconnectReasonInvalidIP : m_LastExtendedErrorInfo = disconReason;
|
|
case disconnectReasonInvalidIPAddr : ret = SAFERROR_INVALIDIPADDR;
|
|
break;
|
|
|
|
case disconnectReasonSocketRecvFailed : ret = SAFERROR_SOCKETRECVFAILED;
|
|
break;
|
|
|
|
case disconnectReasonInvalidEncryption : ret = SAFERROR_INVALIDENCRYPTION;
|
|
break;
|
|
|
|
case disconnectReasonGetHostByNameFailed : ret = SAFERROR_GETHOSTBYNAMEFAILED;
|
|
break;
|
|
|
|
case disconnectReasonLicensingFailed : m_LastExtendedErrorInfo = disconReason;
|
|
case disconnectReasonLicensingTimeout : ret = SAFERROR_LICENSINGFAILED;
|
|
break;
|
|
|
|
case disconnectReasonDecryptionError : ret = SAFERROR_DECRYPTIONERROR;
|
|
break;
|
|
|
|
case disconnectReasonServerCertificateUnpackErr : ret = SAFERROR_MISMATCHPARMS;
|
|
break;
|
|
|
|
default: ret = SAFERROR_RCUNKNOWNERROR;
|
|
m_LastExtendedErrorInfo = disconReason;
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
DC_END_FN();
|
|
return ret;
|
|
}
|
|
|
|
VOID
|
|
CTSRDPRemoteDesktopClient::OnDisconnected(
|
|
long disconReason
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnDisconnected");
|
|
HRESULT hr = E_HANDLE; // initialize an error code.
|
|
|
|
long clientReturnCode;
|
|
ExtendedDisconnectReasonCode extendedClientCode;
|
|
|
|
TRC_ERR((TB, L"Disconnected because %ld", disconReason));
|
|
|
|
m_TSClient->get_ExtendedDisconnectReason(&extendedClientCode);
|
|
clientReturnCode = TranslateMSTSCDisconnectCode(
|
|
(DisconnectReasonCode)disconReason,
|
|
extendedClientCode
|
|
);
|
|
|
|
// Go thru all remaining server:port, mstscax might return some
|
|
// error code that we don't understand.
|
|
if( m_ServerAddressList.size() > 0 ) {
|
|
|
|
ServerAddress address;
|
|
|
|
address = m_ServerAddressList.front();
|
|
m_ServerAddressList.pop_front();
|
|
|
|
hr = ConnectServerPort( address.ServerName, address.portNumber );
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, L"ConnectServerPort: %08X", hr));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the error code from connecting to 'last' server to client
|
|
//
|
|
if( FAILED(hr) ) {
|
|
|
|
m_ServerAddressList.clear();
|
|
|
|
//
|
|
// Fire the server disconnect event, if we are really connected or
|
|
// we have a connection in progress.
|
|
//
|
|
if (m_ConnectedToServer || m_ConnectionInProgress) {
|
|
Fire_Disconnected(clientReturnCode);
|
|
}
|
|
|
|
m_ConnectedToServer = FALSE;
|
|
m_ConnectionInProgress = FALSE;
|
|
|
|
ListenConnectCleanup();
|
|
|
|
//
|
|
// Fire the remote control request failure event, if appropriate.
|
|
//
|
|
if (m_RemoteControlRequestInProgress) {
|
|
ASSERT(clientReturnCode != SAFERROR_NOERROR);
|
|
Fire_RemoteControlRequestComplete(SAFERROR_SHADOWEND_UNKNOWN);
|
|
m_RemoteControlRequestInProgress = FALSE;
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::SendTerminateRCKeysToServer()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Send the terminate shadowing key sequence to the server.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error status is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::SendTerminateRCKeysToServer");
|
|
|
|
HRESULT hr = S_OK;
|
|
IMsRdpClientNonScriptable* pTscNonScript = NULL;
|
|
|
|
VARIANT_BOOL keyUp[] = {
|
|
VARIANT_FALSE, VARIANT_FALSE, VARIANT_TRUE, VARIANT_TRUE
|
|
};
|
|
LONG keyData[] = {
|
|
MapVirtualKey(VK_CONTROL, 0), // these are SCANCODES.
|
|
MapVirtualKey(VK_MULTIPLY, 0),
|
|
MapVirtualKey(VK_MULTIPLY, 0),
|
|
MapVirtualKey(VK_CONTROL, 0),
|
|
};
|
|
|
|
//
|
|
// Send the terminate keys to the server.
|
|
//
|
|
hr = m_TSClient->QueryInterface(
|
|
IID_IMsRdpClientNonScriptable,
|
|
(void**)&pTscNonScript
|
|
);
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"QI: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
pTscNonScript->NotifyRedirectDeviceChange(0, 0);
|
|
pTscNonScript->SendKeys(4, keyUp, keyData);
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"SendKeys, QI: %08X", hr));
|
|
}
|
|
|
|
pTscNonScript->Release();
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HWND CTSRDPRemoteDesktopClient::SearchForWindow(
|
|
HWND hwndParent,
|
|
LPTSTR srchCaption,
|
|
LPTSTR srchClass
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Search for a child window of the specified parent window.
|
|
|
|
Arguments:
|
|
|
|
srchCaption - Window caption for which to search. NULL is
|
|
considered a wildcard.
|
|
srchClass - Window class for which to search. NULL is
|
|
considred a wildcard.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error status is returned.
|
|
|
|
--*/
|
|
{
|
|
WINSEARCH srch;
|
|
|
|
srch.foundWindow = NULL;
|
|
srch.srchCaption = srchCaption;
|
|
srch.srchClass = srchClass;
|
|
|
|
BOOL result = EnumChildWindows(
|
|
hwndParent,
|
|
(WNDENUMPROC)_WindowSrchProc,
|
|
(LPARAM)&srch
|
|
);
|
|
|
|
return srch.foundWindow;
|
|
}
|
|
BOOL CALLBACK
|
|
CTSRDPRemoteDesktopClient::_WindowSrchProc(HWND hwnd, PWINSEARCH srch)
|
|
{
|
|
TCHAR classname[128];
|
|
TCHAR caption[128];
|
|
|
|
if (srch->srchClass && !GetClassName(hwnd, classname, sizeof(classname) / sizeof(TCHAR)))
|
|
{
|
|
return TRUE;
|
|
}
|
|
if (srch->srchCaption && !::GetWindowText(hwnd, caption, sizeof(caption)/sizeof(TCHAR)))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if ((!srch->srchClass || !_tcscmp(classname, srch->srchClass)
|
|
&&
|
|
(!srch->srchCaption || !_tcscmp(caption, srch->srchCaption)))
|
|
)
|
|
{
|
|
srch->foundWindow = hwnd;
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::GenerateNullData( BSTR* pbstrData )
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::GenerateNullData");
|
|
HRESULT hr;
|
|
DWORD len;
|
|
|
|
PREMOTEDESKTOP_CTL_BUFHEADER msgHeader = NULL;
|
|
len = sizeof( REMOTEDESKTOP_CTL_BUFHEADER );
|
|
|
|
msgHeader = (PREMOTEDESKTOP_CTL_BUFHEADER)SysAllocStringByteLen(NULL, len);
|
|
if (msgHeader != NULL) {
|
|
msgHeader->msgType = REMOTEDESKTOP_CTL_ISCONNECTED;
|
|
//nothing else other than the message
|
|
*pbstrData = (BSTR)msgHeader;
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, L"SysAllocStringByteLen failed for %ld bytes", len));
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
LRESULT CTSRDPRemoteDesktopClient::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnCheckConnectTimer");
|
|
BSTR bstrMsg = NULL;
|
|
|
|
if( WM_LISTENTIMEOUT_TIMER == wParam ) {
|
|
|
|
bHandled = TRUE;
|
|
if( TRUE == ListenConnectInProgress() ) {
|
|
StopListen();
|
|
Fire_ListenConnect( SAFERROR_CONNECTIONTIMEDOUT );
|
|
}
|
|
}
|
|
else if ( WM_CONNECTCHECK_TIMER == wParam ) {
|
|
DWORD dwCurTimer = GetTickCount();
|
|
|
|
bHandled = TRUE;
|
|
|
|
if(m_ConnectedToServer) {
|
|
//
|
|
//see if the timer wrapped around to zero (does so if the system was up 49.7 days or something)
|
|
//if so reset it
|
|
//
|
|
if( dwCurTimer > m_PrevTimer && ( dwCurTimer - m_PrevTimer >= m_RdcConnCheckTimeInterval )) {
|
|
//
|
|
//time to send a null data
|
|
//
|
|
if(SUCCEEDED(GenerateNullData(&bstrMsg))) {
|
|
if(!SUCCEEDED(m_CtlChannel->SendChannelData(bstrMsg))) {
|
|
//
|
|
//could not send data, assume disconnected
|
|
//
|
|
DisconnectFromServer();
|
|
//
|
|
//don't need the timer anymore, kill it
|
|
//
|
|
KillTimer( m_TimerId );
|
|
m_TimerId = 0;
|
|
}
|
|
}
|
|
}
|
|
} //m_ConnectedToServer
|
|
|
|
//
|
|
//update the timer
|
|
//
|
|
m_PrevTimer = dwCurTimer;
|
|
|
|
if( NULL != bstrMsg ) {
|
|
SysFreeString(bstrMsg);
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
return 0;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::CreateListenEndpoint(
|
|
IN LONG port,
|
|
OUT BSTR* pConnectParm
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Routine to create a listening socket and return connection parameter to this 'listen' socket.
|
|
|
|
Parameters:
|
|
|
|
port : Port that socket should listen on.
|
|
pConnectParm : Return connection parameter to this listening socket.
|
|
|
|
returns:
|
|
|
|
S_OK or error code.
|
|
|
|
Notes:
|
|
|
|
Function is async, return code, if error, is for listening thread set up, caller is notified of
|
|
successful or error in network connection via ListenConnect event.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
SOCKET hListenSocket = INVALID_SOCKET;
|
|
IMsRdpClientAdvancedSettings* pAdvSettings;
|
|
LONG rdpPort = 0;
|
|
int intRC;
|
|
int lastError;
|
|
SOCKADDR_IN sockAddr;
|
|
int sockAddrSize;
|
|
int optvalue;
|
|
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::CreateListenEndpoint");
|
|
|
|
if( NULL == pConnectParm )
|
|
{
|
|
hr = E_POINTER;
|
|
return hr;
|
|
}
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Return error if we are in progress of connect or connected.
|
|
//
|
|
if( TRUE == ListenConnectInProgress() || // Listen already started.
|
|
TRUE == m_ConnectionInProgress || // Connection already in progress
|
|
TRUE == m_ConnectedToServer ) { // Already connected to server
|
|
hr = HRESULT_FROM_WIN32( ERROR_SHARING_VIOLATION );
|
|
TRC_ERR((TB, L"StartListen() already in listen"));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Initialize Winsock and ICS library if not yet initialized.
|
|
// InitListeningLibrary() will only add ref. count
|
|
// if library already initialized by other instance.
|
|
//
|
|
if( FALSE == m_InitListeningLibrary ) {
|
|
|
|
hr = InitListeningLibrary();
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"InitListeningLibrary() failed : %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
m_InitListeningLibrary = TRUE;
|
|
}
|
|
|
|
//
|
|
// mstscax will close the socket once connection is ended.
|
|
//
|
|
m_TSConnectSocket = INVALID_SOCKET;
|
|
|
|
//
|
|
// Create a listening socket
|
|
//
|
|
m_ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
|
|
if( INVALID_SOCKET == m_ListenSocket ) {
|
|
intRC = WSAGetLastError();
|
|
TRC_ERR((TB, _T("socket failed %d"), intRC));
|
|
hr = HRESULT_FROM_WIN32(intRC);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Disable NAGLE algorithm and enable don't linger option.
|
|
//
|
|
optvalue = 1;
|
|
setsockopt( m_ListenSocket, IPPROTO_TCP, TCP_NODELAY, (char *)&optvalue, sizeof(optvalue) );
|
|
|
|
optvalue = 1;
|
|
setsockopt( m_ListenSocket, SOL_SOCKET, SO_DONTLINGER, (char *)&optvalue, sizeof(optvalue) );
|
|
|
|
|
|
//
|
|
// Request async notifications to send to our window
|
|
//
|
|
intRC = WSAAsyncSelect(
|
|
m_ListenSocket,
|
|
m_hWnd,
|
|
WM_TSCONNECT,
|
|
FD_ACCEPT
|
|
);
|
|
|
|
if(SOCKET_ERROR == intRC) {
|
|
intRC = WSAGetLastError();
|
|
|
|
TRC_ERR((TB, _T("WSAAsyncSelect failed %d"), intRC));
|
|
hr = HRESULT_FROM_WIN32(intRC);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
sockAddr.sin_family = AF_INET;
|
|
sockAddr.sin_port = htons(port);
|
|
sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);;
|
|
|
|
intRC = bind( m_ListenSocket, (struct sockaddr *) &sockAddr, sizeof(sockAddr) );
|
|
if( SOCKET_ERROR == intRC ) {
|
|
lastError = WSAGetLastError();
|
|
TRC_ERR((TB, _T("bind failed - %d"), lastError));
|
|
hr = HRESULT_FROM_WIN32( lastError );
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( 0 == port ) {
|
|
//
|
|
// Retrieve which port we are listening
|
|
//
|
|
sockAddrSize = sizeof( sockAddr );
|
|
intRC = getsockname(
|
|
m_ListenSocket,
|
|
(struct sockaddr *)&sockAddr,
|
|
&sockAddrSize
|
|
);
|
|
if( SOCKET_ERROR == intRC )
|
|
{
|
|
lastError = WSAGetLastError();
|
|
TRC_ERR((TB, _T("getsockname failed - GLE:%d"),lastError));
|
|
hr = HRESULT_FROM_WIN32( lastError );
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
m_ConnectedPort = ntohs(sockAddr.sin_port);
|
|
}
|
|
else {
|
|
m_ConnectedPort = port;
|
|
}
|
|
|
|
TRC_ERR((TB, _T("Listenin on port %d"),m_ConnectedPort));
|
|
|
|
//
|
|
// Tell ICS library to punch a hole thru ICS, no-op
|
|
// if not ICS configuration.
|
|
//
|
|
m_ICSPort = OpenPort( m_ConnectedPort );
|
|
|
|
//
|
|
// Retrieve connection parameters for this client (expert).
|
|
//
|
|
hr = RetrieveUserConnectParm( pConnectParm );
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, _T("RetrieveUserConnectParm failed - 0x%08x"),hr));
|
|
}
|
|
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if( FAILED(hr) ) {
|
|
StopListen();
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::StopListen()
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Stop listening waiting for TS server (helpee, user) to connect.
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::StopListen");
|
|
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|
|
// End listening, either we are actually issued a listen() to socket
|
|
// or we just created the listen socket but not yet start listening
|
|
if( TRUE == ListenConnectInProgress() || INVALID_SOCKET != m_ListenSocket ) {
|
|
ListenConnectCleanup();
|
|
Fire_ListenConnect( SAFERROR_STOPLISTENBYUSER );
|
|
}
|
|
else {
|
|
TRC_ERR((TB, _T("StopListen called while not in listen mode")));
|
|
hr = HRESULT_FROM_WIN32( WSANOTINITIALISED );
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
LRESULT
|
|
CTSRDPRemoteDesktopClient::OnTSConnect(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam,
|
|
BOOL& bHandled
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Window Message Handler FD_ACCEPT from async. winsock.
|
|
|
|
Parameters:
|
|
|
|
Refer to async. winsock FD_ACCEPT.
|
|
|
|
Returns:
|
|
|
|
|
|
|
|
--*/
|
|
{
|
|
WORD eventWSA;
|
|
WORD errorWSA;
|
|
HRESULT hr = S_OK;
|
|
SOCKADDR_IN inSockAddr;
|
|
int inSockAddrSize;
|
|
SOCKET s;
|
|
DWORD dwStatus;
|
|
|
|
DWORD SafErrorCode = SAFERROR_NOERROR;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnTSConnect");
|
|
|
|
eventWSA = WSAGETSELECTEVENT(lParam);
|
|
errorWSA = WSAGETSELECTERROR(lParam);
|
|
|
|
//
|
|
// MSDN : Message might already in our queue before we stop listen.
|
|
//
|
|
if( INVALID_SOCKET == m_ListenSocket || FALSE == ListenConnectInProgress() ) {
|
|
bHandled = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// we are not expecting event other than FD_CONNECT
|
|
//
|
|
if( eventWSA != FD_ACCEPT ) {
|
|
TRC_ERR((TB, _T("Expecting event %d got got %d"), FD_CONNECT, eventWSA));
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Make sure we don't do anything other than our own socket
|
|
//
|
|
if( (SOCKET)wParam != m_ListenSocket ) {
|
|
TRC_ERR((TB, _T("Expecting listening socket %d got %d"), m_ListenSocket, wParam));
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// We handle the message
|
|
//
|
|
bHandled = TRUE;
|
|
|
|
//
|
|
// Error occurred, fire a error event.
|
|
//
|
|
if( 0 != errorWSA ) {
|
|
TRC_ERR((TB, _T("WSA socket listen failed : %d"), errorWSA));
|
|
hr = HRESULT_FROM_WIN32( errorWSA );
|
|
SafErrorCode = SAFERROR_SOCKETCONNECTFAILED;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
inSockAddrSize = sizeof(inSockAddr);
|
|
m_TSConnectSocket = accept( m_ListenSocket,
|
|
(struct sockaddr DCPTR)&inSockAddr,
|
|
&inSockAddrSize
|
|
);
|
|
|
|
if( INVALID_SOCKET == m_TSConnectSocket ) {
|
|
dwStatus = WSAGetLastError();
|
|
hr = HRESULT_FROM_WIN32(dwStatus);
|
|
TRC_ERR((TB, _T("accept failed : %d"), dwStatus));
|
|
SafErrorCode = SAFERROR_SOCKETCONNECTFAILED;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Cached connecting TS server IP address.
|
|
// m_ConnectPort is set at the time we bind socket
|
|
//
|
|
m_ConnectedServer = inet_ntoa(inSockAddr.sin_addr);
|
|
|
|
|
|
//
|
|
// Stop async. event notification now, accepted socket
|
|
// has same properties as original listening socket.
|
|
//
|
|
dwStatus = WSAAsyncSelect(
|
|
m_TSConnectSocket,
|
|
m_hWnd,
|
|
0,
|
|
0
|
|
);
|
|
|
|
//
|
|
// Not critical,
|
|
// listening socket.
|
|
//
|
|
if((DWORD)SOCKET_ERROR == dwStatus) {
|
|
TRC_ERR((TB, _T("WSAAsyncSelect resetting notification failed : %d"), dwStatus));
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
//
|
|
// Close listening socket and kill timer.
|
|
//
|
|
if( (UINT_PTR)0 != m_ListenTimeoutTimerID )
|
|
{
|
|
KillTimer( m_ListenTimeoutTimerID );
|
|
m_ListenTimeoutTimerID = (UINT_PTR)0;
|
|
}
|
|
|
|
if( INVALID_SOCKET != m_ListenSocket )
|
|
{
|
|
closesocket( m_ListenSocket );
|
|
m_ListenSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
//
|
|
// Successfully established connection, terminate listening socket
|
|
//
|
|
Fire_ListenConnect( SafErrorCode );
|
|
|
|
DC_END_FN();
|
|
return 0;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::StartListen(
|
|
/*[in]*/ LONG timeout
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Put client into listen mode with optionally timeout.
|
|
|
|
Parameters:
|
|
|
|
timeout : Listen wait timeout, 0 for infinite.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::OnTSConnect");
|
|
HRESULT hr = S_OK;
|
|
int intRC;
|
|
int lastError;
|
|
|
|
if( FALSE == IsValid() ) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( INVALID_SOCKET == m_ListenSocket ) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Start listening on the port
|
|
//
|
|
intRC = listen( m_ListenSocket, SOMAXCONN );
|
|
if( SOCKET_ERROR == intRC )
|
|
{
|
|
lastError = WSAGetLastError();
|
|
TRC_ERR((TB, _T("listen failed - GLE:%d"), lastError));
|
|
hr = HRESULT_FROM_WIN32( lastError );
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// we are in listening now.
|
|
//
|
|
m_ListenConnectInProgress = TRUE;
|
|
|
|
//
|
|
// Start listening timer
|
|
//
|
|
if( 0 != timeout )
|
|
{
|
|
m_ListenTimeoutTimerID = SetTimer( (UINT_PTR)WM_LISTENTIMEOUT_TIMER, (UINT)(timeout * 1000) );
|
|
if( (UINT_PTR)0 == m_ListenTimeoutTimerID )
|
|
{
|
|
DWORD dwStatus;
|
|
|
|
// Failed to create a timer
|
|
dwStatus = GetLastError();
|
|
|
|
TRC_ERR((TB, _T("SetTimer failed - %d"),dwStatus));
|
|
hr = HRESULT_FROM_WIN32( dwStatus );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_ListenTimeoutTimerID = (UINT_PTR)0;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if( FAILED(hr) ) {
|
|
StopListen();
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CTSRDPRemoteDesktopClient::RetrieveUserConnectParm(
|
|
BSTR* pConnectParm
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieve Salem connection parameter to this expert.
|
|
|
|
Parameters:
|
|
|
|
pConnectParm : Pointer to BSTR to receive connect parm.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
LPTSTR pszAddress = NULL;
|
|
int BufSize = 0;
|
|
CComBSTR bstrConnParm;
|
|
DWORD dwRetry;
|
|
HRESULT hRes;
|
|
DWORD dwBufferRequire;
|
|
DWORD dwNumChars;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::RetrieveUserConnectParm");
|
|
|
|
if( NULL == pConnectParm )
|
|
{
|
|
hRes = E_POINTER;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Address might have change which might require bigger buffer, retry
|
|
//
|
|
//
|
|
for(dwRetry=0; dwRetry < MAX_FETCHIPADDRESSRETRY; dwRetry++) {
|
|
|
|
if( NULL != pszAddress ) {
|
|
LocalFree( pszAddress );
|
|
}
|
|
|
|
//
|
|
// Fetch all address on local machine.
|
|
//
|
|
dwBufferRequire = FetchAllAddresses( NULL, 0 );
|
|
if( 0 == dwBufferRequire ) {
|
|
hRes = E_UNEXPECTED;
|
|
ASSERT(FALSE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
pszAddress = (LPTSTR) LocalAlloc( LPTR, sizeof(TCHAR)*(dwBufferRequire+1) );
|
|
if( NULL == pszAddress ) {
|
|
hRes = E_OUTOFMEMORY;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
dwNumChars = FetchAllAddresses( pszAddress, dwBufferRequire );
|
|
ASSERT( dwNumChars <= dwBufferRequire );
|
|
if( dwNumChars <= dwBufferRequire ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( NULL == pszAddress ) {
|
|
hRes = E_UNEXPECTED;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
bstrConnParm = pszAddress;
|
|
*pConnectParm = bstrConnParm.Copy();
|
|
|
|
if( NULL == *pConnectParm ) {
|
|
hRes = E_OUTOFMEMORY;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
if( NULL != pszAddress ) {
|
|
LocalFree(pszAddress);
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hRes;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::put_ColorDepth(
|
|
LONG val
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set Color depth
|
|
|
|
Arguments:
|
|
|
|
val - Value in bits perpel to set
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::put_ColorDepth");
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->put_ColorDepth(val);
|
|
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"put_ColorDepth: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CTSRDPRemoteDesktopClient::get_ColorDepth(
|
|
LONG *pVal
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get Color depth
|
|
|
|
Arguments:
|
|
|
|
pVal - address to place the colordepth value in
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
IMsRdpClientAdvancedSettings *pAdvSettings = NULL;
|
|
|
|
DC_BEGIN_FN("CTSRDPRemoteDesktopClient::get_ColorDepth");
|
|
|
|
if (!IsValid()) {
|
|
ASSERT(FALSE);
|
|
hr = E_FAIL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_TSClient->get_ColorDepth(pVal);
|
|
if (hr != S_OK) {
|
|
TRC_ERR((TB, L"get_ColorDepth: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|