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