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_HTTP_HTTP_PROXY_CLIENT_SOCKET_POOL_H_ 6 #define NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_POOL_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/basictypes.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/time.h" 15 #include "net/base/host_port_pair.h" 16 #include "net/http/http_auth.h" 17 #include "net/http/http_response_info.h" 18 #include "net/http/proxy_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 HostResolver; 26 class HttpAuthCache; 27 class HttpAuthHandlerFactory; 28 class SSLClientSocketPool; 29 class SSLSocketParams; 30 class SpdySessionPool; 31 class SpdyStream; 32 class TransportClientSocketPool; 33 class TransportSocketParams; 34 35 // HttpProxySocketParams only needs the socket params for one of the proxy 36 // types. The other param must be NULL. When using an HTTP Proxy, 37 // |transport_params| must be set. When using an HTTPS Proxy, |ssl_params| 38 // must be set. 39 class HttpProxySocketParams : public base::RefCounted<HttpProxySocketParams> { 40 public: 41 HttpProxySocketParams( 42 const scoped_refptr<TransportSocketParams>& transport_params, 43 const scoped_refptr<SSLSocketParams>& ssl_params, 44 const GURL& request_url, 45 const std::string& user_agent, 46 HostPortPair endpoint, 47 HttpAuthCache* http_auth_cache, 48 HttpAuthHandlerFactory* http_auth_handler_factory, 49 SpdySessionPool* spdy_session_pool, 50 bool tunnel); 51 transport_params()52 const scoped_refptr<TransportSocketParams>& transport_params() const { 53 return transport_params_; 54 } ssl_params()55 const scoped_refptr<SSLSocketParams>& ssl_params() const { 56 return ssl_params_; 57 } request_url()58 const GURL& request_url() const { return request_url_; } user_agent()59 const std::string& user_agent() const { return user_agent_; } endpoint()60 const HostPortPair& endpoint() const { return endpoint_; } http_auth_cache()61 HttpAuthCache* http_auth_cache() const { return http_auth_cache_; } http_auth_handler_factory()62 HttpAuthHandlerFactory* http_auth_handler_factory() const { 63 return http_auth_handler_factory_; 64 } spdy_session_pool()65 SpdySessionPool* spdy_session_pool() { 66 return spdy_session_pool_; 67 } 68 const HostResolver::RequestInfo& destination() const; tunnel()69 bool tunnel() const { return tunnel_; } 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<HttpProxySocketParams>; 79 ~HttpProxySocketParams(); 80 81 const scoped_refptr<TransportSocketParams> transport_params_; 82 const scoped_refptr<SSLSocketParams> ssl_params_; 83 SpdySessionPool* spdy_session_pool_; 84 const GURL request_url_; 85 const std::string user_agent_; 86 const HostPortPair endpoint_; 87 HttpAuthCache* const http_auth_cache_; 88 HttpAuthHandlerFactory* const http_auth_handler_factory_; 89 const bool tunnel_; 90 bool ignore_limits_; 91 92 DISALLOW_COPY_AND_ASSIGN(HttpProxySocketParams); 93 }; 94 95 // HttpProxyConnectJob optionally establishes a tunnel through the proxy 96 // server after connecting the underlying transport socket. 97 class HttpProxyConnectJob : public ConnectJob { 98 public: 99 HttpProxyConnectJob(const std::string& group_name, 100 const scoped_refptr<HttpProxySocketParams>& params, 101 const base::TimeDelta& timeout_duration, 102 TransportClientSocketPool* transport_pool, 103 SSLClientSocketPool* ssl_pool, 104 HostResolver* host_resolver, 105 Delegate* delegate, 106 NetLog* net_log); 107 virtual ~HttpProxyConnectJob(); 108 109 // ConnectJob methods. 110 virtual LoadState GetLoadState() const; 111 112 virtual void GetAdditionalErrorState(ClientSocketHandle* handle); 113 114 private: 115 enum State { 116 STATE_TCP_CONNECT, 117 STATE_TCP_CONNECT_COMPLETE, 118 STATE_SSL_CONNECT, 119 STATE_SSL_CONNECT_COMPLETE, 120 STATE_HTTP_PROXY_CONNECT, 121 STATE_HTTP_PROXY_CONNECT_COMPLETE, 122 STATE_SPDY_PROXY_CREATE_STREAM, 123 STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE, 124 STATE_SPDY_PROXY_CONNECT_COMPLETE, 125 STATE_NONE, 126 }; 127 128 void OnIOComplete(int result); 129 130 // Runs the state transition loop. 131 int DoLoop(int result); 132 133 // Connecting to HTTP Proxy 134 int DoTransportConnect(); 135 int DoTransportConnectComplete(int result); 136 // Connecting to HTTPS Proxy 137 int DoSSLConnect(); 138 int DoSSLConnectComplete(int result); 139 140 int DoHttpProxyConnect(); 141 int DoHttpProxyConnectComplete(int result); 142 143 int DoSpdyProxyCreateStream(); 144 int DoSpdyProxyCreateStreamComplete(int result); 145 146 // Begins the tcp connection and the optional Http proxy tunnel. If the 147 // request is not immediately servicable (likely), the request will return 148 // ERR_IO_PENDING. An OK return from this function or the callback means 149 // that the connection is established; ERR_PROXY_AUTH_REQUESTED means 150 // that the tunnel needs authentication credentials, the socket will be 151 // returned in this case, and must be release back to the pool; or 152 // a standard net error code will be returned. 153 virtual int ConnectInternal(); 154 155 scoped_refptr<HttpProxySocketParams> params_; 156 TransportClientSocketPool* const transport_pool_; 157 SSLClientSocketPool* const ssl_pool_; 158 HostResolver* const resolver_; 159 160 State next_state_; 161 CompletionCallbackImpl<HttpProxyConnectJob> callback_; 162 scoped_ptr<ClientSocketHandle> transport_socket_handle_; 163 scoped_ptr<ProxyClientSocket> transport_socket_; 164 bool using_spdy_; 165 166 HttpResponseInfo error_response_info_; 167 168 scoped_refptr<SpdyStream> spdy_stream_; 169 170 DISALLOW_COPY_AND_ASSIGN(HttpProxyConnectJob); 171 }; 172 173 class HttpProxyClientSocketPool : public ClientSocketPool { 174 public: 175 HttpProxyClientSocketPool( 176 int max_sockets, 177 int max_sockets_per_group, 178 ClientSocketPoolHistograms* histograms, 179 HostResolver* host_resolver, 180 TransportClientSocketPool* transport_pool, 181 SSLClientSocketPool* ssl_pool, 182 NetLog* net_log); 183 184 virtual ~HttpProxyClientSocketPool(); 185 186 // ClientSocketPool methods: 187 virtual int RequestSocket(const std::string& group_name, 188 const void* connect_params, 189 RequestPriority priority, 190 ClientSocketHandle* handle, 191 CompletionCallback* callback, 192 const BoundNetLog& net_log); 193 194 virtual void RequestSockets(const std::string& group_name, 195 const void* params, 196 int num_sockets, 197 const BoundNetLog& net_log); 198 199 virtual void CancelRequest(const std::string& group_name, 200 ClientSocketHandle* handle); 201 202 virtual void ReleaseSocket(const std::string& group_name, 203 ClientSocket* socket, 204 int id); 205 206 virtual void Flush(); 207 208 virtual void CloseIdleSockets(); 209 210 virtual int IdleSocketCount() const; 211 212 virtual int IdleSocketCountInGroup(const std::string& group_name) const; 213 214 virtual LoadState GetLoadState(const std::string& group_name, 215 const ClientSocketHandle* handle) const; 216 217 virtual DictionaryValue* GetInfoAsValue(const std::string& name, 218 const std::string& type, 219 bool include_nested_pools) const; 220 221 virtual base::TimeDelta ConnectionTimeout() const; 222 223 virtual ClientSocketPoolHistograms* histograms() const; 224 225 private: 226 typedef ClientSocketPoolBase<HttpProxySocketParams> PoolBase; 227 228 class HttpProxyConnectJobFactory : public PoolBase::ConnectJobFactory { 229 public: 230 HttpProxyConnectJobFactory( 231 TransportClientSocketPool* transport_pool, 232 SSLClientSocketPool* ssl_pool, 233 HostResolver* host_resolver, 234 NetLog* net_log); 235 236 // ClientSocketPoolBase::ConnectJobFactory methods. 237 virtual ConnectJob* NewConnectJob(const std::string& group_name, 238 const PoolBase::Request& request, 239 ConnectJob::Delegate* delegate) const; 240 ConnectionTimeout()241 virtual base::TimeDelta ConnectionTimeout() const { return timeout_; } 242 243 private: 244 TransportClientSocketPool* const transport_pool_; 245 SSLClientSocketPool* const ssl_pool_; 246 HostResolver* const host_resolver_; 247 NetLog* net_log_; 248 base::TimeDelta timeout_; 249 250 DISALLOW_COPY_AND_ASSIGN(HttpProxyConnectJobFactory); 251 }; 252 253 TransportClientSocketPool* const transport_pool_; 254 SSLClientSocketPool* const ssl_pool_; 255 PoolBase base_; 256 257 DISALLOW_COPY_AND_ASSIGN(HttpProxyClientSocketPool); 258 }; 259 260 REGISTER_SOCKET_PARAMS_FOR_POOL(HttpProxyClientSocketPool, 261 HttpProxySocketParams); 262 263 } // namespace net 264 265 #endif // NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_POOL_H_ 266