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 NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ 6 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/time/time.h" 14 #include "base/timer/timer.h" 15 #include "net/base/host_port_pair.h" 16 #include "net/dns/host_resolver.h" 17 #include "net/dns/single_request_host_resolver.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 22 namespace net { 23 24 class ClientSocketFactory; 25 26 typedef base::Callback<int(const AddressList&, const BoundNetLog& net_log)> 27 OnHostResolutionCallback; 28 29 class NET_EXPORT_PRIVATE TransportSocketParams 30 : public base::RefCounted<TransportSocketParams> { 31 public: 32 // CombineConnectAndWrite currently translates to using TCP FastOpen. 33 // TCP FastOpen should not be used if the first write to the socket may 34 // be non-idempotent, as the underlying socket could retransmit the data 35 // on failure of the first transmission. 36 // NOTE: Currently, COMBINE_CONNECT_AND_WRITE_DESIRED is used if the data in 37 // the write is known to be idempotent, and COMBINE_CONNECT_AND_WRITE_DEFAULT 38 // is used as a default for other cases (including non-idempotent writes). 39 enum CombineConnectAndWritePolicy { 40 COMBINE_CONNECT_AND_WRITE_DEFAULT, // Default policy, implemented in 41 // TransportSocketParams constructor. 42 COMBINE_CONNECT_AND_WRITE_DESIRED, // Combine if supported by socket. 43 COMBINE_CONNECT_AND_WRITE_PROHIBITED // Do not combine. 44 }; 45 46 // |host_resolution_callback| will be invoked after the the hostname is 47 // resolved. If |host_resolution_callback| does not return OK, then the 48 // connection will be aborted with that value. |combine_connect_and_write| 49 // defines the policy for use of TCP FastOpen on this socket. 50 TransportSocketParams( 51 const HostPortPair& host_port_pair, 52 bool disable_resolver_cache, 53 bool ignore_limits, 54 const OnHostResolutionCallback& host_resolution_callback, 55 CombineConnectAndWritePolicy combine_connect_and_write); 56 57 const HostResolver::RequestInfo& destination() const { return destination_; } 58 bool ignore_limits() const { return ignore_limits_; } 59 const OnHostResolutionCallback& host_resolution_callback() const { 60 return host_resolution_callback_; 61 } 62 63 CombineConnectAndWritePolicy combine_connect_and_write() const { 64 return combine_connect_and_write_; 65 } 66 67 private: 68 friend class base::RefCounted<TransportSocketParams>; 69 ~TransportSocketParams(); 70 71 HostResolver::RequestInfo destination_; 72 bool ignore_limits_; 73 const OnHostResolutionCallback host_resolution_callback_; 74 CombineConnectAndWritePolicy combine_connect_and_write_; 75 76 DISALLOW_COPY_AND_ASSIGN(TransportSocketParams); 77 }; 78 79 // Common data and logic shared between TransportConnectJob and 80 // WebSocketTransportConnectJob. 81 class NET_EXPORT_PRIVATE TransportConnectJobHelper { 82 public: 83 enum State { 84 STATE_RESOLVE_HOST, 85 STATE_RESOLVE_HOST_COMPLETE, 86 STATE_TRANSPORT_CONNECT, 87 STATE_TRANSPORT_CONNECT_COMPLETE, 88 STATE_NONE, 89 }; 90 91 // For recording the connection time in the appropriate bucket. 92 enum ConnectionLatencyHistogram { 93 CONNECTION_LATENCY_UNKNOWN, 94 CONNECTION_LATENCY_IPV4_WINS_RACE, 95 CONNECTION_LATENCY_IPV4_NO_RACE, 96 CONNECTION_LATENCY_IPV6_RACEABLE, 97 CONNECTION_LATENCY_IPV6_SOLO, 98 }; 99 100 TransportConnectJobHelper(const scoped_refptr<TransportSocketParams>& params, 101 ClientSocketFactory* client_socket_factory, 102 HostResolver* host_resolver, 103 LoadTimingInfo::ConnectTiming* connect_timing); 104 ~TransportConnectJobHelper(); 105 106 ClientSocketFactory* client_socket_factory() { 107 return client_socket_factory_; 108 } 109 110 const AddressList& addresses() const { return addresses_; } 111 State next_state() const { return next_state_; } 112 void set_next_state(State next_state) { next_state_ = next_state; } 113 CompletionCallback on_io_complete() const { return on_io_complete_; } 114 const TransportSocketParams* params() { return params_.get(); } 115 116 int DoResolveHost(RequestPriority priority, const BoundNetLog& net_log); 117 int DoResolveHostComplete(int result, const BoundNetLog& net_log); 118 119 template <class T> 120 int DoConnectInternal(T* job); 121 122 template <class T> 123 void SetOnIOComplete(T* job); 124 125 template <class T> 126 void OnIOComplete(T* job, int result); 127 128 // Record the histograms Net.DNS_Resolution_And_TCP_Connection_Latency2 and 129 // Net.TCP_Connection_Latency and return the connect duration. 130 base::TimeDelta HistogramDuration(ConnectionLatencyHistogram race_result); 131 132 static const int kIPv6FallbackTimerInMs; 133 134 private: 135 template <class T> 136 int DoLoop(T* job, int result); 137 138 scoped_refptr<TransportSocketParams> params_; 139 ClientSocketFactory* const client_socket_factory_; 140 SingleRequestHostResolver resolver_; 141 AddressList addresses_; 142 State next_state_; 143 CompletionCallback on_io_complete_; 144 LoadTimingInfo::ConnectTiming* connect_timing_; 145 146 DISALLOW_COPY_AND_ASSIGN(TransportConnectJobHelper); 147 }; 148 149 // TransportConnectJob handles the host resolution necessary for socket creation 150 // and the transport (likely TCP) connect. TransportConnectJob also has fallback 151 // logic for IPv6 connect() timeouts (which may happen due to networks / routers 152 // with broken IPv6 support). Those timeouts take 20s, so rather than make the 153 // user wait 20s for the timeout to fire, we use a fallback timer 154 // (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer 155 // fires. Then we race the IPv4 connect() against the IPv6 connect() (which has 156 // a headstart) and return the one that completes first to the socket pool. 157 class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob { 158 public: 159 TransportConnectJob(const std::string& group_name, 160 RequestPriority priority, 161 const scoped_refptr<TransportSocketParams>& params, 162 base::TimeDelta timeout_duration, 163 ClientSocketFactory* client_socket_factory, 164 HostResolver* host_resolver, 165 Delegate* delegate, 166 NetLog* net_log); 167 virtual ~TransportConnectJob(); 168 169 // ConnectJob methods. 170 virtual LoadState GetLoadState() const OVERRIDE; 171 172 // Rolls |addrlist| forward until the first IPv4 address, if any. 173 // WARNING: this method should only be used to implement the prefer-IPv4 hack. 174 static void MakeAddressListStartWithIPv4(AddressList* addrlist); 175 176 private: 177 enum ConnectInterval { 178 CONNECT_INTERVAL_LE_10MS, 179 CONNECT_INTERVAL_LE_20MS, 180 CONNECT_INTERVAL_GT_20MS, 181 }; 182 183 friend class TransportConnectJobHelper; 184 185 int DoResolveHost(); 186 int DoResolveHostComplete(int result); 187 int DoTransportConnect(); 188 int DoTransportConnectComplete(int result); 189 190 // Not part of the state machine. 191 void DoIPv6FallbackTransportConnect(); 192 void DoIPv6FallbackTransportConnectComplete(int result); 193 194 // Begins the host resolution and the TCP connect. Returns OK on success 195 // and ERR_IO_PENDING if it cannot immediately service the request. 196 // Otherwise, it returns a net error code. 197 virtual int ConnectInternal() OVERRIDE; 198 199 TransportConnectJobHelper helper_; 200 201 scoped_ptr<StreamSocket> transport_socket_; 202 203 scoped_ptr<StreamSocket> fallback_transport_socket_; 204 scoped_ptr<AddressList> fallback_addresses_; 205 base::TimeTicks fallback_connect_start_time_; 206 base::OneShotTimer<TransportConnectJob> fallback_timer_; 207 208 // Track the interval between this connect and previous connect. 209 ConnectInterval interval_between_connects_; 210 211 DISALLOW_COPY_AND_ASSIGN(TransportConnectJob); 212 }; 213 214 class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool { 215 public: 216 typedef TransportSocketParams SocketParams; 217 218 TransportClientSocketPool( 219 int max_sockets, 220 int max_sockets_per_group, 221 ClientSocketPoolHistograms* histograms, 222 HostResolver* host_resolver, 223 ClientSocketFactory* client_socket_factory, 224 NetLog* net_log); 225 226 virtual ~TransportClientSocketPool(); 227 228 // ClientSocketPool implementation. 229 virtual int RequestSocket(const std::string& group_name, 230 const void* resolve_info, 231 RequestPriority priority, 232 ClientSocketHandle* handle, 233 const CompletionCallback& callback, 234 const BoundNetLog& net_log) OVERRIDE; 235 virtual void RequestSockets(const std::string& group_name, 236 const void* params, 237 int num_sockets, 238 const BoundNetLog& net_log) OVERRIDE; 239 virtual void CancelRequest(const std::string& group_name, 240 ClientSocketHandle* handle) OVERRIDE; 241 virtual void ReleaseSocket(const std::string& group_name, 242 scoped_ptr<StreamSocket> socket, 243 int id) OVERRIDE; 244 virtual void FlushWithError(int error) OVERRIDE; 245 virtual void CloseIdleSockets() OVERRIDE; 246 virtual int IdleSocketCount() const OVERRIDE; 247 virtual int IdleSocketCountInGroup( 248 const std::string& group_name) const OVERRIDE; 249 virtual LoadState GetLoadState( 250 const std::string& group_name, 251 const ClientSocketHandle* handle) const OVERRIDE; 252 virtual base::DictionaryValue* GetInfoAsValue( 253 const std::string& name, 254 const std::string& type, 255 bool include_nested_pools) const OVERRIDE; 256 virtual base::TimeDelta ConnectionTimeout() const OVERRIDE; 257 virtual ClientSocketPoolHistograms* histograms() const OVERRIDE; 258 259 // HigherLayeredPool implementation. 260 virtual bool IsStalled() const OVERRIDE; 261 virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE; 262 virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE; 263 264 protected: 265 // Methods shared with WebSocketTransportClientSocketPool 266 void NetLogTcpClientSocketPoolRequestedSocket( 267 const BoundNetLog& net_log, 268 const scoped_refptr<TransportSocketParams>* casted_params); 269 270 private: 271 typedef ClientSocketPoolBase<TransportSocketParams> PoolBase; 272 273 class TransportConnectJobFactory 274 : public PoolBase::ConnectJobFactory { 275 public: 276 TransportConnectJobFactory(ClientSocketFactory* client_socket_factory, 277 HostResolver* host_resolver, 278 NetLog* net_log) 279 : client_socket_factory_(client_socket_factory), 280 host_resolver_(host_resolver), 281 net_log_(net_log) {} 282 283 virtual ~TransportConnectJobFactory() {} 284 285 // ClientSocketPoolBase::ConnectJobFactory methods. 286 287 virtual scoped_ptr<ConnectJob> NewConnectJob( 288 const std::string& group_name, 289 const PoolBase::Request& request, 290 ConnectJob::Delegate* delegate) const OVERRIDE; 291 292 virtual base::TimeDelta ConnectionTimeout() const OVERRIDE; 293 294 private: 295 ClientSocketFactory* const client_socket_factory_; 296 HostResolver* const host_resolver_; 297 NetLog* net_log_; 298 299 DISALLOW_COPY_AND_ASSIGN(TransportConnectJobFactory); 300 }; 301 302 PoolBase base_; 303 304 DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool); 305 }; 306 307 template <class T> 308 int TransportConnectJobHelper::DoConnectInternal(T* job) { 309 next_state_ = STATE_RESOLVE_HOST; 310 return this->DoLoop(job, OK); 311 } 312 313 template <class T> 314 void TransportConnectJobHelper::SetOnIOComplete(T* job) { 315 // These usages of base::Unretained() are safe because IO callbacks are 316 // guaranteed not to be called after the object is destroyed. 317 on_io_complete_ = base::Bind(&TransportConnectJobHelper::OnIOComplete<T>, 318 base::Unretained(this), 319 base::Unretained(job)); 320 } 321 322 template <class T> 323 void TransportConnectJobHelper::OnIOComplete(T* job, int result) { 324 result = this->DoLoop(job, result); 325 if (result != ERR_IO_PENDING) 326 job->NotifyDelegateOfCompletion(result); // Deletes |job| and |this| 327 } 328 329 template <class T> 330 int TransportConnectJobHelper::DoLoop(T* job, int result) { 331 DCHECK_NE(next_state_, STATE_NONE); 332 333 int rv = result; 334 do { 335 State state = next_state_; 336 next_state_ = STATE_NONE; 337 switch (state) { 338 case STATE_RESOLVE_HOST: 339 DCHECK_EQ(OK, rv); 340 rv = job->DoResolveHost(); 341 break; 342 case STATE_RESOLVE_HOST_COMPLETE: 343 rv = job->DoResolveHostComplete(rv); 344 break; 345 case STATE_TRANSPORT_CONNECT: 346 DCHECK_EQ(OK, rv); 347 rv = job->DoTransportConnect(); 348 break; 349 case STATE_TRANSPORT_CONNECT_COMPLETE: 350 rv = job->DoTransportConnectComplete(rv); 351 break; 352 default: 353 NOTREACHED(); 354 rv = ERR_FAILED; 355 break; 356 } 357 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); 358 359 return rv; 360 } 361 362 } // namespace net 363 364 #endif // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_ 365