1 // Copyright (c) 2012 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/chromoting_host.h" 6 7 #include <algorithm> 8 9 #include "base/bind.h" 10 #include "base/callback.h" 11 #include "base/command_line.h" 12 #include "base/message_loop/message_loop_proxy.h" 13 #include "build/build_config.h" 14 #include "jingle/glue/thread_wrapper.h" 15 #include "remoting/base/constants.h" 16 #include "remoting/base/logging.h" 17 #include "remoting/host/chromoting_host_context.h" 18 #include "remoting/host/desktop_environment.h" 19 #include "remoting/host/host_config.h" 20 #include "remoting/host/input_injector.h" 21 #include "remoting/host/video_frame_recorder.h" 22 #include "remoting/protocol/connection_to_client.h" 23 #include "remoting/protocol/client_stub.h" 24 #include "remoting/protocol/host_stub.h" 25 #include "remoting/protocol/input_stub.h" 26 #include "remoting/protocol/session_config.h" 27 28 using remoting::protocol::ConnectionToClient; 29 using remoting::protocol::InputStub; 30 31 namespace remoting { 32 33 namespace { 34 35 const net::BackoffEntry::Policy kDefaultBackoffPolicy = { 36 // Number of initial errors (in sequence) to ignore before applying 37 // exponential back-off rules. 38 0, 39 40 // Initial delay for exponential back-off in ms. 41 2000, 42 43 // Factor by which the waiting time will be multiplied. 44 2, 45 46 // Fuzzing percentage. ex: 10% will spread requests randomly 47 // between 90%-100% of the calculated time. 48 0, 49 50 // Maximum amount of time we are willing to delay our request in ms. 51 -1, 52 53 // Time to keep an entry from being discarded even when it 54 // has no significant state, -1 to never discard. 55 -1, 56 57 // Don't use initial delay unless the last request was an error. 58 false, 59 }; 60 61 } // namespace 62 63 ChromotingHost::ChromotingHost( 64 SignalStrategy* signal_strategy, 65 DesktopEnvironmentFactory* desktop_environment_factory, 66 scoped_ptr<protocol::SessionManager> session_manager, 67 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner, 68 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner, 69 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner, 70 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner, 71 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner, 72 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) 73 : desktop_environment_factory_(desktop_environment_factory), 74 session_manager_(session_manager.Pass()), 75 audio_task_runner_(audio_task_runner), 76 input_task_runner_(input_task_runner), 77 video_capture_task_runner_(video_capture_task_runner), 78 video_encode_task_runner_(video_encode_task_runner), 79 network_task_runner_(network_task_runner), 80 ui_task_runner_(ui_task_runner), 81 signal_strategy_(signal_strategy), 82 started_(false), 83 protocol_config_(protocol::CandidateSessionConfig::CreateDefault()), 84 login_backoff_(&kDefaultBackoffPolicy), 85 authenticating_client_(false), 86 reject_authenticating_client_(false), 87 enable_curtaining_(false), 88 weak_factory_(this) { 89 DCHECK(network_task_runner_->BelongsToCurrentThread()); 90 DCHECK(signal_strategy); 91 92 jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop(); 93 94 if (!desktop_environment_factory_->SupportsAudioCapture()) { 95 protocol_config_->DisableAudioChannel(); 96 } 97 } 98 99 ChromotingHost::~ChromotingHost() { 100 DCHECK(CalledOnValidThread()); 101 102 // Disconnect all of the clients. 103 while (!clients_.empty()) { 104 clients_.front()->DisconnectSession(); 105 } 106 107 // Destroy the session manager to make sure that |signal_strategy_| does not 108 // have any listeners registered. 109 session_manager_.reset(); 110 111 // Notify observers. 112 if (started_) 113 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnShutdown()); 114 } 115 116 void ChromotingHost::Start(const std::string& host_owner_email) { 117 DCHECK(CalledOnValidThread()); 118 DCHECK(!started_); 119 120 HOST_LOG << "Starting host"; 121 started_ = true; 122 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 123 OnStart(host_owner_email)); 124 125 // Start the SessionManager, supplying this ChromotingHost as the listener. 126 session_manager_->Init(signal_strategy_, this); 127 } 128 129 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) { 130 DCHECK(CalledOnValidThread()); 131 status_observers_.AddObserver(observer); 132 } 133 134 void ChromotingHost::RemoveStatusObserver(HostStatusObserver* observer) { 135 DCHECK(CalledOnValidThread()); 136 status_observers_.RemoveObserver(observer); 137 } 138 139 void ChromotingHost::AddExtension(scoped_ptr<HostExtension> extension) { 140 extensions_.push_back(extension.release()); 141 } 142 143 void ChromotingHost::RejectAuthenticatingClient() { 144 DCHECK(authenticating_client_); 145 reject_authenticating_client_ = true; 146 } 147 148 void ChromotingHost::SetAuthenticatorFactory( 149 scoped_ptr<protocol::AuthenticatorFactory> authenticator_factory) { 150 DCHECK(CalledOnValidThread()); 151 session_manager_->set_authenticator_factory(authenticator_factory.Pass()); 152 } 153 154 void ChromotingHost::SetEnableCurtaining(bool enable) { 155 DCHECK(network_task_runner_->BelongsToCurrentThread()); 156 157 if (enable_curtaining_ == enable) 158 return; 159 160 enable_curtaining_ = enable; 161 desktop_environment_factory_->SetEnableCurtaining(enable_curtaining_); 162 163 // Disconnect all existing clients because they might be running not 164 // curtained. 165 // TODO(alexeypa): fix this such that the curtain is applied to the not 166 // curtained sessions or disconnect only the client connected to not 167 // curtained sessions. 168 if (enable_curtaining_) 169 DisconnectAllClients(); 170 } 171 172 void ChromotingHost::SetMaximumSessionDuration( 173 const base::TimeDelta& max_session_duration) { 174 max_session_duration_ = max_session_duration; 175 } 176 177 //////////////////////////////////////////////////////////////////////////// 178 // protocol::ClientSession::EventHandler implementation. 179 void ChromotingHost::OnSessionAuthenticating(ClientSession* client) { 180 // We treat each incoming connection as a failure to authenticate, 181 // and clear the backoff when a connection successfully 182 // authenticates. This allows the backoff to protect from parallel 183 // connection attempts as well as sequential ones. 184 if (login_backoff_.ShouldRejectRequest()) { 185 LOG(WARNING) << "Disconnecting client " << client->client_jid() << " due to" 186 " an overload of failed login attempts."; 187 client->DisconnectSession(); 188 return; 189 } 190 login_backoff_.InformOfRequest(false); 191 } 192 193 bool ChromotingHost::OnSessionAuthenticated(ClientSession* client) { 194 DCHECK(CalledOnValidThread()); 195 196 login_backoff_.Reset(); 197 198 // Disconnect all other clients. |it| should be advanced before Disconnect() 199 // is called to avoid it becoming invalid when the client is removed from 200 // the list. 201 ClientList::iterator it = clients_.begin(); 202 while (it != clients_.end()) { 203 ClientSession* other_client = *it++; 204 if (other_client != client) 205 other_client->DisconnectSession(); 206 } 207 208 // Disconnects above must have destroyed all other clients. 209 DCHECK_EQ(clients_.size(), 1U); 210 211 // Notify observers that there is at least one authenticated client. 212 const std::string& jid = client->client_jid(); 213 214 reject_authenticating_client_ = false; 215 216 authenticating_client_ = true; 217 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 218 OnClientAuthenticated(jid)); 219 authenticating_client_ = false; 220 221 return !reject_authenticating_client_; 222 } 223 224 void ChromotingHost::OnSessionChannelsConnected(ClientSession* client) { 225 DCHECK(CalledOnValidThread()); 226 227 // Notify observers. 228 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 229 OnClientConnected(client->client_jid())); 230 } 231 232 void ChromotingHost::OnSessionAuthenticationFailed(ClientSession* client) { 233 DCHECK(CalledOnValidThread()); 234 235 // Notify observers. 236 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 237 OnAccessDenied(client->client_jid())); 238 } 239 240 void ChromotingHost::OnSessionClosed(ClientSession* client) { 241 DCHECK(CalledOnValidThread()); 242 243 ClientList::iterator it = std::find(clients_.begin(), clients_.end(), client); 244 CHECK(it != clients_.end()); 245 246 if (client->is_authenticated()) { 247 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 248 OnClientDisconnected(client->client_jid())); 249 } 250 251 clients_.erase(it); 252 delete client; 253 } 254 255 void ChromotingHost::OnSessionRouteChange( 256 ClientSession* session, 257 const std::string& channel_name, 258 const protocol::TransportRoute& route) { 259 DCHECK(CalledOnValidThread()); 260 FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, 261 OnClientRouteChange(session->client_jid(), channel_name, 262 route)); 263 } 264 265 void ChromotingHost::OnSessionManagerReady() { 266 DCHECK(CalledOnValidThread()); 267 // Don't need to do anything here, just wait for incoming 268 // connections. 269 } 270 271 void ChromotingHost::OnIncomingSession( 272 protocol::Session* session, 273 protocol::SessionManager::IncomingSessionResponse* response) { 274 DCHECK(CalledOnValidThread()); 275 276 if (!started_) { 277 *response = protocol::SessionManager::DECLINE; 278 return; 279 } 280 281 if (login_backoff_.ShouldRejectRequest()) { 282 LOG(WARNING) << "Rejecting connection due to" 283 " an overload of failed login attempts."; 284 *response = protocol::SessionManager::OVERLOAD; 285 return; 286 } 287 288 protocol::SessionConfig config; 289 if (!protocol_config_->Select(session->candidate_config(), &config)) { 290 LOG(WARNING) << "Rejecting connection from " << session->jid() 291 << " because no compatible configuration has been found."; 292 *response = protocol::SessionManager::INCOMPATIBLE; 293 return; 294 } 295 296 session->set_config(config); 297 298 *response = protocol::SessionManager::ACCEPT; 299 300 HOST_LOG << "Client connected: " << session->jid(); 301 302 // Create a client object. 303 scoped_ptr<protocol::ConnectionToClient> connection( 304 new protocol::ConnectionToClient(session)); 305 ClientSession* client = new ClientSession( 306 this, 307 audio_task_runner_, 308 input_task_runner_, 309 video_capture_task_runner_, 310 video_encode_task_runner_, 311 network_task_runner_, 312 ui_task_runner_, 313 connection.Pass(), 314 desktop_environment_factory_, 315 max_session_duration_, 316 pairing_registry_, 317 extensions_.get()); 318 319 clients_.push_back(client); 320 } 321 322 void ChromotingHost::set_protocol_config( 323 scoped_ptr<protocol::CandidateSessionConfig> config) { 324 DCHECK(CalledOnValidThread()); 325 DCHECK(config.get()); 326 DCHECK(!started_); 327 protocol_config_ = config.Pass(); 328 } 329 330 void ChromotingHost::DisconnectAllClients() { 331 DCHECK(CalledOnValidThread()); 332 333 while (!clients_.empty()) { 334 size_t size = clients_.size(); 335 clients_.front()->DisconnectSession(); 336 CHECK_EQ(clients_.size(), size - 1); 337 } 338 } 339 340 } // namespace remoting 341
