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