902 lines
20 KiB
C++
902 lines
20 KiB
C++
/*++
|
|
|
|
Copyright (c) 1999-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
RemoteDesktopClient
|
|
|
|
Abstract:
|
|
|
|
The CRemoteDesktopClient class is the parent
|
|
class for the Remote Desktop class hierarchy on the server-side.
|
|
It helps the CRemoteDesktopClientHost class to implement
|
|
the ISAFRemoteDesktopClient interface.
|
|
|
|
The Remote Desktop class hierarchy provides a pluggable C++ interface
|
|
for remote desktop access, by abstracting the implementation
|
|
specific details of remote desktop access for the server-side.
|
|
|
|
Author:
|
|
|
|
Tad Brockway 02/00
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#ifdef TRC_FILE
|
|
#undef TRC_FILE
|
|
#endif
|
|
|
|
#define TRC_FILE "_rdclnt"
|
|
|
|
#include "RDCHost.h"
|
|
#include "RemoteDesktopClient.h"
|
|
#include <RemoteDesktopUtils.h>
|
|
#include "ClientDataChannelMgr.h"
|
|
|
|
#include <algorithm>
|
|
|
|
using namespace std;
|
|
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// CRemoteDesktopClientEventSink Methods
|
|
//
|
|
|
|
void __stdcall
|
|
CRemoteDesktopClientEventSink::OnConnected()
|
|
{
|
|
m_Obj->OnConnected();
|
|
}
|
|
void __stdcall
|
|
CRemoteDesktopClientEventSink::OnDisconnected(long reason)
|
|
{
|
|
m_Obj->OnDisconnected(reason);
|
|
}
|
|
void __stdcall
|
|
CRemoteDesktopClientEventSink::OnConnectRemoteDesktopComplete(long status)
|
|
{
|
|
m_Obj->OnConnectRemoteDesktopComplete(status);
|
|
}
|
|
void __stdcall
|
|
CRemoteDesktopClientEventSink::OnListenConnect(long status)
|
|
{
|
|
m_Obj->OnListenConnect(status);
|
|
}
|
|
void __stdcall
|
|
CRemoteDesktopClientEventSink::OnBeginConnect()
|
|
{
|
|
m_Obj->OnBeginConnect();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
// CRemoteDesktopClient Methods
|
|
//
|
|
|
|
HRESULT
|
|
CRemoteDesktopClient::FinalConstruct()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Final Constructor
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::FinalConstruct");
|
|
|
|
//
|
|
// Register with ActiveX
|
|
//
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!AtlAxWinInit()) {
|
|
TRC_ERR((TB, L"AtlAxWinInit failed."));
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
//
|
|
// Create the Data Channel Manager
|
|
//
|
|
m_ChannelMgr = new CComObject<CClientDataChannelMgr>();
|
|
m_ChannelMgr->AddRef();
|
|
|
|
//
|
|
// Initialize the channel mnager
|
|
//
|
|
hr = m_ChannelMgr->Initialize();
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
CRemoteDesktopClient::~CRemoteDesktopClient()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destructor
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::~CRemoteDesktopClient");
|
|
|
|
DisconnectFromServer();
|
|
|
|
//
|
|
// !!!!NOTE!!!!
|
|
// Cleaning up the contained m_Client control is being done in the destructor
|
|
// for Windows XP to make sure it and the MSTSCAX control are not destroyed
|
|
// in a callback to PC Health via a DisconnectFromServer invokation. Cleaning
|
|
// up here removes late-binding of the protocol in that once we connect one time
|
|
// to a particular protocol type (RDP only for XP), we can't later connect using
|
|
// some other protocol.
|
|
//
|
|
// If we are to support other protocol types in the future, then the clean up
|
|
// should be done in the DisconnectFromServer so we can rebind to a different protocol
|
|
// on each ConnectToServer call. To make this work, we will need to clean up MSTCAX
|
|
// and the TSRDP Salem control so they can be destroyed in a callback. I (TadB) actually
|
|
// had this working for the TSRDP Salem control in an afternoon.
|
|
|
|
//
|
|
// Zero out the IO interface ptr for the channel manager, since it is
|
|
// going away.
|
|
//
|
|
if (m_ChannelMgr != NULL) {
|
|
m_ChannelMgr->SetIOInterface(NULL);
|
|
}
|
|
|
|
if (m_Client != NULL) {
|
|
m_Client = NULL;
|
|
}
|
|
|
|
if (m_ClientWnd != NULL) {
|
|
m_ClientAxView.DestroyWindow();
|
|
m_ClientWnd = NULL;
|
|
}
|
|
|
|
//
|
|
// Release the data channel manager.
|
|
//
|
|
m_ChannelMgr->Release();
|
|
|
|
if ( NULL != m_ExtDllName )
|
|
SysFreeString( m_ExtDllName );
|
|
|
|
if ( NULL != m_ExtParams )
|
|
SysFreeString( m_ExtParams );
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::get_IsServerConnected(
|
|
BOOL *pVal
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Indicates whether the client-side Remote Desktop Host ActiveX Control is
|
|
connected to the server, independent of whether the remote user's desktop
|
|
is currently remote controlled.
|
|
|
|
Arguments:
|
|
|
|
pVal - Set to TRUE if the client is currently connected to the server.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::get_IsServerConnected");
|
|
HRESULT hr;
|
|
|
|
if (pVal == NULL) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_Client != NULL) {
|
|
hr = m_Client->get_IsServerConnected(pVal);
|
|
}
|
|
else {
|
|
*pVal = FALSE;
|
|
hr = S_OK;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::get_IsRemoteDesktopConnected(
|
|
BOOL *pVal
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Indicates whether the control is currently connected to the server
|
|
machine.
|
|
|
|
Arguments:
|
|
|
|
pVal - Sets to TRUE if the control is currently connected to the server.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success. Otherwise, an error code is returned.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::get_IsRemoteDesktopConnected");
|
|
HRESULT hr;
|
|
|
|
if (pVal == NULL) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_Client != NULL) {
|
|
hr = m_Client->get_IsRemoteDesktopConnected(pVal);
|
|
}
|
|
else {
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_CONNECTED);
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::get_ExtendedErrorInfo(
|
|
LONG *error
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::get_ExtendedErrorInfo");
|
|
|
|
HRESULT hr;
|
|
|
|
if (error == NULL) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_Client != NULL) {
|
|
hr = m_Client->get_ExtendedErrorInfo(error);
|
|
}
|
|
else {
|
|
hr = S_OK;
|
|
*error = SAFERROR_NOERROR;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::DisconnectRemoteDesktop()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::DisconnectRemoteDesktop");
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Hide our window.
|
|
//
|
|
//ShowWindow(SW_HIDE);
|
|
m_RemoteControlEnabled = FALSE;
|
|
|
|
if (m_Client != NULL) {
|
|
hr = m_Client->DisconnectRemoteDesktop();
|
|
}
|
|
else {
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_CONNECTED);
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::ConnectRemoteDesktop()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::ConnectRemoteDesktop");
|
|
HRESULT hr;
|
|
|
|
if (m_Client != NULL) {
|
|
hr = m_Client->ConnectRemoteDesktop();
|
|
}
|
|
else {
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_CONNECTED);
|
|
}
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CRemoteDesktopClient::InitializeRemoteDesktopClientObject()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Routine to initialize window for actvie x control and setups our channel manager
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
Notes:
|
|
|
|
put_EnableSmartSizing() is not invoked in here because on listen mode, we
|
|
create/initialize object first then goes into actual connection, two seperate calls,
|
|
and so it is possible for caller to invoke smartsizeing in-between and we will
|
|
never pick it up, both ConnectToServer() and AcceptListenConnection()
|
|
need to make the call.
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::InitializeRemoteDesktopClientObject");
|
|
HRESULT hr = S_OK;
|
|
IUnknown *pUnk = NULL;
|
|
RECT ourWindowRect;
|
|
RECT rcClient;
|
|
CComPtr<IDataChannelIO> ioInterface;
|
|
|
|
//
|
|
// Get the dimensions of our window.
|
|
//
|
|
if (!::GetWindowRect(m_hWnd, &ourWindowRect)) {
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
TRC_ERR((TB, L"GetWindowRect: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Create the client Window.
|
|
//
|
|
rcClient.top = 0;
|
|
rcClient.left = 0;
|
|
rcClient.right = ourWindowRect.right - ourWindowRect.left;
|
|
rcClient.bottom = ourWindowRect.bottom - ourWindowRect.top;
|
|
m_ClientWnd = m_ClientAxView.Create(
|
|
m_hWnd, rcClient, REMOTEDESKTOPRDPCLIENT_TEXTGUID,
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, 0
|
|
);
|
|
|
|
if (m_ClientWnd == NULL) {
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
TRC_ERR((TB, L"Window Create: %08X", GetLastError()));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
ASSERT(::IsWindow(m_ClientWnd));
|
|
|
|
//
|
|
// Get IUnknown
|
|
//
|
|
hr = AtlAxGetControl(m_ClientWnd, &pUnk);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"AtlAxGetControl: %08X", hr));
|
|
pUnk = NULL;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Get the control.
|
|
//
|
|
hr = pUnk->QueryInterface(__uuidof(ISAFRemoteDesktopClient), (void**)&m_Client);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"QueryInterface: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Initialize the event sink.
|
|
//
|
|
m_ClientEventSink.m_Obj = this;
|
|
|
|
//
|
|
// Add the event sink.
|
|
//
|
|
hr = m_ClientEventSink.DispEventAdvise(pUnk);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"DispEventAdvise: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Get the Data IO interface from the control so we can talk
|
|
// over an OOB data channel.
|
|
//
|
|
hr = pUnk->QueryInterface(__uuidof(IDataChannelIO), (void**)&ioInterface);
|
|
if (!SUCCEEDED(hr)) {
|
|
TRC_ERR((TB, L"QueryInterface: %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Pass the channel manager to the control.
|
|
//
|
|
ioInterface->put_ChannelMgr(m_ChannelMgr);
|
|
|
|
//
|
|
// Indicate the current data io provider to the channel manager
|
|
// because it just changed.
|
|
//
|
|
m_ChannelMgr->SetIOInterface(ioInterface);
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
//
|
|
// m_Client keeps our reference to the client object until
|
|
// it ref counts to zero.
|
|
//
|
|
if (pUnk != NULL) {
|
|
pUnk->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::ConnectToServer(BSTR bstrExpertBlob)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
bstrExpertBlob : Optional blob to be transmitted over to user side, this
|
|
is used only in the case of SAF resolver.
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::ConnectToServer");
|
|
HRESULT hr;
|
|
DWORD protocolType;
|
|
CComBSTR tmp;
|
|
CComBSTR helpSessionId;
|
|
DWORD result;
|
|
CComBSTR channelInfo;
|
|
ChannelsType::iterator element;
|
|
DWORD dwConnParmVersion;
|
|
WCHAR buf[MAX_PATH];
|
|
|
|
//
|
|
// Check the connection parameters.
|
|
//
|
|
if (m_ConnectParms.Length() == 0) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Parse the connection parms to get the type of server
|
|
// to which we are connecting.
|
|
//
|
|
result = ParseConnectParmsString(
|
|
m_ConnectParms, &dwConnParmVersion, &protocolType, tmp, tmp,
|
|
tmp, helpSessionId, tmp, tmp,
|
|
tmp
|
|
);
|
|
if (result != ERROR_SUCCESS) {
|
|
hr = HRESULT_FROM_WIN32(result);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Right now, we only support the TSRDP client.
|
|
// TODO: We should make this pluggable for Whistler timeframe
|
|
// via registry defined CLSID's.
|
|
//
|
|
if (protocolType != REMOTEDESKTOP_TSRDP_PROTOCOL) {
|
|
TRC_ERR((TB, L"Unsupported protocol: %ld", protocolType));
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if( m_Client == NULL) {
|
|
hr = InitializeRemoteDesktopClientObject();
|
|
if( FAILED(hr) ) {
|
|
TRC_ERR((TB, L"InitializeRemoteDesktopClientObject() failed with : %x", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Enable/disable smart sizing.
|
|
//
|
|
hr = m_Client->put_EnableSmartSizing(m_EnableSmartSizing);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_Client->put_ColorDepth(m_ColorDepth);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// setup the test extension
|
|
//
|
|
_PutExtParams();
|
|
|
|
//
|
|
// Connect.
|
|
//
|
|
m_Client->put_ConnectParms(m_ConnectParms);
|
|
hr = m_Client->ConnectToServer(bstrExpertBlob);
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::DisconnectFromServer()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("CRemoteDesktopClient::DisconnectFromServer");
|
|
|
|
//
|
|
// Hide our window.
|
|
//
|
|
//ShowWindow(SW_HIDE);
|
|
|
|
//
|
|
// Notify the contained client object.
|
|
//
|
|
if (m_Client != NULL) {
|
|
m_Client->DisconnectFromServer();
|
|
}
|
|
|
|
DC_END_FN();
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// send parameters to ISAFRemoteDesktopTestExtension
|
|
//
|
|
HRESULT
|
|
CRemoteDesktopClient::_PutExtParams(
|
|
VOID
|
|
)
|
|
{
|
|
ISAFRemoteDesktopTestExtension *pExt = NULL;
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
DC_BEGIN_FN("CRemoteDesktopClient::_PutExtParams");
|
|
|
|
if ( NULL == m_ExtDllName )
|
|
{
|
|
hr = S_OK;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
if (m_Client == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_CONNECTED);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_Client->QueryInterface( __uuidof( ISAFRemoteDesktopTestExtension ),
|
|
(void **)&pExt );
|
|
if (FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"QueryInterface( ISAFRemoteDesktopTestExtension ), failed %08X", hr));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
|
|
hr = pExt->put_TestExtDllName( m_ExtDllName );
|
|
if (FAILED( hr ))
|
|
{
|
|
TRC_ERR((TB, L"put_TestExtDllName failed %08X", hr ));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
if ( NULL != m_ExtParams )
|
|
hr = pExt->put_TestExtParams( m_ExtParams );
|
|
|
|
CLEANUPANDEXIT:
|
|
if ( NULL != pExt )
|
|
pExt->Release();
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::StartListen(
|
|
/*[in]*/ LONG timeout
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Put client (expert) in listening on socket port listening_port and wait for TS server to connect.
|
|
|
|
Parameters:
|
|
|
|
listening_port : Port to listen on, 0 for dynamic port.
|
|
timeout : Listen timeout.
|
|
pConnectParm : Return Salem specific connection parameter for ISAFRemoteDesktopServerHost object
|
|
to connect to this client (expert).
|
|
|
|
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;
|
|
|
|
if( m_Client != NULL ) {
|
|
hr = m_Client->StartListen( timeout );
|
|
}
|
|
else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::CreateListenEndpoint(
|
|
/*[in]*/ LONG listening_port,
|
|
/*[out, retval]*/ BSTR* pConnectParm
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Put client (expert) in listening on socket port listening_port and wait for TS server to connect.
|
|
|
|
Parameters:
|
|
|
|
listening_port : Port to listen on, 0 for dynamic port.
|
|
pConnectParm : Return Salem specific connection parameter for ISAFRemoteDesktopServerHost object
|
|
to connect to this client (expert).
|
|
|
|
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;
|
|
|
|
if( NULL == pConnectParm ) {
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else {
|
|
if( m_Client == NULL ) {
|
|
hr = InitializeRemoteDesktopClientObject();
|
|
if( FAILED(hr) ) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
}
|
|
|
|
hr = m_Client->CreateListenEndpoint( listening_port, pConnectParm );
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::StopListen()
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Stop listening waiting for TS server (helpee, user) to connect.
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
|
|
if( m_Client != NULL ) {
|
|
hr = m_Client->StopListen();
|
|
}
|
|
else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRemoteDesktopClient::AcceptListenConnection(
|
|
/*[in]*/ BSTR expertBlob
|
|
)
|
|
/*++
|
|
|
|
Description:
|
|
|
|
Stop listening waiting for TS server (helpee, user) to connect.
|
|
|
|
Parameters:
|
|
|
|
None.
|
|
|
|
Returns:
|
|
|
|
S_OK or error code.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD protocolType;
|
|
CComBSTR tmp;
|
|
CComBSTR helpSessionId;
|
|
DWORD result;
|
|
CComBSTR channelInfo;
|
|
ChannelsType::iterator element;
|
|
DWORD dwConnParmVersion;
|
|
WCHAR buf[MAX_PATH];
|
|
|
|
|
|
DC_BEGIN_FN("CRemoteDesktopClient::AcceptListenConnection");
|
|
|
|
//
|
|
// Check the connection parameters.
|
|
//
|
|
if (m_ConnectParms.Length() == 0 || m_Client == NULL) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Parse the connection parms to get the type of server
|
|
// to which we are connecting.
|
|
//
|
|
result = ParseConnectParmsString(
|
|
m_ConnectParms, &dwConnParmVersion, &protocolType, tmp, tmp,
|
|
tmp, helpSessionId, tmp, tmp,
|
|
tmp
|
|
);
|
|
if (result != ERROR_SUCCESS) {
|
|
hr = HRESULT_FROM_WIN32(result);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Right now, we only support the TSRDP client.
|
|
// TODO: We should make this pluggable for Whistler timeframe
|
|
// via registry defined CLSID's.
|
|
//
|
|
if (protocolType != REMOTEDESKTOP_TSRDP_PROTOCOL) {
|
|
TRC_ERR((TB, L"Unsupported protocol: %ld", protocolType));
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Enable/disable smart sizing.
|
|
//
|
|
hr = m_Client->put_EnableSmartSizing(m_EnableSmartSizing);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
hr = m_Client->put_ColorDepth(m_ColorDepth);
|
|
if (!SUCCEEDED(hr)) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// setup the test extension
|
|
//
|
|
_PutExtParams();
|
|
|
|
//
|
|
// Connect.
|
|
//
|
|
m_Client->put_ConnectParms(m_ConnectParms);
|
|
hr = m_Client->AcceptListenConnection(expertBlob);
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|