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
destination()57 const HostResolver::RequestInfo& destination() const { return destination_; }
ignore_limits()58 bool ignore_limits() const { return ignore_limits_; }
host_resolution_callback()59 const OnHostResolutionCallback& host_resolution_callback() const {
60 return host_resolution_callback_;
61 }
62
combine_connect_and_write()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
client_socket_factory()106 ClientSocketFactory* client_socket_factory() {
107 return client_socket_factory_;
108 }
109
addresses()110 const AddressList& addresses() const { return addresses_; }
next_state()111 State next_state() const { return next_state_; }
set_next_state(State next_state)112 void set_next_state(State next_state) { next_state_ = next_state; }
on_io_complete()113 CompletionCallback on_io_complete() const { return on_io_complete_; }
params()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:
TransportConnectJobFactory(ClientSocketFactory * client_socket_factory,HostResolver * host_resolver,NetLog * net_log)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
~TransportConnectJobFactory()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>
DoConnectInternal(T * job)308 int TransportConnectJobHelper::DoConnectInternal(T* job) {
309 next_state_ = STATE_RESOLVE_HOST;
310 return this->DoLoop(job, OK);
311 }
312
313 template <class T>
SetOnIOComplete(T * job)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>
OnIOComplete(T * job,int result)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>
DoLoop(T * job,int result)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