1 // Copyright (c) 2011 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 NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_ 6 #define NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/time.h" 14 #include "net/base/host_resolver.h" 15 #include "net/base/ssl_config_service.h" 16 #include "net/http/http_response_info.h" 17 #include "net/proxy/proxy_server.h" 18 #include "net/socket/ssl_client_socket.h" 19 #include "net/socket/client_socket_pool_base.h" 20 #include "net/socket/client_socket_pool_histograms.h" 21 #include "net/socket/client_socket_pool.h" 22 23 namespace net { 24 25 class CertVerifier; 26 class ClientSocketFactory; 27 class ConnectJobFactory; 28 class DnsCertProvenanceChecker; 29 class DnsRRResolver; 30 class HostPortPair; 31 class HttpProxyClientSocketPool; 32 class HttpProxySocketParams; 33 class SOCKSClientSocketPool; 34 class SOCKSSocketParams; 35 class SSLClientSocket; 36 class SSLHostInfoFactory; 37 class TransportSocketParams; 38 class TransportClientSocketPool; 39 struct RRResponse; 40 41 // SSLSocketParams only needs the socket params for the transport socket 42 // that will be used (denoted by |proxy|). 43 class SSLSocketParams : public base::RefCounted<SSLSocketParams> { 44 public: 45 SSLSocketParams(const scoped_refptr<TransportSocketParams>& transport_params, 46 const scoped_refptr<SOCKSSocketParams>& socks_params, 47 const scoped_refptr<HttpProxySocketParams>& http_proxy_params, 48 ProxyServer::Scheme proxy, 49 const HostPortPair& host_and_port, 50 const SSLConfig& ssl_config, 51 int load_flags, 52 bool force_spdy_over_ssl, 53 bool want_spdy_over_npn); 54 transport_params()55 const scoped_refptr<TransportSocketParams>& transport_params() { 56 return transport_params_; 57 } http_proxy_params()58 const scoped_refptr<HttpProxySocketParams>& http_proxy_params() { 59 return http_proxy_params_; 60 } socks_params()61 const scoped_refptr<SOCKSSocketParams>& socks_params() { 62 return socks_params_; 63 } proxy()64 ProxyServer::Scheme proxy() const { return proxy_; } host_and_port()65 const HostPortPair& host_and_port() const { return host_and_port_; } ssl_config()66 const SSLConfig& ssl_config() const { return ssl_config_; } load_flags()67 int load_flags() const { return load_flags_; } force_spdy_over_ssl()68 bool force_spdy_over_ssl() const { return force_spdy_over_ssl_; } want_spdy_over_npn()69 bool want_spdy_over_npn() const { return want_spdy_over_npn_; } ignore_limits()70 bool ignore_limits() const { return ignore_limits_; } 71 #ifdef ANDROID 72 // Gets the UID of the calling process 73 bool getUID(uid_t *uid) const; 74 void setUID(uid_t uid); 75 #endif 76 77 private: 78 friend class base::RefCounted<SSLSocketParams>; 79 ~SSLSocketParams(); 80 81 const scoped_refptr<TransportSocketParams> transport_params_; 82 const scoped_refptr<HttpProxySocketParams> http_proxy_params_; 83 const scoped_refptr<SOCKSSocketParams> socks_params_; 84 const ProxyServer::Scheme proxy_; 85 const HostPortPair host_and_port_; 86 const SSLConfig ssl_config_; 87 const int load_flags_; 88 const bool force_spdy_over_ssl_; 89 const bool want_spdy_over_npn_; 90 bool ignore_limits_; 91 92 DISALLOW_COPY_AND_ASSIGN(SSLSocketParams); 93 }; 94 95 // SSLConnectJob handles the SSL handshake after setting up the underlying 96 // connection as specified in the params. 97 class SSLConnectJob : public ConnectJob { 98 public: 99 SSLConnectJob( 100 const std::string& group_name, 101 const scoped_refptr<SSLSocketParams>& params, 102 const base::TimeDelta& timeout_duration, 103 TransportClientSocketPool* transport_pool, 104 SOCKSClientSocketPool* socks_pool, 105 HttpProxyClientSocketPool* http_proxy_pool, 106 ClientSocketFactory* client_socket_factory, 107 HostResolver* host_resolver, 108 CertVerifier* cert_verifier, 109 DnsRRResolver* dnsrr_resolver, 110 DnsCertProvenanceChecker* dns_cert_checker, 111 SSLHostInfoFactory* ssl_host_info_factory, 112 Delegate* delegate, 113 NetLog* net_log); 114 virtual ~SSLConnectJob(); 115 116 // ConnectJob methods. 117 virtual LoadState GetLoadState() const; 118 119 virtual void GetAdditionalErrorState(ClientSocketHandle * handle); 120 121 private: 122 enum State { 123 STATE_TRANSPORT_CONNECT, 124 STATE_TRANSPORT_CONNECT_COMPLETE, 125 STATE_SOCKS_CONNECT, 126 STATE_SOCKS_CONNECT_COMPLETE, 127 STATE_TUNNEL_CONNECT, 128 STATE_TUNNEL_CONNECT_COMPLETE, 129 STATE_SSL_CONNECT, 130 STATE_SSL_CONNECT_COMPLETE, 131 STATE_NONE, 132 }; 133 134 void OnIOComplete(int result); 135 136 // Runs the state transition loop. 137 int DoLoop(int result); 138 139 int DoTransportConnect(); 140 int DoTransportConnectComplete(int result); 141 int DoSOCKSConnect(); 142 int DoSOCKSConnectComplete(int result); 143 int DoTunnelConnect(); 144 int DoTunnelConnectComplete(int result); 145 int DoSSLConnect(); 146 int DoSSLConnectComplete(int result); 147 148 // Starts the SSL connection process. Returns OK on success and 149 // ERR_IO_PENDING if it cannot immediately service the request. 150 // Otherwise, it returns a net error code. 151 virtual int ConnectInternal(); 152 153 scoped_refptr<SSLSocketParams> params_; 154 TransportClientSocketPool* const transport_pool_; 155 SOCKSClientSocketPool* const socks_pool_; 156 HttpProxyClientSocketPool* const http_proxy_pool_; 157 ClientSocketFactory* const client_socket_factory_; 158 HostResolver* const host_resolver_; 159 CertVerifier* const cert_verifier_; 160 DnsRRResolver* const dnsrr_resolver_; 161 DnsCertProvenanceChecker* dns_cert_checker_; 162 SSLHostInfoFactory* const ssl_host_info_factory_; 163 164 State next_state_; 165 CompletionCallbackImpl<SSLConnectJob> callback_; 166 scoped_ptr<ClientSocketHandle> transport_socket_handle_; 167 scoped_ptr<SSLClientSocket> ssl_socket_; 168 scoped_ptr<SSLHostInfo> ssl_host_info_; 169 170 // The time the DoSSLConnect() method was called. 171 base::TimeTicks ssl_connect_start_time_; 172 173 HttpResponseInfo error_response_info_; 174 175 DISALLOW_COPY_AND_ASSIGN(SSLConnectJob); 176 }; 177 178 class SSLClientSocketPool : public ClientSocketPool, 179 public SSLConfigService::Observer { 180 public: 181 // Only the pools that will be used are required. i.e. if you never 182 // try to create an SSL over SOCKS socket, |socks_pool| may be NULL. 183 SSLClientSocketPool( 184 int max_sockets, 185 int max_sockets_per_group, 186 ClientSocketPoolHistograms* histograms, 187 HostResolver* host_resolver, 188 CertVerifier* cert_verifier, 189 DnsRRResolver* dnsrr_resolver, 190 DnsCertProvenanceChecker* dns_cert_checker, 191 SSLHostInfoFactory* ssl_host_info_factory, 192 ClientSocketFactory* client_socket_factory, 193 TransportClientSocketPool* transport_pool, 194 SOCKSClientSocketPool* socks_pool, 195 HttpProxyClientSocketPool* http_proxy_pool, 196 SSLConfigService* ssl_config_service, 197 NetLog* net_log); 198 199 virtual ~SSLClientSocketPool(); 200 201 // ClientSocketPool methods: 202 virtual int RequestSocket(const std::string& group_name, 203 const void* connect_params, 204 RequestPriority priority, 205 ClientSocketHandle* handle, 206 CompletionCallback* callback, 207 const BoundNetLog& net_log); 208 209 virtual void RequestSockets(const std::string& group_name, 210 const void* params, 211 int num_sockets, 212 const BoundNetLog& net_log); 213 214 virtual void CancelRequest(const std::string& group_name, 215 ClientSocketHandle* handle); 216 217 virtual void ReleaseSocket(const std::string& group_name, 218 ClientSocket* socket, 219 int id); 220 221 virtual void Flush(); 222 223 virtual void CloseIdleSockets(); 224 225 virtual int IdleSocketCount() const; 226 227 virtual int IdleSocketCountInGroup(const std::string& group_name) const; 228 229 virtual LoadState GetLoadState(const std::string& group_name, 230 const ClientSocketHandle* handle) const; 231 232 virtual DictionaryValue* GetInfoAsValue(const std::string& name, 233 const std::string& type, 234 bool include_nested_pools) const; 235 236 virtual base::TimeDelta ConnectionTimeout() const; 237 238 virtual ClientSocketPoolHistograms* histograms() const; 239 240 private: 241 typedef ClientSocketPoolBase<SSLSocketParams> PoolBase; 242 243 // SSLConfigService::Observer methods: 244 245 // When the user changes the SSL config, we flush all idle sockets so they 246 // won't get re-used. 247 virtual void OnSSLConfigChanged(); 248 249 class SSLConnectJobFactory : public PoolBase::ConnectJobFactory { 250 public: 251 SSLConnectJobFactory( 252 TransportClientSocketPool* transport_pool, 253 SOCKSClientSocketPool* socks_pool, 254 HttpProxyClientSocketPool* http_proxy_pool, 255 ClientSocketFactory* client_socket_factory, 256 HostResolver* host_resolver, 257 CertVerifier* cert_verifier, 258 DnsRRResolver* dnsrr_resolver, 259 DnsCertProvenanceChecker* dns_cert_checker, 260 SSLHostInfoFactory* ssl_host_info_factory, 261 NetLog* net_log); 262 ~SSLConnectJobFactory()263 virtual ~SSLConnectJobFactory() {} 264 265 // ClientSocketPoolBase::ConnectJobFactory methods. 266 virtual ConnectJob* NewConnectJob( 267 const std::string& group_name, 268 const PoolBase::Request& request, 269 ConnectJob::Delegate* delegate) const; 270 ConnectionTimeout()271 virtual base::TimeDelta ConnectionTimeout() const { return timeout_; } 272 273 private: 274 TransportClientSocketPool* const transport_pool_; 275 SOCKSClientSocketPool* const socks_pool_; 276 HttpProxyClientSocketPool* const http_proxy_pool_; 277 ClientSocketFactory* const client_socket_factory_; 278 HostResolver* const host_resolver_; 279 CertVerifier* const cert_verifier_; 280 DnsRRResolver* const dnsrr_resolver_; 281 DnsCertProvenanceChecker* const dns_cert_checker_; 282 SSLHostInfoFactory* const ssl_host_info_factory_; 283 base::TimeDelta timeout_; 284 NetLog* net_log_; 285 286 DISALLOW_COPY_AND_ASSIGN(SSLConnectJobFactory); 287 }; 288 289 TransportClientSocketPool* const transport_pool_; 290 SOCKSClientSocketPool* const socks_pool_; 291 HttpProxyClientSocketPool* const http_proxy_pool_; 292 PoolBase base_; 293 const scoped_refptr<SSLConfigService> ssl_config_service_; 294 295 DISALLOW_COPY_AND_ASSIGN(SSLClientSocketPool); 296 }; 297 298 REGISTER_SOCKET_PARAMS_FOR_POOL(SSLClientSocketPool, SSLSocketParams); 299 300 } // namespace net 301 302 #endif // NET_SOCKET_SSL_CLIENT_SOCKET_POOL_H_ 303