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 #ifndef REMOTING_HOST_CHROMOTING_HOST_H_ 6 #define REMOTING_HOST_CHROMOTING_HOST_H_ 7 8 #include <list> 9 #include <string> 10 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/memory/scoped_vector.h" 14 #include "base/memory/weak_ptr.h" 15 #include "base/observer_list.h" 16 #include "base/threading/non_thread_safe.h" 17 #include "base/threading/thread.h" 18 #include "net/base/backoff_entry.h" 19 #include "remoting/host/client_session.h" 20 #include "remoting/host/host_extension.h" 21 #include "remoting/host/host_status_monitor.h" 22 #include "remoting/host/host_status_observer.h" 23 #include "remoting/protocol/authenticator.h" 24 #include "remoting/protocol/connection_to_client.h" 25 #include "remoting/protocol/pairing_registry.h" 26 #include "remoting/protocol/session_manager.h" 27 28 namespace base { 29 class SingleThreadTaskRunner; 30 } // namespace base 31 32 namespace remoting { 33 34 namespace protocol { 35 class InputStub; 36 class SessionConfig; 37 class CandidateSessionConfig; 38 } // namespace protocol 39 40 class DesktopEnvironmentFactory; 41 42 // A class to implement the functionality of a host process. 43 // 44 // Here's the work flow of this class: 45 // 1. We should load the saved GAIA ID token or if this is the first 46 // time the host process runs we should prompt user for the 47 // credential. We will use this token or credentials to authenicate 48 // and register the host. 49 // 50 // 2. We listen for incoming connection using libjingle. We will create 51 // a ConnectionToClient object that wraps around linjingle for transport. 52 // A VideoScheduler is created with an Encoder and a webrtc::ScreenCapturer. 53 // A ConnectionToClient is added to the ScreenRecorder for transporting 54 // the screen captures. An InputStub is created and registered with the 55 // ConnectionToClient to receive mouse / keyboard events from the remote 56 // client. 57 // After we have done all the initialization we'll start the ScreenRecorder. 58 // We'll then enter the running state of the host process. 59 // 60 // 3. When the user is disconnected, we will pause the ScreenRecorder 61 // and try to terminate the threads we have created. This will allow 62 // all pending tasks to complete. After all of that completed we 63 // return to the idle state. We then go to step (2) if there a new 64 // incoming connection. 65 class ChromotingHost : public base::NonThreadSafe, 66 public ClientSession::EventHandler, 67 public protocol::SessionManager::Listener, 68 public HostStatusMonitor { 69 public: 70 // Both |signal_strategy| and |desktop_environment_factory| should outlive 71 // this object. 72 ChromotingHost( 73 SignalStrategy* signal_strategy, 74 DesktopEnvironmentFactory* desktop_environment_factory, 75 scoped_ptr<protocol::SessionManager> session_manager, 76 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner, 77 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner, 78 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner, 79 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner, 80 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner, 81 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner); 82 virtual ~ChromotingHost(); 83 84 // Asynchronously starts the host. 85 // 86 // After this is invoked, the host process will connect to the talk 87 // network and start listening for incoming connections. 88 // 89 // This method can only be called once during the lifetime of this object. 90 void Start(const std::string& host_owner); 91 92 // HostStatusMonitor interface. 93 virtual void AddStatusObserver(HostStatusObserver* observer) OVERRIDE; 94 virtual void RemoveStatusObserver(HostStatusObserver* observer) OVERRIDE; 95 96 // Registers a host extension. 97 void AddExtension(scoped_ptr<HostExtension> extension); 98 99 // This method may be called only from 100 // HostStatusObserver::OnClientAuthenticated() to reject the new 101 // client. 102 void RejectAuthenticatingClient(); 103 104 // Sets the authenticator factory to use for incoming 105 // connections. Incoming connections are rejected until 106 // authenticator factory is set. Must be called on the network 107 // thread after the host is started. Must not be called more than 108 // once per host instance because it may not be safe to delete 109 // factory before all authenticators it created are deleted. 110 void SetAuthenticatorFactory( 111 scoped_ptr<protocol::AuthenticatorFactory> authenticator_factory); 112 113 // Enables/disables curtaining when one or more clients are connected. 114 // Takes immediate effect if clients are already connected. 115 void SetEnableCurtaining(bool enable); 116 117 // Sets the maximum duration of any session. By default, a session has no 118 // maximum duration. 119 void SetMaximumSessionDuration(const base::TimeDelta& max_session_duration); 120 121 //////////////////////////////////////////////////////////////////////////// 122 // ClientSession::EventHandler implementation. 123 virtual void OnSessionAuthenticating(ClientSession* client) OVERRIDE; 124 virtual bool OnSessionAuthenticated(ClientSession* client) OVERRIDE; 125 virtual void OnSessionChannelsConnected(ClientSession* client) OVERRIDE; 126 virtual void OnSessionClientCapabilities(ClientSession* client) OVERRIDE; 127 virtual void OnSessionAuthenticationFailed(ClientSession* client) OVERRIDE; 128 virtual void OnSessionClosed(ClientSession* session) OVERRIDE; 129 virtual void OnSessionSequenceNumber(ClientSession* session, 130 int64 sequence_number) OVERRIDE; 131 virtual void OnSessionRouteChange( 132 ClientSession* session, 133 const std::string& channel_name, 134 const protocol::TransportRoute& route) OVERRIDE; 135 136 // SessionManager::Listener implementation. 137 virtual void OnSessionManagerReady() OVERRIDE; 138 virtual void OnIncomingSession( 139 protocol::Session* session, 140 protocol::SessionManager::IncomingSessionResponse* response) OVERRIDE; 141 142 // Gets the candidate configuration for the protocol. protocol_config()143 const protocol::CandidateSessionConfig* protocol_config() const { 144 return protocol_config_.get(); 145 } 146 147 // Sets desired configuration for the protocol. Must be called before Start(). 148 void set_protocol_config(scoped_ptr<protocol::CandidateSessionConfig> config); 149 150 // The host uses a pairing registry to generate and store pairing information 151 // for clients for PIN-less authentication. pairing_registry()152 scoped_refptr<protocol::PairingRegistry> pairing_registry() const { 153 return pairing_registry_; 154 } set_pairing_registry(scoped_refptr<protocol::PairingRegistry> pairing_registry)155 void set_pairing_registry( 156 scoped_refptr<protocol::PairingRegistry> pairing_registry) { 157 pairing_registry_ = pairing_registry; 158 } 159 AsWeakPtr()160 base::WeakPtr<ChromotingHost> AsWeakPtr() { 161 return weak_factory_.GetWeakPtr(); 162 } 163 164 private: 165 friend class ChromotingHostTest; 166 167 typedef std::list<ClientSession*> ClientList; 168 typedef ScopedVector<HostExtension> HostExtensionList; 169 170 // Immediately disconnects all active clients. Host-internal components may 171 // shutdown asynchronously, but the caller is guaranteed not to receive 172 // callbacks for disconnected clients after this call returns. 173 void DisconnectAllClients(); 174 175 // Unless specified otherwise all members of this class must be 176 // used on the network thread only. 177 178 // Parameters specified when the host was created. 179 DesktopEnvironmentFactory* desktop_environment_factory_; 180 scoped_ptr<protocol::SessionManager> session_manager_; 181 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_; 182 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_; 183 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_; 184 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_; 185 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_; 186 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_; 187 188 // Connection objects. 189 SignalStrategy* signal_strategy_; 190 191 // Must be used on the network thread only. 192 ObserverList<HostStatusObserver> status_observers_; 193 194 // The connections to remote clients. 195 ClientList clients_; 196 197 // True if the host has been started. 198 bool started_; 199 200 // Configuration of the protocol. 201 scoped_ptr<protocol::CandidateSessionConfig> protocol_config_; 202 203 // Login backoff state. 204 net::BackoffEntry login_backoff_; 205 206 // Flags used for RejectAuthenticatingClient(). 207 bool authenticating_client_; 208 bool reject_authenticating_client_; 209 210 // True if the curtain mode is enabled. 211 bool enable_curtaining_; 212 213 // The maximum duration of any session. 214 base::TimeDelta max_session_duration_; 215 216 // The pairing registry for PIN-less authentication. 217 scoped_refptr<protocol::PairingRegistry> pairing_registry_; 218 219 // List of host extensions. 220 HostExtensionList extensions_; 221 222 base::WeakPtrFactory<ChromotingHost> weak_factory_; 223 224 DISALLOW_COPY_AND_ASSIGN(ChromotingHost); 225 }; 226 227 } // namespace remoting 228 229 #endif // REMOTING_HOST_CHROMOTING_HOST_H_ 230