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_CLIENT_SESSION_H_ 6 #define REMOTING_HOST_CLIENT_SESSION_H_ 7 8 #include <string> 9 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_vector.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/sequenced_task_runner_helpers.h" 14 #include "base/threading/non_thread_safe.h" 15 #include "base/time/time.h" 16 #include "base/timer/timer.h" 17 #include "remoting/host/client_session_control.h" 18 #include "remoting/host/gnubby_auth_handler.h" 19 #include "remoting/host/host_extension.h" 20 #include "remoting/host/host_extension_session.h" 21 #include "remoting/host/mouse_clamping_filter.h" 22 #include "remoting/host/remote_input_filter.h" 23 #include "remoting/protocol/clipboard_echo_filter.h" 24 #include "remoting/protocol/clipboard_filter.h" 25 #include "remoting/protocol/clipboard_stub.h" 26 #include "remoting/protocol/connection_to_client.h" 27 #include "remoting/protocol/host_stub.h" 28 #include "remoting/protocol/input_event_tracker.h" 29 #include "remoting/protocol/input_filter.h" 30 #include "remoting/protocol/input_stub.h" 31 #include "remoting/protocol/pairing_registry.h" 32 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h" 33 34 namespace base { 35 class SingleThreadTaskRunner; 36 } // namespace base 37 38 namespace remoting { 39 40 class AudioEncoder; 41 class AudioScheduler; 42 class DesktopEnvironment; 43 class DesktopEnvironmentFactory; 44 class InputInjector; 45 class ScreenControls; 46 class VideoEncoder; 47 class VideoScheduler; 48 49 // A ClientSession keeps a reference to a connection to a client, and maintains 50 // per-client state. 51 class ClientSession 52 : public base::NonThreadSafe, 53 public protocol::HostStub, 54 public protocol::ConnectionToClient::EventHandler, 55 public ClientSessionControl { 56 public: 57 // Callback interface for passing events to the ChromotingHost. 58 class EventHandler { 59 public: 60 // Called after authentication has started. 61 virtual void OnSessionAuthenticating(ClientSession* client) = 0; 62 63 // Called after authentication has finished successfully. Returns true if 64 // the connection is allowed, or false otherwise. 65 virtual bool OnSessionAuthenticated(ClientSession* client) = 0; 66 67 // Called after we've finished connecting all channels. 68 virtual void OnSessionChannelsConnected(ClientSession* client) = 0; 69 70 // Called after client has reported capabilities. 71 virtual void OnSessionClientCapabilities(ClientSession* client) = 0; 72 73 // Called after authentication has failed. Must not tear down this 74 // object. OnSessionClosed() is notified after this handler 75 // returns. 76 virtual void OnSessionAuthenticationFailed(ClientSession* client) = 0; 77 78 // Called after connection has failed or after the client closed it. 79 virtual void OnSessionClosed(ClientSession* client) = 0; 80 81 // Called to notify of each message's sequence number. The 82 // callback must not tear down this object. 83 virtual void OnSessionSequenceNumber(ClientSession* client, 84 int64 sequence_number) = 0; 85 86 // Called on notification of a route change event, when a channel is 87 // connected. 88 virtual void OnSessionRouteChange( 89 ClientSession* client, 90 const std::string& channel_name, 91 const protocol::TransportRoute& route) = 0; 92 93 protected: ~EventHandler()94 virtual ~EventHandler() {} 95 }; 96 97 // |event_handler| and |desktop_environment_factory| must outlive |this|. 98 ClientSession( 99 EventHandler* event_handler, 100 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner, 101 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner, 102 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner, 103 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner, 104 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner, 105 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner, 106 scoped_ptr<protocol::ConnectionToClient> connection, 107 DesktopEnvironmentFactory* desktop_environment_factory, 108 const base::TimeDelta& max_duration, 109 scoped_refptr<protocol::PairingRegistry> pairing_registry); 110 virtual ~ClientSession(); 111 112 // Adds an extension to client to handle extension messages. 113 void AddExtensionSession(scoped_ptr<HostExtensionSession> extension_session); 114 115 // Adds extended capabilities to advertise to the client, e.g. those 116 // implemented by |DesktopEnvironment| or |HostExtension|s. 117 void AddHostCapabilities(const std::string& capability); 118 119 // protocol::HostStub interface. 120 virtual void NotifyClientResolution( 121 const protocol::ClientResolution& resolution) OVERRIDE; 122 virtual void ControlVideo( 123 const protocol::VideoControl& video_control) OVERRIDE; 124 virtual void ControlAudio( 125 const protocol::AudioControl& audio_control) OVERRIDE; 126 virtual void SetCapabilities( 127 const protocol::Capabilities& capabilities) OVERRIDE; 128 virtual void RequestPairing( 129 const remoting::protocol::PairingRequest& pairing_request) OVERRIDE; 130 virtual void DeliverClientMessage( 131 const protocol::ExtensionMessage& message) OVERRIDE; 132 133 // protocol::ConnectionToClient::EventHandler interface. 134 virtual void OnConnectionAuthenticating( 135 protocol::ConnectionToClient* connection) OVERRIDE; 136 virtual void OnConnectionAuthenticated( 137 protocol::ConnectionToClient* connection) OVERRIDE; 138 virtual void OnConnectionChannelsConnected( 139 protocol::ConnectionToClient* connection) OVERRIDE; 140 virtual void OnConnectionClosed(protocol::ConnectionToClient* connection, 141 protocol::ErrorCode error) OVERRIDE; 142 virtual void OnSequenceNumberUpdated( 143 protocol::ConnectionToClient* connection, int64 sequence_number) OVERRIDE; 144 virtual void OnRouteChange( 145 protocol::ConnectionToClient* connection, 146 const std::string& channel_name, 147 const protocol::TransportRoute& route) OVERRIDE; 148 149 // ClientSessionControl interface. 150 virtual const std::string& client_jid() const OVERRIDE; 151 virtual void DisconnectSession() OVERRIDE; 152 virtual void OnLocalMouseMoved( 153 const webrtc::DesktopVector& position) OVERRIDE; 154 virtual void SetDisableInputs(bool disable_inputs) OVERRIDE; 155 156 void SetGnubbyAuthHandlerForTesting(GnubbyAuthHandler* gnubby_auth_handler); 157 connection()158 protocol::ConnectionToClient* connection() const { 159 return connection_.get(); 160 } 161 is_authenticated()162 bool is_authenticated() { return auth_input_filter_.enabled(); } 163 client_capabilities()164 const std::string* client_capabilities() const { 165 return client_capabilities_.get(); 166 } 167 168 private: 169 typedef ScopedVector<HostExtensionSession> HostExtensionSessionList; 170 171 // Creates a proxy for sending clipboard events to the client. 172 scoped_ptr<protocol::ClipboardStub> CreateClipboardProxy(); 173 174 // Creates an audio encoder for the specified configuration. 175 static scoped_ptr<AudioEncoder> CreateAudioEncoder( 176 const protocol::SessionConfig& config); 177 178 // Creates a video encoder for the specified configuration. 179 static scoped_ptr<VideoEncoder> CreateVideoEncoder( 180 const protocol::SessionConfig& config); 181 182 EventHandler* event_handler_; 183 184 // The connection to the client. 185 scoped_ptr<protocol::ConnectionToClient> connection_; 186 187 std::string client_jid_; 188 189 // Used to disable callbacks to |this| once DisconnectSession() has been 190 // called. 191 base::WeakPtrFactory<ClientSessionControl> control_factory_; 192 193 // Used to create a DesktopEnvironment instance for this session. 194 DesktopEnvironmentFactory* desktop_environment_factory_; 195 196 // The DesktopEnvironment instance for this session. 197 scoped_ptr<DesktopEnvironment> desktop_environment_; 198 199 // Filter used as the final element in the input pipeline. 200 protocol::InputFilter host_input_filter_; 201 202 // Tracker used to release pressed keys and buttons when disconnecting. 203 protocol::InputEventTracker input_tracker_; 204 205 // Filter used to disable remote inputs during local input activity. 206 RemoteInputFilter remote_input_filter_; 207 208 // Filter used to clamp mouse events to the current display dimensions. 209 MouseClampingFilter mouse_clamping_filter_; 210 211 // Filter to used to stop clipboard items sent from the client being echoed 212 // back to it. It is the final element in the clipboard (client -> host) 213 // pipeline. 214 protocol::ClipboardEchoFilter clipboard_echo_filter_; 215 216 // Filters used to manage enabling & disabling of input & clipboard. 217 protocol::InputFilter disable_input_filter_; 218 protocol::ClipboardFilter disable_clipboard_filter_; 219 220 // Filters used to disable input & clipboard when we're not authenticated. 221 protocol::InputFilter auth_input_filter_; 222 protocol::ClipboardFilter auth_clipboard_filter_; 223 224 // Factory for weak pointers to the client clipboard stub. 225 // This must appear after |clipboard_echo_filter_|, so that it won't outlive 226 // it. 227 base::WeakPtrFactory<protocol::ClipboardStub> client_clipboard_factory_; 228 229 // The maximum duration of this session. 230 // There is no maximum if this value is <= 0. 231 base::TimeDelta max_duration_; 232 233 // A timer that triggers a disconnect when the maximum session duration 234 // is reached. 235 base::OneShotTimer<ClientSession> max_duration_timer_; 236 237 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_; 238 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_; 239 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_; 240 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_; 241 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_; 242 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_; 243 244 // Schedulers for audio and video capture. 245 scoped_refptr<AudioScheduler> audio_scheduler_; 246 scoped_refptr<VideoScheduler> video_scheduler_; 247 248 // The set of all capabilities supported by the client. 249 scoped_ptr<std::string> client_capabilities_; 250 251 // The set of all capabilities supported by the host. 252 std::string host_capabilities_; 253 254 // Used to inject mouse and keyboard input and handle clipboard events. 255 scoped_ptr<InputInjector> input_injector_; 256 257 // Used to apply client-requested changes in screen resolution. 258 scoped_ptr<ScreenControls> screen_controls_; 259 260 // The pairing registry for PIN-less authentication. 261 scoped_refptr<protocol::PairingRegistry> pairing_registry_; 262 263 // Used to proxy gnubby auth traffic. 264 scoped_ptr<GnubbyAuthHandler> gnubby_auth_handler_; 265 266 // Host extension sessions, used to handle extension messages. 267 HostExtensionSessionList extension_sessions_; 268 269 DISALLOW_COPY_AND_ASSIGN(ClientSession); 270 }; 271 272 } // namespace remoting 273 274 #endif // REMOTING_HOST_CLIENT_SESSION_H_ 275