net/socket/client_socket_pool_manager_impl.cc

   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/socket/client_socket_pool_manager_impl.h"
   6
   7 #include "base/logging.h"
   8 #include "base/values.h"
   9 #include "net/http/http_network_session.h"
  10 #include "net/http/http_proxy_client_socket_pool.h"
  11 #include "net/socket/socks_client_socket_pool.h"
  12 #include "net/socket/ssl_client_socket_pool.h"
  13 #include "net/socket/transport_client_socket_pool.h"
  14 #include "net/ssl/ssl_config_service.h"
  15
  16 namespace net {
  17
  18 namespace {
  19
  20 // Appends information about all |socket_pools| to the end of |list|.
  21 template <class MapType>
  22 void AddSocketPoolsToList(base::ListValue* list,
  23                           const MapType& socket_pools,
  24                           const std::string& type,
  25                           bool include_nested_pools) {
  26   for (typename MapType::const_iterator it = socket_pools.begin();
  27        it != socket_pools.end(); it++) {
  28     list->Append(it->second->GetInfoAsValue(it->first.ToString(),
  29                                             type,
  30                                             include_nested_pools));
  31   }
  32 }
  33
  34 }  // namespace
  35
  36 ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
  37     NetLog* net_log,
  38     ClientSocketFactory* socket_factory,
  39     HostResolver* host_resolver,
  40     CertVerifier* cert_verifier,
  41     ServerBoundCertService* server_bound_cert_service,
  42     TransportSecurityState* transport_security_state,
  43     CTVerifier* cert_transparency_verifier,
  44     const std::string& ssl_session_cache_shard,
  45     ProxyService* proxy_service,
  46     SSLConfigService* ssl_config_service,
  47     HttpNetworkSession::SocketPoolType pool_type)
  48     : net_log_(net_log),
  49       socket_factory_(socket_factory),
  50       host_resolver_(host_resolver),
  51       cert_verifier_(cert_verifier),
  52       server_bound_cert_service_(server_bound_cert_service),
  53       transport_security_state_(transport_security_state),
  54       cert_transparency_verifier_(cert_transparency_verifier),
  55       ssl_session_cache_shard_(ssl_session_cache_shard),
  56       proxy_service_(proxy_service),
  57       ssl_config_service_(ssl_config_service),
  58       pool_type_(pool_type),
  59       transport_pool_histograms_("TCP"),
  60       transport_socket_pool_(new TransportClientSocketPool(
  61           max_sockets_per_pool(pool_type), max_sockets_per_group(pool_type),
  62           &transport_pool_histograms_,
  63           host_resolver,
  64           socket_factory_,
  65           net_log)),
  66       ssl_pool_histograms_("SSL2"),
  67       ssl_socket_pool_(new SSLClientSocketPool(
  68           max_sockets_per_pool(pool_type), max_sockets_per_group(pool_type),
  69           &ssl_pool_histograms_,
  70           host_resolver,
  71           cert_verifier,
  72           server_bound_cert_service,
  73           transport_security_state,
  74           cert_transparency_verifier,
  75           ssl_session_cache_shard,
  76           socket_factory,
  77           transport_socket_pool_.get(),
  78           NULL /* no socks proxy */,
  79           NULL /* no http proxy */,
  80           ssl_config_service,
  81           net_log)),
  82       transport_for_socks_pool_histograms_("TCPforSOCKS"),
  83       socks_pool_histograms_("SOCK"),
  84       transport_for_http_proxy_pool_histograms_("TCPforHTTPProxy"),
  85       transport_for_https_proxy_pool_histograms_("TCPforHTTPSProxy"),
  86       ssl_for_https_proxy_pool_histograms_("SSLforHTTPSProxy"),
  87       http_proxy_pool_histograms_("HTTPProxy"),
  88       ssl_socket_pool_for_proxies_histograms_("SSLForProxies") {
  89   CertDatabase::GetInstance()->AddObserver(this);
  90 }
  91
  92 ClientSocketPoolManagerImpl::~ClientSocketPoolManagerImpl() {
  93   CertDatabase::GetInstance()->RemoveObserver(this);
  94 }
  95
  96 void ClientSocketPoolManagerImpl::FlushSocketPoolsWithError(int error) {
  97   // Flush the highest level pools first, since higher level pools may release
  98   // stuff to the lower level pools.
  99
 100   for (SSLSocketPoolMap::const_iterator it =
 101        ssl_socket_pools_for_proxies_.begin();
 102        it != ssl_socket_pools_for_proxies_.end();
 103        ++it)
 104     it->second->FlushWithError(error);
 105
 106   for (HTTPProxySocketPoolMap::const_iterator it =
 107        http_proxy_socket_pools_.begin();
 108        it != http_proxy_socket_pools_.end();
 109        ++it)
 110     it->second->FlushWithError(error);
 111
 112   for (SSLSocketPoolMap::const_iterator it =
 113        ssl_socket_pools_for_https_proxies_.begin();
 114        it != ssl_socket_pools_for_https_proxies_.end();
 115        ++it)
 116     it->second->FlushWithError(error);
 117
 118   for (TransportSocketPoolMap::const_iterator it =
 119        transport_socket_pools_for_https_proxies_.begin();
 120        it != transport_socket_pools_for_https_proxies_.end();
 121        ++it)
 122     it->second->FlushWithError(error);
 123
 124   for (TransportSocketPoolMap::const_iterator it =
 125        transport_socket_pools_for_http_proxies_.begin();
 126        it != transport_socket_pools_for_http_proxies_.end();
 127        ++it)
 128     it->second->FlushWithError(error);
 129
 130   for (SOCKSSocketPoolMap::const_iterator it =
 131        socks_socket_pools_.begin();
 132        it != socks_socket_pools_.end();
 133        ++it)
 134     it->second->FlushWithError(error);
 135
 136   for (TransportSocketPoolMap::const_iterator it =
 137        transport_socket_pools_for_socks_proxies_.begin();
 138        it != transport_socket_pools_for_socks_proxies_.end();
 139        ++it)
 140     it->second->FlushWithError(error);
 141
 142   ssl_socket_pool_->FlushWithError(error);
 143   transport_socket_pool_->FlushWithError(error);
 144 }
 145
 146 void ClientSocketPoolManagerImpl::CloseIdleSockets() {
 147   // Close sockets in the highest level pools first, since higher level pools'
 148   // sockets may release stuff to the lower level pools.
 149   for (SSLSocketPoolMap::const_iterator it =
 150        ssl_socket_pools_for_proxies_.begin();
 151        it != ssl_socket_pools_for_proxies_.end();
 152        ++it)
 153     it->second->CloseIdleSockets();
 154
 155   for (HTTPProxySocketPoolMap::const_iterator it =
 156        http_proxy_socket_pools_.begin();
 157        it != http_proxy_socket_pools_.end();
 158        ++it)
 159     it->second->CloseIdleSockets();
 160
 161   for (SSLSocketPoolMap::const_iterator it =
 162        ssl_socket_pools_for_https_proxies_.begin();
 163        it != ssl_socket_pools_for_https_proxies_.end();
 164        ++it)
 165     it->second->CloseIdleSockets();
 166
 167   for (TransportSocketPoolMap::const_iterator it =
 168        transport_socket_pools_for_https_proxies_.begin();
 169        it != transport_socket_pools_for_https_proxies_.end();
 170        ++it)
 171     it->second->CloseIdleSockets();
 172
 173   for (TransportSocketPoolMap::const_iterator it =
 174        transport_socket_pools_for_http_proxies_.begin();
 175        it != transport_socket_pools_for_http_proxies_.end();
 176        ++it)
 177     it->second->CloseIdleSockets();
 178
 179   for (SOCKSSocketPoolMap::const_iterator it =
 180        socks_socket_pools_.begin();
 181        it != socks_socket_pools_.end();
 182        ++it)
 183     it->second->CloseIdleSockets();
 184
 185   for (TransportSocketPoolMap::const_iterator it =
 186        transport_socket_pools_for_socks_proxies_.begin();
 187        it != transport_socket_pools_for_socks_proxies_.end();
 188        ++it)
 189     it->second->CloseIdleSockets();
 190
 191   ssl_socket_pool_->CloseIdleSockets();
 192   transport_socket_pool_->CloseIdleSockets();
 193 }
 194
 195 TransportClientSocketPool*
 196 ClientSocketPoolManagerImpl::GetTransportSocketPool() {
 197   return transport_socket_pool_.get();
 198 }
 199
 200 SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSSLSocketPool() {
 201   return ssl_socket_pool_.get();
 202 }
 203
 204 SOCKSClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSOCKSProxy(
 205     const HostPortPair& socks_proxy) {
 206   SOCKSSocketPoolMap::const_iterator it = socks_socket_pools_.find(socks_proxy);
 207   if (it != socks_socket_pools_.end()) {
 208     DCHECK(ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
 209     return it->second;
 210   }
 211
 212   DCHECK(!ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
 213
 214   std::pair<TransportSocketPoolMap::iterator, bool> tcp_ret =
 215       transport_socket_pools_for_socks_proxies_.insert(
 216           std::make_pair(
 217               socks_proxy,
 218               new TransportClientSocketPool(
 219                   max_sockets_per_proxy_server(pool_type_),
 220                   max_sockets_per_group(pool_type_),
 221                   &transport_for_socks_pool_histograms_,
 222                   host_resolver_,
 223                   socket_factory_,
 224                   net_log_)));
 225   DCHECK(tcp_ret.second);
 226
 227   std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
 228       socks_socket_pools_.insert(
 229           std::make_pair(socks_proxy, new SOCKSClientSocketPool(
 230               max_sockets_per_proxy_server(pool_type_),
 231               max_sockets_per_group(pool_type_),
 232               &socks_pool_histograms_,
 233               host_resolver_,
 234               tcp_ret.first->second,
 235               net_log_)));
 236
 237   return ret.first->second;
 238 }
 239
 240 HttpProxyClientSocketPool*
 241 ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
 242     const HostPortPair& http_proxy) {
 243   HTTPProxySocketPoolMap::const_iterator it =
 244       http_proxy_socket_pools_.find(http_proxy);
 245   if (it != http_proxy_socket_pools_.end()) {
 246     DCHECK(ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
 247     DCHECK(ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
 248     DCHECK(ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
 249     return it->second;
 250   }
 251
 252   DCHECK(!ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
 253   DCHECK(!ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
 254   DCHECK(!ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
 255
 256   std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
 257       transport_socket_pools_for_http_proxies_.insert(
 258           std::make_pair(
 259               http_proxy,
 260               new TransportClientSocketPool(
 261                   max_sockets_per_proxy_server(pool_type_),
 262                   max_sockets_per_group(pool_type_),
 263                   &transport_for_http_proxy_pool_histograms_,
 264                   host_resolver_,
 265                   socket_factory_,
 266                   net_log_)));
 267   DCHECK(tcp_http_ret.second);
 268
 269   std::pair<TransportSocketPoolMap::iterator, bool> tcp_https_ret =
 270       transport_socket_pools_for_https_proxies_.insert(
 271           std::make_pair(
 272               http_proxy,
 273               new TransportClientSocketPool(
 274                   max_sockets_per_proxy_server(pool_type_),
 275                   max_sockets_per_group(pool_type_),
 276                   &transport_for_https_proxy_pool_histograms_,
 277                   host_resolver_,
 278                   socket_factory_,
 279                   net_log_)));
 280   DCHECK(tcp_https_ret.second);
 281
 282   std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =
 283       ssl_socket_pools_for_https_proxies_.insert(std::make_pair(
 284           http_proxy,
 285           new SSLClientSocketPool(max_sockets_per_proxy_server(pool_type_),
 286                                   max_sockets_per_group(pool_type_),
 287                                   &ssl_for_https_proxy_pool_histograms_,
 288                                   host_resolver_,
 289                                   cert_verifier_,
 290                                   server_bound_cert_service_,
 291                                   transport_security_state_,
 292                                   cert_transparency_verifier_,
 293                                   ssl_session_cache_shard_,
 294                                   socket_factory_,
 295                                   tcp_https_ret.first->second /* https proxy */,
 296                                   NULL /* no socks proxy */,
 297                                   NULL /* no http proxy */,
 298                                   ssl_config_service_.get(),
 299                                   net_log_)));
 300   DCHECK(tcp_https_ret.second);
 301
 302   std::pair<HTTPProxySocketPoolMap::iterator, bool> ret =
 303       http_proxy_socket_pools_.insert(
 304           std::make_pair(
 305               http_proxy,
 306               new HttpProxyClientSocketPool(
 307                   max_sockets_per_proxy_server(pool_type_),
 308                   max_sockets_per_group(pool_type_),
 309                   &http_proxy_pool_histograms_,
 310                   host_resolver_,
 311                   tcp_http_ret.first->second,
 312                   ssl_https_ret.first->second,
 313                   net_log_)));
 314
 315   return ret.first->second;
 316 }
 317
 318 SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSSLWithProxy(
 319     const HostPortPair& proxy_server) {
 320   SSLSocketPoolMap::const_iterator it =
 321       ssl_socket_pools_for_proxies_.find(proxy_server);
 322   if (it != ssl_socket_pools_for_proxies_.end())
 323     return it->second;
 324
 325   SSLClientSocketPool* new_pool = new SSLClientSocketPool(
 326       max_sockets_per_proxy_server(pool_type_),
 327       max_sockets_per_group(pool_type_),
 328       &ssl_pool_histograms_,
 329       host_resolver_,
 330       cert_verifier_,
 331       server_bound_cert_service_,
 332       transport_security_state_,
 333       cert_transparency_verifier_,
 334       ssl_session_cache_shard_,
 335       socket_factory_,
 336       NULL, /* no tcp pool, we always go through a proxy */
 337       GetSocketPoolForSOCKSProxy(proxy_server),
 338       GetSocketPoolForHTTPProxy(proxy_server),
 339       ssl_config_service_.get(),
 340       net_log_);
 341
 342   std::pair<SSLSocketPoolMap::iterator, bool> ret =
 343       ssl_socket_pools_for_proxies_.insert(std::make_pair(proxy_server,
 344                                                           new_pool));
 345
 346   return ret.first->second;
 347 }
 348
 349 base::Value* ClientSocketPoolManagerImpl::SocketPoolInfoToValue() const {
 350   base::ListValue* list = new base::ListValue();
 351   list->Append(transport_socket_pool_->GetInfoAsValue("transport_socket_pool",
 352                                                 "transport_socket_pool",
 353                                                 false));
 354   // Third parameter is false because |ssl_socket_pool_| uses
 355   // |transport_socket_pool_| internally, and do not want to add it a second
 356   // time.
 357   list->Append(ssl_socket_pool_->GetInfoAsValue("ssl_socket_pool",
 358                                                 "ssl_socket_pool",
 359                                                 false));
 360   AddSocketPoolsToList(list,
 361                        http_proxy_socket_pools_,
 362                        "http_proxy_socket_pool",
 363                        true);
 364   AddSocketPoolsToList(list,
 365                        socks_socket_pools_,
 366                        "socks_socket_pool",
 367                        true);
 368
 369   // Third parameter is false because |ssl_socket_pools_for_proxies_| use
 370   // socket pools in |http_proxy_socket_pools_| and |socks_socket_pools_|.
 371   AddSocketPoolsToList(list,
 372                        ssl_socket_pools_for_proxies_,
 373                        "ssl_socket_pool_for_proxies",
 374                        false);
 375   return list;
 376 }
 377
 378 void ClientSocketPoolManagerImpl::OnCertAdded(const X509Certificate* cert) {
 379   FlushSocketPoolsWithError(ERR_NETWORK_CHANGED);
 380 }
 381
 382 void ClientSocketPoolManagerImpl::OnCACertChanged(
 383     const X509Certificate* cert) {
 384   // We should flush the socket pools if we removed trust from a
 385   // cert, because a previously trusted server may have become
 386   // untrusted.
 387   //
 388   // We should not flush the socket pools if we added trust to a
 389   // cert.
 390   //
 391   // Since the OnCACertChanged method doesn't tell us what
 392   // kind of change it is, we have to flush the socket
 393   // pools to be safe.
 394   FlushSocketPoolsWithError(ERR_NETWORK_CHANGED);
 395 }
 396
 397 }  // namespace net