remoting/host/win/rdp_client.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/win/rdp_client.h"
   6
   7 #include <windows.h>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/logging.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/win/registry.h"
  14 #include "net/base/ip_endpoint.h"
  15 #include "remoting/base/typed_buffer.h"
  16 #include "remoting/host/win/rdp_client_window.h"
  17 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  18
  19 namespace remoting {
  20
  21 namespace {
  22
  23 // 127.0.0.1 is explicitly blocked by the RDP ActiveX control, so we use
  24 // 127.0.0.2 instead.
  25 const unsigned char kRdpLoopbackAddress[] = { 127, 0, 0, 2 };
  26
  27 const int kDefaultRdpPort = 3389;
  28
  29 // The port number used by RDP is stored in the registry.
  30 const wchar_t kRdpPortKeyName[] = L"SYSTEM\\CurrentControlSet\\Control\\"
  31     L"Terminal Server\\WinStations\\RDP-Tcp";
  32 const wchar_t kRdpPortValueName[] = L"PortNumber";
  33
  34 }  // namespace
  35
  36 // The core of RdpClient is ref-counted since it services calls and notifies
  37 // events on the caller task runner, but runs the ActiveX control on the UI
  38 // task runner.
  39 class RdpClient::Core
  40     : public base::RefCountedThreadSafe<Core>,
  41       public RdpClientWindow::EventHandler {
  42  public:
  43   Core(
  44       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  45       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  46       RdpClient::EventHandler* event_handler);
  47
  48   // Initiates a loopback RDP connection.
  49   void Connect(const webrtc::DesktopSize& screen_size,
  50                const std::string& terminal_id);
  51
  52   // Initiates a graceful shutdown of the RDP connection.
  53   void Disconnect();
  54
  55   // Sends Secure Attention Sequence to the session.
  56   void InjectSas();
  57
  58   // RdpClientWindow::EventHandler interface.
  59   virtual void OnConnected() OVERRIDE;
  60   virtual void OnDisconnected() OVERRIDE;
  61
  62  private:
  63   friend class base::RefCountedThreadSafe<Core>;
  64   virtual ~Core();
  65
  66   // Helpers for the event handler's methods that make sure that OnRdpClosed()
  67   // is the last notification delivered and is delevered only once.
  68   void NotifyConnected();
  69   void NotifyClosed();
  70
  71   // Task runner on which the caller expects |event_handler_| to be notified.
  72   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
  73
  74   // Task runner on which |rdp_client_window_| is running.
  75   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
  76
  77   // Event handler receiving notification about connection state. The pointer is
  78   // cleared when Disconnect() methods is called, stopping any further updates.
  79   RdpClient::EventHandler* event_handler_;
  80
  81   // Hosts the RDP ActiveX control.
  82   scoped_ptr<RdpClientWindow> rdp_client_window_;
  83
  84   // A self-reference to keep the object alive during connection shutdown.
  85   scoped_refptr<Core> self_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(Core);
  88 };
  89
  90 RdpClient::RdpClient(
  91     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  92     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  93     const webrtc::DesktopSize& screen_size,
  94     const std::string& terminal_id,
  95     EventHandler* event_handler) {
  96   DCHECK(caller_task_runner->BelongsToCurrentThread());
  97
  98   core_ = new Core(caller_task_runner, ui_task_runner, event_handler);
  99   core_->Connect(screen_size, terminal_id);
 100 }
 101
 102 RdpClient::~RdpClient() {
 103   DCHECK(CalledOnValidThread());
 104
 105   core_->Disconnect();
 106 }
 107
 108 void RdpClient::InjectSas() {
 109   DCHECK(CalledOnValidThread());
 110
 111   core_->InjectSas();
 112 }
 113
 114 RdpClient::Core::Core(
 115     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 116     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 117     RdpClient::EventHandler* event_handler)
 118     : caller_task_runner_(caller_task_runner),
 119       ui_task_runner_(ui_task_runner),
 120       event_handler_(event_handler) {
 121 }
 122
 123 void RdpClient::Core::Connect(const webrtc::DesktopSize& screen_size,
 124                               const std::string& terminal_id) {
 125   if (!ui_task_runner_->BelongsToCurrentThread()) {
 126     ui_task_runner_->PostTask(
 127         FROM_HERE, base::Bind(&Core::Connect, this, screen_size, terminal_id));
 128     return;
 129   }
 130
 131   DCHECK(base::MessageLoopForUI::IsCurrent());
 132   DCHECK(!rdp_client_window_);
 133   DCHECK(!self_);
 134
 135   // Read the port number used by RDP.
 136   DWORD server_port;
 137   base::win::RegKey key(HKEY_LOCAL_MACHINE, kRdpPortKeyName, KEY_READ);
 138   if (!key.Valid() ||
 139       (key.ReadValueDW(kRdpPortValueName, &server_port) != ERROR_SUCCESS)) {
 140     server_port = kDefaultRdpPort;
 141   }
 142
 143   net::IPAddressNumber server_address(
 144       kRdpLoopbackAddress,
 145       kRdpLoopbackAddress + arraysize(kRdpLoopbackAddress));
 146   net::IPEndPoint server_endpoint(server_address, server_port);
 147
 148   // Create the ActiveX control window.
 149   rdp_client_window_.reset(new RdpClientWindow(server_endpoint, terminal_id,
 150                                                this));
 151   if (!rdp_client_window_->Connect(screen_size)) {
 152     rdp_client_window_.reset();
 153
 154     // Notify the caller that connection attempt failed.
 155     NotifyClosed();
 156   }
 157 }
 158
 159 void RdpClient::Core::Disconnect() {
 160   if (!ui_task_runner_->BelongsToCurrentThread()) {
 161     ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::Disconnect, this));
 162     return;
 163   }
 164
 165   // The caller does not expect any notifications to be delivered after this
 166   // point.
 167   event_handler_ = NULL;
 168
 169   // Gracefully shutdown the RDP connection.
 170   if (rdp_client_window_) {
 171     self_ = this;
 172     rdp_client_window_->Disconnect();
 173   }
 174 }
 175
 176 void RdpClient::Core::InjectSas() {
 177   if (!ui_task_runner_->BelongsToCurrentThread()) {
 178     ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::InjectSas, this));
 179     return;
 180   }
 181
 182   if (rdp_client_window_)
 183     rdp_client_window_->InjectSas();
 184 }
 185
 186 void RdpClient::Core::OnConnected() {
 187   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 188   DCHECK(rdp_client_window_);
 189
 190   NotifyConnected();
 191 }
 192
 193 void RdpClient::Core::OnDisconnected() {
 194   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 195   DCHECK(rdp_client_window_);
 196
 197   NotifyClosed();
 198
 199   // Delay window destruction until no ActiveX control's code is on the stack.
 200   ui_task_runner_->DeleteSoon(FROM_HERE, rdp_client_window_.release());
 201   self_ = NULL;
 202 }
 203
 204 RdpClient::Core::~Core() {
 205   DCHECK(!event_handler_);
 206   DCHECK(!rdp_client_window_);
 207 }
 208
 209 void RdpClient::Core::NotifyConnected() {
 210   if (!caller_task_runner_->BelongsToCurrentThread()) {
 211     caller_task_runner_->PostTask(
 212         FROM_HERE, base::Bind(&Core::NotifyConnected, this));
 213     return;
 214   }
 215
 216   if (event_handler_)
 217     event_handler_->OnRdpConnected();
 218 }
 219
 220 void RdpClient::Core::NotifyClosed() {
 221   if (!caller_task_runner_->BelongsToCurrentThread()) {
 222     caller_task_runner_->PostTask(
 223         FROM_HERE, base::Bind(&Core::NotifyClosed, this));
 224     return;
 225   }
 226
 227   if (event_handler_) {
 228     RdpClient::EventHandler* event_handler = event_handler_;
 229     event_handler_ = NULL;
 230     event_handler->OnRdpClosed();
 231   }
 232 }
 233
 234 }  // namespace remoting