Home | History | Annotate | Download | only in socket 
      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/transport_client_socket_pool.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/compiler_specific.h"
     10 #include "base/lazy_instance.h"
     11 #include "base/logging.h"
     12 #include "base/message_loop/message_loop.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/strings/string_util.h"
     15 #include "base/synchronization/lock.h"
     16 #include "base/time/time.h"
     17 #include "base/values.h"
     18 #include "net/base/ip_endpoint.h"
     19 #include "net/base/net_errors.h"
     20 #include "net/base/net_log.h"
     21 #include "net/socket/client_socket_factory.h"
     22 #include "net/socket/client_socket_handle.h"
     23 #include "net/socket/client_socket_pool_base.h"
     24 #include "net/socket/socket_net_log_params.h"
     25 #include "net/socket/tcp_client_socket.h"
     26 
     27 using base::TimeDelta;
     28 
     29 namespace net {
     30 
     31 // TODO(willchan): Base this off RTT instead of statically setting it. Note we
     32 // choose a timeout that is different from the backup connect job timer so they
     33 // don't synchronize.
     34 const int TransportConnectJob::kIPv6FallbackTimerInMs = 300;
     35 
     36 namespace {
     37 
     38 // Returns true iff all addresses in |list| are in the IPv6 family.
     39 bool AddressListOnlyContainsIPv6(const AddressList& list) {
     40   DCHECK(!list.empty());
     41   for (AddressList::const_iterator iter = list.begin(); iter != list.end();
     42        ++iter) {
     43     if (iter->GetFamily() != ADDRESS_FAMILY_IPV6)
     44       return false;
     45   }
     46   return true;
     47 }
     48 
     49 }  // namespace
     50 
     51 // This lock protects |g_last_connect_time|.
     52 static base::LazyInstance<base::Lock>::Leaky
     53     g_last_connect_time_lock = LAZY_INSTANCE_INITIALIZER;
     54 
     55 // |g_last_connect_time| has the last time a connect() call is made.
     56 static base::LazyInstance<base::TimeTicks>::Leaky
     57     g_last_connect_time = LAZY_INSTANCE_INITIALIZER;
     58 
     59 TransportSocketParams::TransportSocketParams(
     60     const HostPortPair& host_port_pair,
     61     bool disable_resolver_cache,
     62     bool ignore_limits,
     63     const OnHostResolutionCallback& host_resolution_callback)
     64     : destination_(host_port_pair),
     65       ignore_limits_(ignore_limits),
     66       host_resolution_callback_(host_resolution_callback) {
     67   if (disable_resolver_cache)
     68     destination_.set_allow_cached_response(false);
     69 }
     70 
     71 TransportSocketParams::~TransportSocketParams() {}
     72 
     73 // TransportConnectJobs will time out after this many seconds.  Note this is
     74 // the total time, including both host resolution and TCP connect() times.
     75 //
     76 // TODO(eroman): The use of this constant needs to be re-evaluated. The time
     77 // needed for TCPClientSocketXXX::Connect() can be arbitrarily long, since
     78 // the address list may contain many alternatives, and most of those may
     79 // timeout. Even worse, the per-connect timeout threshold varies greatly
     80 // between systems (anywhere from 20 seconds to 190 seconds).
     81 // See comment #12 at http://crbug.com/23364 for specifics.
     82 static const int kTransportConnectJobTimeoutInSeconds = 240;  // 4 minutes.
     83 
     84 TransportConnectJob::TransportConnectJob(
     85     const std::string& group_name,
     86     RequestPriority priority,
     87     const scoped_refptr<TransportSocketParams>& params,
     88     base::TimeDelta timeout_duration,
     89     ClientSocketFactory* client_socket_factory,
     90     HostResolver* host_resolver,
     91     Delegate* delegate,
     92     NetLog* net_log)
     93     : ConnectJob(group_name, timeout_duration, priority, delegate,
     94                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
     95       params_(params),
     96       client_socket_factory_(client_socket_factory),
     97       resolver_(host_resolver),
     98       next_state_(STATE_NONE),
     99       interval_between_connects_(CONNECT_INTERVAL_GT_20MS) {
    100 }
    101 
    102 TransportConnectJob::~TransportConnectJob() {
    103   // We don't worry about cancelling the host resolution and TCP connect, since
    104   // ~SingleRequestHostResolver and ~StreamSocket will take care of it.
    105 }
    106 
    107 LoadState TransportConnectJob::GetLoadState() const {
    108   switch (next_state_) {
    109     case STATE_RESOLVE_HOST:
    110     case STATE_RESOLVE_HOST_COMPLETE:
    111       return LOAD_STATE_RESOLVING_HOST;
    112     case STATE_TRANSPORT_CONNECT:
    113     case STATE_TRANSPORT_CONNECT_COMPLETE:
    114       return LOAD_STATE_CONNECTING;
    115     case STATE_NONE:
    116       return LOAD_STATE_IDLE;
    117   }
    118   NOTREACHED();
    119   return LOAD_STATE_IDLE;
    120 }
    121 
    122 // static
    123 void TransportConnectJob::MakeAddressListStartWithIPv4(AddressList* list) {
    124   for (AddressList::iterator i = list->begin(); i != list->end(); ++i) {
    125     if (i->GetFamily() == ADDRESS_FAMILY_IPV4) {
    126       std::rotate(list->begin(), i, list->end());
    127       break;
    128     }
    129   }
    130 }
    131 
    132 void TransportConnectJob::OnIOComplete(int result) {
    133   int rv = DoLoop(result);
    134   if (rv != ERR_IO_PENDING)
    135     NotifyDelegateOfCompletion(rv);  // Deletes |this|
    136 }
    137 
    138 int TransportConnectJob::DoLoop(int result) {
    139   DCHECK_NE(next_state_, STATE_NONE);
    140 
    141   int rv = result;
    142   do {
    143     State state = next_state_;
    144     next_state_ = STATE_NONE;
    145     switch (state) {
    146       case STATE_RESOLVE_HOST:
    147         DCHECK_EQ(OK, rv);
    148         rv = DoResolveHost();
    149         break;
    150       case STATE_RESOLVE_HOST_COMPLETE:
    151         rv = DoResolveHostComplete(rv);
    152         break;
    153       case STATE_TRANSPORT_CONNECT:
    154         DCHECK_EQ(OK, rv);
    155         rv = DoTransportConnect();
    156         break;
    157       case STATE_TRANSPORT_CONNECT_COMPLETE:
    158         rv = DoTransportConnectComplete(rv);
    159         break;
    160       default:
    161         NOTREACHED();
    162         rv = ERR_FAILED;
    163         break;
    164     }
    165   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
    166 
    167   return rv;
    168 }
    169 
    170 int TransportConnectJob::DoResolveHost() {
    171   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
    172   connect_timing_.dns_start = base::TimeTicks::Now();
    173 
    174   return resolver_.Resolve(
    175       params_->destination(),
    176       priority(),
    177       &addresses_,
    178       base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)),
    179       net_log());
    180 }
    181 
    182 int TransportConnectJob::DoResolveHostComplete(int result) {
    183   connect_timing_.dns_end = base::TimeTicks::Now();
    184   // Overwrite connection start time, since for connections that do not go
    185   // through proxies, |connect_start| should not include dns lookup time.
    186   connect_timing_.connect_start = connect_timing_.dns_end;
    187 
    188   if (result == OK) {
    189     // Invoke callback, and abort if it fails.
    190     if (!params_->host_resolution_callback().is_null())
    191       result = params_->host_resolution_callback().Run(addresses_, net_log());
    192 
    193     if (result == OK)
    194       next_state_ = STATE_TRANSPORT_CONNECT;
    195   }
    196   return result;
    197 }
    198 
    199 int TransportConnectJob::DoTransportConnect() {
    200   base::TimeTicks now = base::TimeTicks::Now();
    201   base::TimeTicks last_connect_time;
    202   {
    203     base::AutoLock lock(g_last_connect_time_lock.Get());
    204     last_connect_time = g_last_connect_time.Get();
    205     *g_last_connect_time.Pointer() = now;
    206   }
    207   if (last_connect_time.is_null()) {
    208     interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
    209   } else {
    210     int64 interval = (now - last_connect_time).InMilliseconds();
    211     if (interval <= 10)
    212       interval_between_connects_ = CONNECT_INTERVAL_LE_10MS;
    213     else if (interval <= 20)
    214       interval_between_connects_ = CONNECT_INTERVAL_LE_20MS;
    215     else
    216       interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
    217   }
    218 
    219   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
    220   transport_socket_ = client_socket_factory_->CreateTransportClientSocket(
    221         addresses_, net_log().net_log(), net_log().source());
    222   int rv = transport_socket_->Connect(
    223       base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)));
    224   if (rv == ERR_IO_PENDING &&
    225       addresses_.front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
    226       !AddressListOnlyContainsIPv6(addresses_)) {
    227     fallback_timer_.Start(FROM_HERE,
    228         base::TimeDelta::FromMilliseconds(kIPv6FallbackTimerInMs),
    229         this, &TransportConnectJob::DoIPv6FallbackTransportConnect);
    230   }
    231   return rv;
    232 }
    233 
    234 int TransportConnectJob::DoTransportConnectComplete(int result) {
    235   if (result == OK) {
    236     bool is_ipv4 = addresses_.front().GetFamily() == ADDRESS_FAMILY_IPV4;
    237     DCHECK(!connect_timing_.connect_start.is_null());
    238     DCHECK(!connect_timing_.dns_start.is_null());
    239     base::TimeTicks now = base::TimeTicks::Now();
    240     base::TimeDelta total_duration = now - connect_timing_.dns_start;
    241     UMA_HISTOGRAM_CUSTOM_TIMES(
    242         "Net.DNS_Resolution_And_TCP_Connection_Latency2",
    243         total_duration,
    244         base::TimeDelta::FromMilliseconds(1),
    245         base::TimeDelta::FromMinutes(10),
    246         100);
    247 
    248     base::TimeDelta connect_duration = now - connect_timing_.connect_start;
    249     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
    250         connect_duration,
    251         base::TimeDelta::FromMilliseconds(1),
    252         base::TimeDelta::FromMinutes(10),
    253         100);
    254 
    255     switch (interval_between_connects_) {
    256       case CONNECT_INTERVAL_LE_10MS:
    257         UMA_HISTOGRAM_CUSTOM_TIMES(
    258             "Net.TCP_Connection_Latency_Interval_LessThanOrEqual_10ms",
    259             connect_duration,
    260             base::TimeDelta::FromMilliseconds(1),
    261             base::TimeDelta::FromMinutes(10),
    262             100);
    263         break;
    264       case CONNECT_INTERVAL_LE_20MS:
    265         UMA_HISTOGRAM_CUSTOM_TIMES(
    266             "Net.TCP_Connection_Latency_Interval_LessThanOrEqual_20ms",
    267             connect_duration,
    268             base::TimeDelta::FromMilliseconds(1),
    269             base::TimeDelta::FromMinutes(10),
    270             100);
    271         break;
    272       case CONNECT_INTERVAL_GT_20MS:
    273         UMA_HISTOGRAM_CUSTOM_TIMES(
    274             "Net.TCP_Connection_Latency_Interval_GreaterThan_20ms",
    275             connect_duration,
    276             base::TimeDelta::FromMilliseconds(1),
    277             base::TimeDelta::FromMinutes(10),
    278             100);
    279         break;
    280       default:
    281         NOTREACHED();
    282         break;
    283     }
    284 
    285     if (is_ipv4) {
    286       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_No_Race",
    287                                  connect_duration,
    288                                  base::TimeDelta::FromMilliseconds(1),
    289                                  base::TimeDelta::FromMinutes(10),
    290                                  100);
    291     } else {
    292       if (AddressListOnlyContainsIPv6(addresses_)) {
    293         UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Solo",
    294                                    connect_duration,
    295                                    base::TimeDelta::FromMilliseconds(1),
    296                                    base::TimeDelta::FromMinutes(10),
    297                                    100);
    298       } else {
    299         UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Raceable",
    300                                    connect_duration,
    301                                    base::TimeDelta::FromMilliseconds(1),
    302                                    base::TimeDelta::FromMinutes(10),
    303                                    100);
    304       }
    305     }
    306     SetSocket(transport_socket_.Pass());
    307     fallback_timer_.Stop();
    308   } else {
    309     // Be a bit paranoid and kill off the fallback members to prevent reuse.
    310     fallback_transport_socket_.reset();
    311     fallback_addresses_.reset();
    312   }
    313 
    314   return result;
    315 }
    316 
    317 void TransportConnectJob::DoIPv6FallbackTransportConnect() {
    318   // The timer should only fire while we're waiting for the main connect to
    319   // succeed.
    320   if (next_state_ != STATE_TRANSPORT_CONNECT_COMPLETE) {
    321     NOTREACHED();
    322     return;
    323   }
    324 
    325   DCHECK(!fallback_transport_socket_.get());
    326   DCHECK(!fallback_addresses_.get());
    327 
    328   fallback_addresses_.reset(new AddressList(addresses_));
    329   MakeAddressListStartWithIPv4(fallback_addresses_.get());
    330   fallback_transport_socket_ =
    331       client_socket_factory_->CreateTransportClientSocket(
    332           *fallback_addresses_, net_log().net_log(), net_log().source());
    333   fallback_connect_start_time_ = base::TimeTicks::Now();
    334   int rv = fallback_transport_socket_->Connect(
    335       base::Bind(
    336           &TransportConnectJob::DoIPv6FallbackTransportConnectComplete,
    337           base::Unretained(this)));
    338   if (rv != ERR_IO_PENDING)
    339     DoIPv6FallbackTransportConnectComplete(rv);
    340 }
    341 
    342 void TransportConnectJob::DoIPv6FallbackTransportConnectComplete(int result) {
    343   // This should only happen when we're waiting for the main connect to succeed.
    344   if (next_state_ != STATE_TRANSPORT_CONNECT_COMPLETE) {
    345     NOTREACHED();
    346     return;
    347   }
    348 
    349   DCHECK_NE(ERR_IO_PENDING, result);
    350   DCHECK(fallback_transport_socket_.get());
    351   DCHECK(fallback_addresses_.get());
    352 
    353   if (result == OK) {
    354     DCHECK(!fallback_connect_start_time_.is_null());
    355     DCHECK(!connect_timing_.dns_start.is_null());
    356     base::TimeTicks now = base::TimeTicks::Now();
    357     base::TimeDelta total_duration = now - connect_timing_.dns_start;
    358     UMA_HISTOGRAM_CUSTOM_TIMES(
    359         "Net.DNS_Resolution_And_TCP_Connection_Latency2",
    360         total_duration,
    361         base::TimeDelta::FromMilliseconds(1),
    362         base::TimeDelta::FromMinutes(10),
    363         100);
    364 
    365     base::TimeDelta connect_duration = now - fallback_connect_start_time_;
    366     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
    367         connect_duration,
    368         base::TimeDelta::FromMilliseconds(1),
    369         base::TimeDelta::FromMinutes(10),
    370         100);
    371 
    372     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_Wins_Race",
    373         connect_duration,
    374         base::TimeDelta::FromMilliseconds(1),
    375         base::TimeDelta::FromMinutes(10),
    376         100);
    377     SetSocket(fallback_transport_socket_.Pass());
    378     next_state_ = STATE_NONE;
    379     transport_socket_.reset();
    380   } else {
    381     // Be a bit paranoid and kill off the fallback members to prevent reuse.
    382     fallback_transport_socket_.reset();
    383     fallback_addresses_.reset();
    384   }
    385   NotifyDelegateOfCompletion(result);  // Deletes |this|
    386 }
    387 
    388 int TransportConnectJob::ConnectInternal() {
    389   next_state_ = STATE_RESOLVE_HOST;
    390   return DoLoop(OK);
    391 }
    392 
    393 scoped_ptr<ConnectJob>
    394     TransportClientSocketPool::TransportConnectJobFactory::NewConnectJob(
    395     const std::string& group_name,
    396     const PoolBase::Request& request,
    397     ConnectJob::Delegate* delegate) const {
    398   return scoped_ptr<ConnectJob>(
    399       new TransportConnectJob(group_name,
    400                               request.priority(),
    401                               request.params(),
    402                               ConnectionTimeout(),
    403                               client_socket_factory_,
    404                               host_resolver_,
    405                               delegate,
    406                               net_log_));
    407 }
    408 
    409 base::TimeDelta
    410     TransportClientSocketPool::TransportConnectJobFactory::ConnectionTimeout()
    411     const {
    412   return base::TimeDelta::FromSeconds(kTransportConnectJobTimeoutInSeconds);
    413 }
    414 
    415 TransportClientSocketPool::TransportClientSocketPool(
    416     int max_sockets,
    417     int max_sockets_per_group,
    418     ClientSocketPoolHistograms* histograms,
    419     HostResolver* host_resolver,
    420     ClientSocketFactory* client_socket_factory,
    421     NetLog* net_log)
    422     : base_(NULL, max_sockets, max_sockets_per_group, histograms,
    423             ClientSocketPool::unused_idle_socket_timeout(),
    424             ClientSocketPool::used_idle_socket_timeout(),
    425             new TransportConnectJobFactory(client_socket_factory,
    426                                            host_resolver, net_log)) {
    427   base_.EnableConnectBackupJobs();
    428 }
    429 
    430 TransportClientSocketPool::~TransportClientSocketPool() {}
    431 
    432 int TransportClientSocketPool::RequestSocket(
    433     const std::string& group_name,
    434     const void* params,
    435     RequestPriority priority,
    436     ClientSocketHandle* handle,
    437     const CompletionCallback& callback,
    438     const BoundNetLog& net_log) {
    439   const scoped_refptr<TransportSocketParams>* casted_params =
    440       static_cast<const scoped_refptr<TransportSocketParams>*>(params);
    441 
    442   if (net_log.IsLoggingAllEvents()) {
    443     // TODO(eroman): Split out the host and port parameters.
    444     net_log.AddEvent(
    445         NetLog::TYPE_TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
    446         CreateNetLogHostPortPairCallback(
    447             &casted_params->get()->destination().host_port_pair()));
    448   }
    449 
    450   return base_.RequestSocket(group_name, *casted_params, priority, handle,
    451                              callback, net_log);
    452 }
    453 
    454 void TransportClientSocketPool::RequestSockets(
    455     const std::string& group_name,
    456     const void* params,
    457     int num_sockets,
    458     const BoundNetLog& net_log) {
    459   const scoped_refptr<TransportSocketParams>* casted_params =
    460       static_cast<const scoped_refptr<TransportSocketParams>*>(params);
    461 
    462   if (net_log.IsLoggingAllEvents()) {
    463     // TODO(eroman): Split out the host and port parameters.
    464     net_log.AddEvent(
    465         NetLog::TYPE_TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKETS,
    466         CreateNetLogHostPortPairCallback(
    467             &casted_params->get()->destination().host_port_pair()));
    468   }
    469 
    470   base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
    471 }
    472 
    473 void TransportClientSocketPool::CancelRequest(
    474     const std::string& group_name,
    475     ClientSocketHandle* handle) {
    476   base_.CancelRequest(group_name, handle);
    477 }
    478 
    479 void TransportClientSocketPool::ReleaseSocket(
    480     const std::string& group_name,
    481     scoped_ptr<StreamSocket> socket,
    482     int id) {
    483   base_.ReleaseSocket(group_name, socket.Pass(), id);
    484 }
    485 
    486 void TransportClientSocketPool::FlushWithError(int error) {
    487   base_.FlushWithError(error);
    488 }
    489 
    490 void TransportClientSocketPool::CloseIdleSockets() {
    491   base_.CloseIdleSockets();
    492 }
    493 
    494 int TransportClientSocketPool::IdleSocketCount() const {
    495   return base_.idle_socket_count();
    496 }
    497 
    498 int TransportClientSocketPool::IdleSocketCountInGroup(
    499     const std::string& group_name) const {
    500   return base_.IdleSocketCountInGroup(group_name);
    501 }
    502 
    503 LoadState TransportClientSocketPool::GetLoadState(
    504     const std::string& group_name, const ClientSocketHandle* handle) const {
    505   return base_.GetLoadState(group_name, handle);
    506 }
    507 
    508 base::DictionaryValue* TransportClientSocketPool::GetInfoAsValue(
    509     const std::string& name,
    510     const std::string& type,
    511     bool include_nested_pools) const {
    512   return base_.GetInfoAsValue(name, type);
    513 }
    514 
    515 base::TimeDelta TransportClientSocketPool::ConnectionTimeout() const {
    516   return base_.ConnectionTimeout();
    517 }
    518 
    519 ClientSocketPoolHistograms* TransportClientSocketPool::histograms() const {
    520   return base_.histograms();
    521 }
    522 
    523 bool TransportClientSocketPool::IsStalled() const {
    524   return base_.IsStalled();
    525 }
    526 
    527 void TransportClientSocketPool::AddHigherLayeredPool(
    528     HigherLayeredPool* higher_pool) {
    529   base_.AddHigherLayeredPool(higher_pool);
    530 }
    531 
    532 void TransportClientSocketPool::RemoveHigherLayeredPool(
    533     HigherLayeredPool* higher_pool) {
    534   base_.RemoveHigherLayeredPool(higher_pool);
    535 }
    536 
    537 }  // namespace net
    538