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.
5 #ifndef NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_
6 #define NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_
12 #include "base/memory/ref_counted.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/time/time.h"
15 #include "net/base/privacy_mode.h"
16 #include "net/dns/host_resolver.h"
17 #include "net/http/http_response_info.h"
18 #include "net/socket/client_socket_pool.h"
19 #include "net/socket/client_socket_pool_base.h"
20 #include "net/socket/client_socket_pool_histograms.h"
21 #include "net/socket/ssl_client_socket.h"
22 #include "net/ssl/ssl_config_service.h"
27 class ClientSocketFactory;
28 class ConnectJobFactory;
31 class HttpProxyClientSocketPool;
32 class HttpProxySocketParams;
33 class SOCKSClientSocketPool;
34 class SOCKSSocketParams;
35 class SSLClientSocket;
36 class TransportClientSocketPool;
37 class TransportSecurityState;
38 class TransportSocketParams;
40 class NET_EXPORT_PRIVATE SSLSocketParams
41 : public base::RefCounted<SSLSocketParams> {
43 enum ConnectionType { DIRECT, SOCKS_PROXY, HTTP_PROXY };
45 // Exactly one of |direct_params|, |socks_proxy_params|, and
46 // |http_proxy_params| must be non-NULL.
48 const scoped_refptr<TransportSocketParams>& direct_params,
49 const scoped_refptr<SOCKSSocketParams>& socks_proxy_params,
50 const scoped_refptr<HttpProxySocketParams>& http_proxy_params,
51 const HostPortPair& host_and_port,
52 const SSLConfig& ssl_config,
53 PrivacyMode privacy_mode,
55 bool force_spdy_over_ssl,
56 bool want_spdy_over_npn);
58 // Returns the type of the underlying connection.
59 ConnectionType GetConnectionType() const;
61 // Must be called only when GetConnectionType() returns DIRECT.
62 const scoped_refptr<TransportSocketParams>&
63 GetDirectConnectionParams() const;
65 // Must be called only when GetConnectionType() returns SOCKS_PROXY.
66 const scoped_refptr<SOCKSSocketParams>&
67 GetSocksProxyConnectionParams() const;
69 // Must be called only when GetConnectionType() returns HTTP_PROXY.
70 const scoped_refptr<HttpProxySocketParams>&
71 GetHttpProxyConnectionParams() const;
73 const HostPortPair& host_and_port() const { return host_and_port_; }
74 const SSLConfig& ssl_config() const { return ssl_config_; }
75 PrivacyMode privacy_mode() const { return privacy_mode_; }
76 int load_flags() const { return load_flags_; }
77 bool force_spdy_over_ssl() const { return force_spdy_over_ssl_; }
78 bool want_spdy_over_npn() const { return want_spdy_over_npn_; }
79 bool ignore_limits() const { return ignore_limits_; }
82 friend class base::RefCounted<SSLSocketParams>;
85 const scoped_refptr<TransportSocketParams> direct_params_;
86 const scoped_refptr<SOCKSSocketParams> socks_proxy_params_;
87 const scoped_refptr<HttpProxySocketParams> http_proxy_params_;
88 const HostPortPair host_and_port_;
89 const SSLConfig ssl_config_;
90 const PrivacyMode privacy_mode_;
91 const int load_flags_;
92 const bool force_spdy_over_ssl_;
93 const bool want_spdy_over_npn_;
96 DISALLOW_COPY_AND_ASSIGN(SSLSocketParams);
99 // SSLConnectJobMessenger handles communication between concurrent
100 // SSLConnectJobs that share the same SSL session cache key.
102 // SSLConnectJobMessengers tell the session cache when a certain
103 // connection should be monitored for success or failure, and
104 // tell SSLConnectJobs when to pause or resume their connections.
105 class SSLConnectJobMessenger {
107 struct SocketAndCallback {
108 SocketAndCallback(SSLClientSocket* ssl_socket,
109 const base::Closure& job_resumption_callback);
110 ~SocketAndCallback();
112 SSLClientSocket* socket;
113 base::Closure callback;
116 typedef std::vector<SocketAndCallback> SSLPendingSocketsAndCallbacks;
118 // |messenger_finished_callback| is run when a connection monitored by the
119 // SSLConnectJobMessenger has completed and we are finished with the
120 // SSLConnectJobMessenger.
121 explicit SSLConnectJobMessenger(
122 const base::Closure& messenger_finished_callback);
123 ~SSLConnectJobMessenger();
125 // Removes |socket| from the set of sockets being monitored. This
126 // guarantees that |job_resumption_callback| will not be called for
128 void RemovePendingSocket(SSLClientSocket* ssl_socket);
130 // Returns true if |ssl_socket|'s Connect() method should be called.
131 bool CanProceed(SSLClientSocket* ssl_socket);
133 // Configures the SSLConnectJobMessenger to begin monitoring |ssl_socket|'s
134 // connection status. After a successful connection, or an error,
135 // the messenger will determine which sockets that have been added
136 // via AddPendingSocket() to allow to proceed.
137 void MonitorConnectionResult(SSLClientSocket* ssl_socket);
139 // Adds |socket| to the list of sockets waiting to Connect(). When
140 // the messenger has determined that it's an appropriate time for |socket|
141 // to connect, it will invoke |callback|.
143 // Note: It is an error to call AddPendingSocket() without having first
144 // called MonitorConnectionResult() and configuring a socket that WILL
145 // have Connect() called on it.
146 void AddPendingSocket(SSLClientSocket* ssl_socket,
147 const base::Closure& callback);
150 // Processes pending callbacks when a socket completes its SSL handshake --
151 // either successfully or unsuccessfully.
152 void OnSSLHandshakeCompleted();
154 // Runs all callbacks stored in |pending_sockets_and_callbacks_|.
155 void RunAllCallbacks(
156 const SSLPendingSocketsAndCallbacks& pending_socket_and_callbacks);
158 SSLPendingSocketsAndCallbacks pending_sockets_and_callbacks_;
159 // Note: this field is a vector to allow for future design changes. Currently,
160 // this vector should only ever have one entry.
161 std::vector<SSLClientSocket*> connecting_sockets_;
163 base::Closure messenger_finished_callback_;
165 base::WeakPtrFactory<SSLConnectJobMessenger> weak_factory_;
168 // SSLConnectJob handles the SSL handshake after setting up the underlying
169 // connection as specified in the params.
170 class SSLConnectJob : public ConnectJob {
172 // Callback to allow the SSLConnectJob to obtain an SSLConnectJobMessenger to
173 // coordinate connecting. The SSLConnectJob will supply a unique identifer
174 // (ex: the SSL session cache key), with the expectation that the same
175 // Messenger will be returned for all such ConnectJobs.
177 // Note: It will only be called for situations where the SSL session cache
178 // does not already have a candidate session to resume.
179 typedef base::Callback<SSLConnectJobMessenger*(const std::string&)>
180 GetMessengerCallback;
182 // Note: the SSLConnectJob does not own |messenger| so it must outlive the
184 SSLConnectJob(const std::string& group_name,
185 RequestPriority priority,
186 const scoped_refptr<SSLSocketParams>& params,
187 const base::TimeDelta& timeout_duration,
188 TransportClientSocketPool* transport_pool,
189 SOCKSClientSocketPool* socks_pool,
190 HttpProxyClientSocketPool* http_proxy_pool,
191 ClientSocketFactory* client_socket_factory,
192 HostResolver* host_resolver,
193 const SSLClientSocketContext& context,
194 const GetMessengerCallback& get_messenger_callback,
197 ~SSLConnectJob() override;
199 // ConnectJob methods.
200 LoadState GetLoadState() const override;
202 void GetAdditionalErrorState(ClientSocketHandle* handle) override;
206 STATE_TRANSPORT_CONNECT,
207 STATE_TRANSPORT_CONNECT_COMPLETE,
209 STATE_SOCKS_CONNECT_COMPLETE,
210 STATE_TUNNEL_CONNECT,
211 STATE_TUNNEL_CONNECT_COMPLETE,
212 STATE_CREATE_SSL_SOCKET,
213 STATE_CHECK_FOR_RESUME,
215 STATE_SSL_CONNECT_COMPLETE,
219 void OnIOComplete(int result);
221 // Runs the state transition loop.
222 int DoLoop(int result);
224 int DoTransportConnect();
225 int DoTransportConnectComplete(int result);
226 int DoSOCKSConnect();
227 int DoSOCKSConnectComplete(int result);
228 int DoTunnelConnect();
229 int DoTunnelConnectComplete(int result);
230 int DoCreateSSLSocket();
231 int DoCheckForResume();
233 int DoSSLConnectComplete(int result);
235 // Tells a waiting SSLConnectJob to resume its SSL connection.
236 void ResumeSSLConnection();
238 // Returns the initial state for the state machine based on the
239 // |connection_type|.
240 static State GetInitialState(SSLSocketParams::ConnectionType connection_type);
242 // Starts the SSL connection process. Returns OK on success and
243 // ERR_IO_PENDING if it cannot immediately service the request.
244 // Otherwise, it returns a net error code.
245 int ConnectInternal() override;
247 scoped_refptr<SSLSocketParams> params_;
248 TransportClientSocketPool* const transport_pool_;
249 SOCKSClientSocketPool* const socks_pool_;
250 HttpProxyClientSocketPool* const http_proxy_pool_;
251 ClientSocketFactory* const client_socket_factory_;
252 HostResolver* const host_resolver_;
254 const SSLClientSocketContext context_;
257 CompletionCallback io_callback_;
258 scoped_ptr<ClientSocketHandle> transport_socket_handle_;
259 scoped_ptr<SSLClientSocket> ssl_socket_;
261 SSLConnectJobMessenger* messenger_;
262 HttpResponseInfo error_response_info_;
264 GetMessengerCallback get_messenger_callback_;
266 base::WeakPtrFactory<SSLConnectJob> weak_factory_;
268 DISALLOW_COPY_AND_ASSIGN(SSLConnectJob);
271 class NET_EXPORT_PRIVATE SSLClientSocketPool
272 : public ClientSocketPool,
273 public HigherLayeredPool,
274 public SSLConfigService::Observer {
276 typedef SSLSocketParams SocketParams;
278 // Only the pools that will be used are required. i.e. if you never
279 // try to create an SSL over SOCKS socket, |socks_pool| may be NULL.
280 SSLClientSocketPool(int max_sockets,
281 int max_sockets_per_group,
282 ClientSocketPoolHistograms* histograms,
283 HostResolver* host_resolver,
284 CertVerifier* cert_verifier,
285 ChannelIDService* channel_id_service,
286 TransportSecurityState* transport_security_state,
287 CTVerifier* cert_transparency_verifier,
288 const std::string& ssl_session_cache_shard,
289 ClientSocketFactory* client_socket_factory,
290 TransportClientSocketPool* transport_pool,
291 SOCKSClientSocketPool* socks_pool,
292 HttpProxyClientSocketPool* http_proxy_pool,
293 SSLConfigService* ssl_config_service,
294 bool enable_ssl_connect_job_waiting,
297 ~SSLClientSocketPool() override;
299 // ClientSocketPool implementation.
300 int RequestSocket(const std::string& group_name,
301 const void* connect_params,
302 RequestPriority priority,
303 ClientSocketHandle* handle,
304 const CompletionCallback& callback,
305 const BoundNetLog& net_log) override;
307 void RequestSockets(const std::string& group_name,
310 const BoundNetLog& net_log) override;
312 void CancelRequest(const std::string& group_name,
313 ClientSocketHandle* handle) override;
315 void ReleaseSocket(const std::string& group_name,
316 scoped_ptr<StreamSocket> socket,
319 void FlushWithError(int error) override;
321 void CloseIdleSockets() override;
323 int IdleSocketCount() const override;
325 int IdleSocketCountInGroup(const std::string& group_name) const override;
327 LoadState GetLoadState(const std::string& group_name,
328 const ClientSocketHandle* handle) const override;
330 base::DictionaryValue* GetInfoAsValue(
331 const std::string& name,
332 const std::string& type,
333 bool include_nested_pools) const override;
335 base::TimeDelta ConnectionTimeout() const override;
337 ClientSocketPoolHistograms* histograms() const override;
339 // LowerLayeredPool implementation.
340 bool IsStalled() const override;
342 void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
344 void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
346 // HigherLayeredPool implementation.
347 bool CloseOneIdleConnection() override;
349 // Gets the SSLConnectJobMessenger for the given ssl session |cache_key|. If
350 // none exits, it creates one and stores it in |messenger_map_|.
351 SSLConnectJobMessenger* GetOrCreateSSLConnectJobMessenger(
352 const std::string& cache_key);
353 void DeleteSSLConnectJobMessenger(const std::string& cache_key);
356 typedef ClientSocketPoolBase<SSLSocketParams> PoolBase;
357 // Maps SSLConnectJob cache keys to SSLConnectJobMessenger objects.
358 typedef std::map<std::string, SSLConnectJobMessenger*> MessengerMap;
360 // SSLConfigService::Observer implementation.
362 // When the user changes the SSL config, we flush all idle sockets so they
363 // won't get re-used.
364 void OnSSLConfigChanged() override;
366 class SSLConnectJobFactory : public PoolBase::ConnectJobFactory {
368 SSLConnectJobFactory(
369 TransportClientSocketPool* transport_pool,
370 SOCKSClientSocketPool* socks_pool,
371 HttpProxyClientSocketPool* http_proxy_pool,
372 ClientSocketFactory* client_socket_factory,
373 HostResolver* host_resolver,
374 const SSLClientSocketContext& context,
375 const SSLConnectJob::GetMessengerCallback& get_messenger_callback,
378 ~SSLConnectJobFactory() override;
380 // ClientSocketPoolBase::ConnectJobFactory methods.
381 scoped_ptr<ConnectJob> NewConnectJob(
382 const std::string& group_name,
383 const PoolBase::Request& request,
384 ConnectJob::Delegate* delegate) const override;
386 base::TimeDelta ConnectionTimeout() const override;
389 TransportClientSocketPool* const transport_pool_;
390 SOCKSClientSocketPool* const socks_pool_;
391 HttpProxyClientSocketPool* const http_proxy_pool_;
392 ClientSocketFactory* const client_socket_factory_;
393 HostResolver* const host_resolver_;
394 const SSLClientSocketContext context_;
395 base::TimeDelta timeout_;
396 SSLConnectJob::GetMessengerCallback get_messenger_callback_;
399 DISALLOW_COPY_AND_ASSIGN(SSLConnectJobFactory);
402 TransportClientSocketPool* const transport_pool_;
403 SOCKSClientSocketPool* const socks_pool_;
404 HttpProxyClientSocketPool* const http_proxy_pool_;
406 const scoped_refptr<SSLConfigService> ssl_config_service_;
407 MessengerMap messenger_map_;
408 bool enable_ssl_connect_job_waiting_;
410 DISALLOW_COPY_AND_ASSIGN(SSLClientSocketPool);
415 #endif // NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_