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