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 #include "net/http/http_network_session.h"
6
7 #include <utility>
8
9 #include "base/compiler_specific.h"
10 #include "base/debug/stack_trace.h"
11 #include "base/logging.h"
12 #include "base/stl_util.h"
13 #include "base/strings/string_util.h"
14 #include "base/values.h"
15 #include "net/http/http_auth_handler_factory.h"
16 #include "net/http/http_response_body_drainer.h"
17 #include "net/http/http_stream_factory_impl.h"
18 #include "net/http/url_security_manager.h"
19 #include "net/proxy/proxy_service.h"
20 #include "net/quic/crypto/quic_random.h"
21 #include "net/quic/quic_clock.h"
22 #include "net/quic/quic_crypto_client_stream_factory.h"
23 #include "net/quic/quic_stream_factory.h"
24 #include "net/socket/client_socket_factory.h"
25 #include "net/socket/client_socket_pool_manager_impl.h"
26 #include "net/socket/next_proto.h"
27 #include "net/spdy/hpack_huffman_aggregator.h"
28 #include "net/spdy/spdy_session_pool.h"
29
30 namespace {
31
CreateSocketPoolManager(net::HttpNetworkSession::SocketPoolType pool_type,const net::HttpNetworkSession::Params & params)32 net::ClientSocketPoolManager* CreateSocketPoolManager(
33 net::HttpNetworkSession::SocketPoolType pool_type,
34 const net::HttpNetworkSession::Params& params) {
35 // TODO(yutak): Differentiate WebSocket pool manager and allow more
36 // simultaneous connections for WebSockets.
37 return new net::ClientSocketPoolManagerImpl(
38 params.net_log,
39 params.client_socket_factory ?
40 params.client_socket_factory :
41 net::ClientSocketFactory::GetDefaultFactory(),
42 params.host_resolver,
43 params.cert_verifier,
44 params.server_bound_cert_service,
45 params.transport_security_state,
46 params.cert_transparency_verifier,
47 params.ssl_session_cache_shard,
48 params.proxy_service,
49 params.ssl_config_service,
50 pool_type);
51 }
52
53 } // unnamed namespace
54
55 namespace net {
56
Params()57 HttpNetworkSession::Params::Params()
58 : client_socket_factory(NULL),
59 host_resolver(NULL),
60 cert_verifier(NULL),
61 server_bound_cert_service(NULL),
62 transport_security_state(NULL),
63 cert_transparency_verifier(NULL),
64 proxy_service(NULL),
65 ssl_config_service(NULL),
66 http_auth_handler_factory(NULL),
67 network_delegate(NULL),
68 net_log(NULL),
69 host_mapping_rules(NULL),
70 ignore_certificate_errors(false),
71 testing_fixed_http_port(0),
72 testing_fixed_https_port(0),
73 force_spdy_single_domain(false),
74 enable_spdy_compression(true),
75 enable_spdy_ping_based_connection_checking(true),
76 spdy_default_protocol(kProtoUnknown),
77 spdy_stream_initial_recv_window_size(0),
78 spdy_initial_max_concurrent_streams(0),
79 spdy_max_concurrent_streams_limit(0),
80 time_func(&base::TimeTicks::Now),
81 force_spdy_over_ssl(true),
82 force_spdy_always(false),
83 use_alternate_protocols(false),
84 enable_websocket_over_spdy(false),
85 enable_quic(false),
86 enable_quic_https(false),
87 enable_quic_port_selection(true),
88 enable_quic_pacing(false),
89 enable_quic_time_based_loss_detection(false),
90 enable_quic_persist_server_info(true),
91 quic_clock(NULL),
92 quic_random(NULL),
93 quic_max_packet_length(kDefaultMaxPacketSize),
94 enable_user_alternate_protocol_ports(false),
95 quic_crypto_client_stream_factory(NULL) {
96 quic_supported_versions.push_back(QUIC_VERSION_18);
97 }
98
~Params()99 HttpNetworkSession::Params::~Params() {}
100
101 // TODO(mbelshe): Move the socket factories into HttpStreamFactory.
HttpNetworkSession(const Params & params)102 HttpNetworkSession::HttpNetworkSession(const Params& params)
103 : net_log_(params.net_log),
104 network_delegate_(params.network_delegate),
105 http_server_properties_(params.http_server_properties),
106 cert_verifier_(params.cert_verifier),
107 http_auth_handler_factory_(params.http_auth_handler_factory),
108 proxy_service_(params.proxy_service),
109 ssl_config_service_(params.ssl_config_service),
110 normal_socket_pool_manager_(
111 CreateSocketPoolManager(NORMAL_SOCKET_POOL, params)),
112 websocket_socket_pool_manager_(
113 CreateSocketPoolManager(WEBSOCKET_SOCKET_POOL, params)),
114 quic_stream_factory_(params.host_resolver,
115 params.client_socket_factory ?
116 params.client_socket_factory :
117 net::ClientSocketFactory::GetDefaultFactory(),
118 params.http_server_properties,
119 params.cert_verifier,
120 params.transport_security_state,
121 params.quic_crypto_client_stream_factory,
122 params.quic_random ? params.quic_random :
123 QuicRandom::GetInstance(),
124 params.quic_clock ? params. quic_clock :
125 new QuicClock(),
126 params.quic_max_packet_length,
127 params.quic_user_agent_id,
128 params.quic_supported_versions,
129 params.enable_quic_port_selection,
130 params.enable_quic_pacing,
131 params.enable_quic_time_based_loss_detection),
132 spdy_session_pool_(params.host_resolver,
133 params.ssl_config_service,
134 params.http_server_properties,
135 params.force_spdy_single_domain,
136 params.enable_spdy_compression,
137 params.enable_spdy_ping_based_connection_checking,
138 params.spdy_default_protocol,
139 params.spdy_stream_initial_recv_window_size,
140 params.spdy_initial_max_concurrent_streams,
141 params.spdy_max_concurrent_streams_limit,
142 params.time_func,
143 params.trusted_spdy_proxy),
144 http_stream_factory_(new HttpStreamFactoryImpl(this, false)),
145 http_stream_factory_for_websocket_(
146 new HttpStreamFactoryImpl(this, true)),
147 params_(params) {
148 DCHECK(proxy_service_);
149 DCHECK(ssl_config_service_.get());
150 CHECK(http_server_properties_);
151
152 for (int i = ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION;
153 i <= ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION; ++i) {
154 enabled_protocols_[i - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION] = false;
155 }
156
157 // TODO(rtenneti): bug 116575 - consider combining the NextProto and
158 // AlternateProtocol.
159 for (std::vector<NextProto>::const_iterator it = params_.next_protos.begin();
160 it != params_.next_protos.end(); ++it) {
161 NextProto proto = *it;
162
163 // Add the protocol to the TLS next protocol list, except for QUIC
164 // since it uses UDP.
165 if (proto != kProtoQUIC1SPDY3) {
166 next_protos_.push_back(SSLClientSocket::NextProtoToString(proto));
167 }
168
169 // Enable the corresponding alternate protocol, except for HTTP
170 // which has not corresponding alternative.
171 if (proto != kProtoHTTP11) {
172 AlternateProtocol alternate = AlternateProtocolFromNextProto(proto);
173 if (!IsAlternateProtocolValid(alternate)) {
174 NOTREACHED() << "Invalid next proto: " << proto;
175 continue;
176 }
177 enabled_protocols_[alternate - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION] =
178 true;
179 }
180 }
181
182 if (HpackHuffmanAggregator::UseAggregator()) {
183 huffman_aggregator_.reset(new HpackHuffmanAggregator());
184 }
185 }
186
~HttpNetworkSession()187 HttpNetworkSession::~HttpNetworkSession() {
188 STLDeleteElements(&response_drainers_);
189 spdy_session_pool_.CloseAllSessions();
190 }
191
AddResponseDrainer(HttpResponseBodyDrainer * drainer)192 void HttpNetworkSession::AddResponseDrainer(HttpResponseBodyDrainer* drainer) {
193 DCHECK(!ContainsKey(response_drainers_, drainer));
194 response_drainers_.insert(drainer);
195 }
196
RemoveResponseDrainer(HttpResponseBodyDrainer * drainer)197 void HttpNetworkSession::RemoveResponseDrainer(
198 HttpResponseBodyDrainer* drainer) {
199 DCHECK(ContainsKey(response_drainers_, drainer));
200 response_drainers_.erase(drainer);
201 }
202
GetTransportSocketPool(SocketPoolType pool_type)203 TransportClientSocketPool* HttpNetworkSession::GetTransportSocketPool(
204 SocketPoolType pool_type) {
205 return GetSocketPoolManager(pool_type)->GetTransportSocketPool();
206 }
207
GetSSLSocketPool(SocketPoolType pool_type)208 SSLClientSocketPool* HttpNetworkSession::GetSSLSocketPool(
209 SocketPoolType pool_type) {
210 return GetSocketPoolManager(pool_type)->GetSSLSocketPool();
211 }
212
GetSocketPoolForSOCKSProxy(SocketPoolType pool_type,const HostPortPair & socks_proxy)213 SOCKSClientSocketPool* HttpNetworkSession::GetSocketPoolForSOCKSProxy(
214 SocketPoolType pool_type,
215 const HostPortPair& socks_proxy) {
216 return GetSocketPoolManager(pool_type)->GetSocketPoolForSOCKSProxy(
217 socks_proxy);
218 }
219
GetSocketPoolForHTTPProxy(SocketPoolType pool_type,const HostPortPair & http_proxy)220 HttpProxyClientSocketPool* HttpNetworkSession::GetSocketPoolForHTTPProxy(
221 SocketPoolType pool_type,
222 const HostPortPair& http_proxy) {
223 return GetSocketPoolManager(pool_type)->GetSocketPoolForHTTPProxy(http_proxy);
224 }
225
GetSocketPoolForSSLWithProxy(SocketPoolType pool_type,const HostPortPair & proxy_server)226 SSLClientSocketPool* HttpNetworkSession::GetSocketPoolForSSLWithProxy(
227 SocketPoolType pool_type,
228 const HostPortPair& proxy_server) {
229 return GetSocketPoolManager(pool_type)->GetSocketPoolForSSLWithProxy(
230 proxy_server);
231 }
232
SocketPoolInfoToValue() const233 base::Value* HttpNetworkSession::SocketPoolInfoToValue() const {
234 // TODO(yutak): Should merge values from normal pools and WebSocket pools.
235 return normal_socket_pool_manager_->SocketPoolInfoToValue();
236 }
237
SpdySessionPoolInfoToValue() const238 base::Value* HttpNetworkSession::SpdySessionPoolInfoToValue() const {
239 return spdy_session_pool_.SpdySessionPoolInfoToValue();
240 }
241
QuicInfoToValue() const242 base::Value* HttpNetworkSession::QuicInfoToValue() const {
243 base::DictionaryValue* dict = new base::DictionaryValue();
244 dict->Set("sessions", quic_stream_factory_.QuicStreamFactoryInfoToValue());
245 dict->SetBoolean("quic_enabled", params_.enable_quic);
246 dict->SetBoolean("quic_enabled_https", params_.enable_quic_https);
247 dict->SetBoolean("enable_quic_port_selection",
248 params_.enable_quic_port_selection);
249 dict->SetBoolean("enable_quic_pacing",
250 params_.enable_quic_pacing);
251 dict->SetBoolean("enable_quic_time_based_loss_detection",
252 params_.enable_quic_time_based_loss_detection);
253 dict->SetBoolean("enable_quic_persist_server_info",
254 params_.enable_quic_persist_server_info);
255 dict->SetString("origin_to_force_quic_on",
256 params_.origin_to_force_quic_on.ToString());
257 return dict;
258 }
259
CloseAllConnections()260 void HttpNetworkSession::CloseAllConnections() {
261 normal_socket_pool_manager_->FlushSocketPoolsWithError(ERR_ABORTED);
262 websocket_socket_pool_manager_->FlushSocketPoolsWithError(ERR_ABORTED);
263 spdy_session_pool_.CloseCurrentSessions(ERR_ABORTED);
264 quic_stream_factory_.CloseAllSessions(ERR_ABORTED);
265 }
266
CloseIdleConnections()267 void HttpNetworkSession::CloseIdleConnections() {
268 normal_socket_pool_manager_->CloseIdleSockets();
269 websocket_socket_pool_manager_->CloseIdleSockets();
270 spdy_session_pool_.CloseCurrentIdleSessions();
271 }
272
IsProtocolEnabled(AlternateProtocol protocol) const273 bool HttpNetworkSession::IsProtocolEnabled(AlternateProtocol protocol) const {
274 DCHECK(IsAlternateProtocolValid(protocol));
275 return enabled_protocols_[
276 protocol - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION];
277 }
278
GetNextProtos(std::vector<std::string> * next_protos) const279 void HttpNetworkSession::GetNextProtos(
280 std::vector<std::string>* next_protos) const {
281 if (HttpStreamFactory::spdy_enabled()) {
282 *next_protos = next_protos_;
283 } else {
284 next_protos->clear();
285 }
286 }
287
HasSpdyExclusion(HostPortPair host_port_pair) const288 bool HttpNetworkSession::HasSpdyExclusion(
289 HostPortPair host_port_pair) const {
290 return params_.forced_spdy_exclusions.find(host_port_pair) !=
291 params_.forced_spdy_exclusions.end();
292 }
293
GetSocketPoolManager(SocketPoolType pool_type)294 ClientSocketPoolManager* HttpNetworkSession::GetSocketPoolManager(
295 SocketPoolType pool_type) {
296 switch (pool_type) {
297 case NORMAL_SOCKET_POOL:
298 return normal_socket_pool_manager_.get();
299 case WEBSOCKET_SOCKET_POOL:
300 return websocket_socket_pool_manager_.get();
301 default:
302 NOTREACHED();
303 break;
304 }
305 return NULL;
306 }
307
308 } // namespace net
309