spdy_session_pool.cc revision e5d81f57cb97b3b6b7fccc9c5610d21eb81db09d 
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/spdy/spdy_session_pool.h"
6
7#include "base/logging.h"
8#include "base/metrics/histogram.h"
9#include "base/values.h"
10#include "net/base/address_list.h"
11#include "net/http/http_network_session.h"
12#include "net/http/http_server_properties.h"
13#include "net/spdy/spdy_session.h"
14
15
16namespace net {
17
18namespace {
19
20enum SpdySessionGetTypes {
21  CREATED_NEW                 = 0,
22  FOUND_EXISTING              = 1,
23  FOUND_EXISTING_FROM_IP_POOL = 2,
24  IMPORTED_FROM_SOCKET        = 3,
25  SPDY_SESSION_GET_MAX        = 4
26};
27
28}  // namespace
29
30SpdySessionPool::SpdySessionPool(
31    HostResolver* resolver,
32    SSLConfigService* ssl_config_service,
33    const base::WeakPtr<HttpServerProperties>& http_server_properties,
34    bool force_single_domain,
35    bool enable_compression,
36    bool enable_ping_based_connection_checking,
37    NextProto default_protocol,
38    size_t stream_initial_recv_window_size,
39    size_t initial_max_concurrent_streams,
40    size_t max_concurrent_streams_limit,
41    SpdySessionPool::TimeFunc time_func,
42    const std::string& trusted_spdy_proxy)
43    : http_server_properties_(http_server_properties),
44      ssl_config_service_(ssl_config_service),
45      resolver_(resolver),
46      verify_domain_authentication_(true),
47      enable_sending_initial_data_(true),
48      force_single_domain_(force_single_domain),
49      enable_compression_(enable_compression),
50      enable_ping_based_connection_checking_(
51          enable_ping_based_connection_checking),
52      // TODO(akalin): Force callers to have a valid value of
53      // |default_protocol_|.
54      default_protocol_(
55          (default_protocol == kProtoUnknown) ?
56          kProtoSPDY3 : default_protocol),
57      stream_initial_recv_window_size_(stream_initial_recv_window_size),
58      initial_max_concurrent_streams_(initial_max_concurrent_streams),
59      max_concurrent_streams_limit_(max_concurrent_streams_limit),
60      time_func_(time_func),
61      trusted_spdy_proxy_(
62          HostPortPair::FromString(trusted_spdy_proxy)) {
63  DCHECK(default_protocol_ >= kProtoSPDYMinimumVersion &&
64         default_protocol_ <= kProtoSPDYMaximumVersion);
65  NetworkChangeNotifier::AddIPAddressObserver(this);
66  if (ssl_config_service_.get())
67    ssl_config_service_->AddObserver(this);
68  CertDatabase::GetInstance()->AddObserver(this);
69}
70
71SpdySessionPool::~SpdySessionPool() {
72  CloseAllSessions();
73
74  if (ssl_config_service_.get())
75    ssl_config_service_->RemoveObserver(this);
76  NetworkChangeNotifier::RemoveIPAddressObserver(this);
77  CertDatabase::GetInstance()->RemoveObserver(this);
78}
79
80base::WeakPtr<SpdySession> SpdySessionPool::CreateAvailableSessionFromSocket(
81    const SpdySessionKey& key,
82    scoped_ptr<ClientSocketHandle> connection,
83    const BoundNetLog& net_log,
84    int certificate_error_code,
85    bool is_secure) {
86  DCHECK_GE(default_protocol_, kProtoSPDYMinimumVersion);
87  DCHECK_LE(default_protocol_, kProtoSPDYMaximumVersion);
88
89  UMA_HISTOGRAM_ENUMERATION(
90      "Net.SpdySessionGet", IMPORTED_FROM_SOCKET, SPDY_SESSION_GET_MAX);
91
92  scoped_ptr<SpdySession> new_session(
93      new SpdySession(key,
94                      http_server_properties_,
95                      verify_domain_authentication_,
96                      enable_sending_initial_data_,
97                      enable_compression_,
98                      enable_ping_based_connection_checking_,
99                      default_protocol_,
100                      stream_initial_recv_window_size_,
101                      initial_max_concurrent_streams_,
102                      max_concurrent_streams_limit_,
103                      time_func_,
104                      trusted_spdy_proxy_,
105                      net_log.net_log()));
106
107  new_session->InitializeWithSocket(
108      connection.Pass(), this, is_secure, certificate_error_code);
109
110  base::WeakPtr<SpdySession> available_session = new_session->GetWeakPtr();
111  sessions_.insert(new_session.release());
112  MapKeyToAvailableSession(key, available_session);
113
114  net_log.AddEvent(
115      NetLog::TYPE_SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
116      available_session->net_log().source().ToEventParametersCallback());
117
118  // Look up the IP address for this session so that we can match
119  // future sessions (potentially to different domains) which can
120  // potentially be pooled with this one. Because GetPeerAddress()
121  // reports the proxy's address instead of the origin server, check
122  // to see if this is a direct connection.
123  if (key.proxy_server().is_direct()) {
124    IPEndPoint address;
125    if (available_session->GetPeerAddress(&address) == OK)
126      aliases_[address] = key;
127  }
128
129  return available_session;
130}
131
132base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
133    const SpdySessionKey& key,
134    const BoundNetLog& net_log) {
135  AvailableSessionMap::iterator it = LookupAvailableSessionByKey(key);
136  if (it != available_sessions_.end()) {
137    UMA_HISTOGRAM_ENUMERATION(
138        "Net.SpdySessionGet", FOUND_EXISTING, SPDY_SESSION_GET_MAX);
139    net_log.AddEvent(
140        NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION,
141        it->second->net_log().source().ToEventParametersCallback());
142    return it->second;
143  }
144
145  // Look up the key's from the resolver's cache.
146  net::HostResolver::RequestInfo resolve_info(key.host_port_pair());
147  AddressList addresses;
148  int rv = resolver_->ResolveFromCache(resolve_info, &addresses, net_log);
149  DCHECK_NE(rv, ERR_IO_PENDING);
150  if (rv != OK)
151    return base::WeakPtr<SpdySession>();
152
153  // Check if we have a session through a domain alias.
154  for (AddressList::const_iterator address_it = addresses.begin();
155       address_it != addresses.end();
156       ++address_it) {
157    AliasMap::const_iterator alias_it = aliases_.find(*address_it);
158    if (alias_it == aliases_.end())
159      continue;
160
161    // We found an alias.
162    const SpdySessionKey& alias_key = alias_it->second;
163
164    // We can reuse this session only if the proxy and privacy
165    // settings match.
166    if (!(alias_key.proxy_server() == key.proxy_server()) ||
167        !(alias_key.privacy_mode() == key.privacy_mode()))
168      continue;
169
170    AvailableSessionMap::iterator available_session_it =
171        LookupAvailableSessionByKey(alias_key);
172    if (available_session_it == available_sessions_.end()) {
173      NOTREACHED();  // It shouldn't be in the aliases table if we can't get it!
174      continue;
175    }
176
177    const base::WeakPtr<SpdySession>& available_session =
178        available_session_it->second;
179    DCHECK(ContainsKey(sessions_, available_session.get()));
180    // If the session is a secure one, we need to verify that the
181    // server is authenticated to serve traffic for |host_port_proxy_pair| too.
182    if (!available_session->VerifyDomainAuthentication(
183            key.host_port_pair().host())) {
184      UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 0, 2);
185      continue;
186    }
187
188    UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 1, 2);
189    UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
190                              FOUND_EXISTING_FROM_IP_POOL,
191                              SPDY_SESSION_GET_MAX);
192    net_log.AddEvent(
193        NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
194        available_session->net_log().source().ToEventParametersCallback());
195    // Add this session to the map so that we can find it next time.
196    MapKeyToAvailableSession(key, available_session);
197    available_session->AddPooledAlias(key);
198    return available_session;
199  }
200
201  return base::WeakPtr<SpdySession>();
202}
203
204void SpdySessionPool::MakeSessionUnavailable(
205    const base::WeakPtr<SpdySession>& available_session) {
206  UnmapKey(available_session->spdy_session_key());
207  RemoveAliases(available_session->spdy_session_key());
208  const std::set<SpdySessionKey>& aliases = available_session->pooled_aliases();
209  for (std::set<SpdySessionKey>::const_iterator it = aliases.begin();
210       it != aliases.end(); ++it) {
211    UnmapKey(*it);
212    RemoveAliases(*it);
213  }
214  DCHECK(!IsSessionAvailable(available_session));
215}
216
217void SpdySessionPool::RemoveUnavailableSession(
218    const base::WeakPtr<SpdySession>& unavailable_session) {
219  DCHECK(!IsSessionAvailable(unavailable_session));
220
221  unavailable_session->net_log().AddEvent(
222      NetLog::TYPE_SPDY_SESSION_POOL_REMOVE_SESSION,
223      unavailable_session->net_log().source().ToEventParametersCallback());
224
225  SessionSet::iterator it = sessions_.find(unavailable_session.get());
226  CHECK(it != sessions_.end());
227  scoped_ptr<SpdySession> owned_session(*it);
228  sessions_.erase(it);
229}
230
231// Make a copy of |sessions_| in the Close* functions below to avoid
232// reentrancy problems. Since arbitrary functions get called by close
233// handlers, it doesn't suffice to simply increment the iterator
234// before closing.
235
236void SpdySessionPool::CloseCurrentSessions(net::Error error) {
237  CloseCurrentSessionsHelper(error, "Closing current sessions.",
238                             false /* idle_only */);
239}
240
241void SpdySessionPool::CloseCurrentIdleSessions() {
242  CloseCurrentSessionsHelper(ERR_ABORTED, "Closing idle sessions.",
243                             true /* idle_only */);
244}
245
246void SpdySessionPool::CloseAllSessions() {
247  while (!sessions_.empty()) {
248    CloseCurrentSessionsHelper(ERR_ABORTED, "Closing all sessions.",
249                               false /* idle_only */);
250  }
251}
252
253base::Value* SpdySessionPool::SpdySessionPoolInfoToValue() const {
254  base::ListValue* list = new base::ListValue();
255
256  for (AvailableSessionMap::const_iterator it = available_sessions_.begin();
257       it != available_sessions_.end(); ++it) {
258    // Only add the session if the key in the map matches the main
259    // host_port_proxy_pair (not an alias).
260    const SpdySessionKey& key = it->first;
261    const SpdySessionKey& session_key = it->second->spdy_session_key();
262    if (key.Equals(session_key))
263      list->Append(it->second->GetInfoAsValue());
264  }
265  return list;
266}
267
268void SpdySessionPool::OnIPAddressChanged() {
269  WeakSessionList current_sessions = GetCurrentSessions();
270  for (WeakSessionList::const_iterator it = current_sessions.begin();
271       it != current_sessions.end(); ++it) {
272    if (!*it)
273      continue;
274
275    // For OSs that terminate TCP connections upon relevant network changes
276    // there is no need to explicitly close SpdySessions, instead simply mark
277    // the sessions as deprecated so they aren't reused.
278#if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
279    (*it)->MakeUnavailable();
280#else
281    (*it)->CloseSessionOnError(ERR_NETWORK_CHANGED,
282                               "Closing current sessions.");
283    DCHECK(!*it);
284#endif  // defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
285    DCHECK(!IsSessionAvailable(*it));
286  }
287  http_server_properties_->ClearAllSpdySettings();
288}
289
290void SpdySessionPool::OnSSLConfigChanged() {
291  CloseCurrentSessions(ERR_NETWORK_CHANGED);
292}
293
294void SpdySessionPool::OnCertAdded(const X509Certificate* cert) {
295  CloseCurrentSessions(ERR_CERT_DATABASE_CHANGED);
296}
297
298void SpdySessionPool::OnCACertChanged(const X509Certificate* cert) {
299  // Per wtc, we actually only need to CloseCurrentSessions when trust is
300  // reduced. CloseCurrentSessions now because OnCACertChanged does not
301  // tell us this.
302  // See comments in ClientSocketPoolManager::OnCACertChanged.
303  CloseCurrentSessions(ERR_CERT_DATABASE_CHANGED);
304}
305
306bool SpdySessionPool::IsSessionAvailable(
307    const base::WeakPtr<SpdySession>& session) const {
308  for (AvailableSessionMap::const_iterator it = available_sessions_.begin();
309       it != available_sessions_.end(); ++it) {
310    if (it->second.get() == session.get())
311      return true;
312  }
313  return false;
314}
315
316const SpdySessionKey& SpdySessionPool::NormalizeListKey(
317    const SpdySessionKey& key) const {
318  if (!force_single_domain_)
319    return key;
320
321  static SpdySessionKey* single_domain_key = NULL;
322  if (!single_domain_key) {
323    HostPortPair single_domain = HostPortPair("singledomain.com", 80);
324    single_domain_key = new SpdySessionKey(single_domain,
325                                           ProxyServer::Direct(),
326                                           PRIVACY_MODE_DISABLED);
327  }
328  return *single_domain_key;
329}
330
331void SpdySessionPool::MapKeyToAvailableSession(
332    const SpdySessionKey& key,
333    const base::WeakPtr<SpdySession>& session) {
334  DCHECK(ContainsKey(sessions_, session.get()));
335  const SpdySessionKey& normalized_key = NormalizeListKey(key);
336  std::pair<AvailableSessionMap::iterator, bool> result =
337      available_sessions_.insert(std::make_pair(normalized_key, session));
338  CHECK(result.second);
339}
340
341SpdySessionPool::AvailableSessionMap::iterator
342SpdySessionPool::LookupAvailableSessionByKey(
343    const SpdySessionKey& key) {
344  const SpdySessionKey& normalized_key = NormalizeListKey(key);
345  return available_sessions_.find(normalized_key);
346}
347
348void SpdySessionPool::UnmapKey(const SpdySessionKey& key) {
349  AvailableSessionMap::iterator it = LookupAvailableSessionByKey(key);
350  CHECK(it != available_sessions_.end());
351  available_sessions_.erase(it);
352}
353
354void SpdySessionPool::RemoveAliases(const SpdySessionKey& key) {
355  // Walk the aliases map, find references to this pair.
356  // TODO(mbelshe):  Figure out if this is too expensive.
357  for (AliasMap::iterator it = aliases_.begin(); it != aliases_.end(); ) {
358    if (it->second.Equals(key)) {
359      AliasMap::iterator old_it = it;
360      ++it;
361      aliases_.erase(old_it);
362    } else {
363      ++it;
364    }
365  }
366}
367
368SpdySessionPool::WeakSessionList SpdySessionPool::GetCurrentSessions() const {
369  WeakSessionList current_sessions;
370  for (SessionSet::const_iterator it = sessions_.begin();
371       it != sessions_.end(); ++it) {
372    current_sessions.push_back((*it)->GetWeakPtr());
373  }
374  return current_sessions;
375}
376
377void SpdySessionPool::CloseCurrentSessionsHelper(
378    Error error,
379    const std::string& description,
380    bool idle_only) {
381  WeakSessionList current_sessions = GetCurrentSessions();
382  for (WeakSessionList::const_iterator it = current_sessions.begin();
383       it != current_sessions.end(); ++it) {
384    if (!*it)
385      continue;
386
387    if (idle_only && (*it)->is_active())
388      continue;
389
390    (*it)->CloseSessionOnError(error, description);
391    DCHECK(!IsSessionAvailable(*it));
392    DCHECK(!*it);
393  }
394}
395
396}  // namespace net
397