net/socket/socks_client_socket_pool.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/socks_client_socket_pool.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/time/time.h"
  10 #include "base/values.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/socket/client_socket_factory.h"
  13 #include "net/socket/client_socket_handle.h"
  14 #include "net/socket/client_socket_pool_base.h"
  15 #include "net/socket/socks5_client_socket.h"
  16 #include "net/socket/socks_client_socket.h"
  17 #include "net/socket/transport_client_socket_pool.h"
  18
  19 namespace net {
  20
  21 SOCKSSocketParams::SOCKSSocketParams(
  22     const scoped_refptr<TransportSocketParams>& proxy_server,
  23     bool socks_v5,
  24     const HostPortPair& host_port_pair,
  25     RequestPriority priority)
  26     : transport_params_(proxy_server),
  27       destination_(host_port_pair),
  28       socks_v5_(socks_v5) {
  29   if (transport_params_.get())
  30     ignore_limits_ = transport_params_->ignore_limits();
  31   else
  32     ignore_limits_ = false;
  33   destination_.set_priority(priority);
  34 }
  35
  36 SOCKSSocketParams::~SOCKSSocketParams() {}
  37
  38 // SOCKSConnectJobs will time out after this many seconds.  Note this is on
  39 // top of the timeout for the transport socket.
  40 static const int kSOCKSConnectJobTimeoutInSeconds = 30;
  41
  42 SOCKSConnectJob::SOCKSConnectJob(
  43     const std::string& group_name,
  44     const scoped_refptr<SOCKSSocketParams>& socks_params,
  45     const base::TimeDelta& timeout_duration,
  46     TransportClientSocketPool* transport_pool,
  47     HostResolver* host_resolver,
  48     Delegate* delegate,
  49     NetLog* net_log)
  50     : ConnectJob(group_name, timeout_duration, delegate,
  51                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
  52       socks_params_(socks_params),
  53       transport_pool_(transport_pool),
  54       resolver_(host_resolver),
  55       callback_(base::Bind(&SOCKSConnectJob::OnIOComplete,
  56                            base::Unretained(this))) {
  57 }
  58
  59 SOCKSConnectJob::~SOCKSConnectJob() {
  60   // We don't worry about cancelling the tcp socket since the destructor in
  61   // scoped_ptr<ClientSocketHandle> transport_socket_handle_ will take care of
  62   // it.
  63 }
  64
  65 LoadState SOCKSConnectJob::GetLoadState() const {
  66   switch (next_state_) {
  67     case STATE_TRANSPORT_CONNECT:
  68     case STATE_TRANSPORT_CONNECT_COMPLETE:
  69       return transport_socket_handle_->GetLoadState();
  70     case STATE_SOCKS_CONNECT:
  71     case STATE_SOCKS_CONNECT_COMPLETE:
  72       return LOAD_STATE_CONNECTING;
  73     default:
  74       NOTREACHED();
  75       return LOAD_STATE_IDLE;
  76   }
  77 }
  78
  79 void SOCKSConnectJob::OnIOComplete(int result) {
  80   int rv = DoLoop(result);
  81   if (rv != ERR_IO_PENDING)
  82     NotifyDelegateOfCompletion(rv);  // Deletes |this|
  83 }
  84
  85 int SOCKSConnectJob::DoLoop(int result) {
  86   DCHECK_NE(next_state_, STATE_NONE);
  87
  88   int rv = result;
  89   do {
  90     State state = next_state_;
  91     next_state_ = STATE_NONE;
  92     switch (state) {
  93       case STATE_TRANSPORT_CONNECT:
  94         DCHECK_EQ(OK, rv);
  95         rv = DoTransportConnect();
  96         break;
  97       case STATE_TRANSPORT_CONNECT_COMPLETE:
  98         rv = DoTransportConnectComplete(rv);
  99         break;
 100       case STATE_SOCKS_CONNECT:
 101         DCHECK_EQ(OK, rv);
 102         rv = DoSOCKSConnect();
 103         break;
 104       case STATE_SOCKS_CONNECT_COMPLETE:
 105         rv = DoSOCKSConnectComplete(rv);
 106         break;
 107       default:
 108         NOTREACHED() << "bad state";
 109         rv = ERR_FAILED;
 110         break;
 111     }
 112   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 113
 114   return rv;
 115 }
 116
 117 int SOCKSConnectJob::DoTransportConnect() {
 118   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
 119   transport_socket_handle_.reset(new ClientSocketHandle());
 120   return transport_socket_handle_->Init(
 121       group_name(), socks_params_->transport_params(),
 122       socks_params_->destination().priority(), callback_, transport_pool_,
 123       net_log());
 124 }
 125
 126 int SOCKSConnectJob::DoTransportConnectComplete(int result) {
 127   if (result != OK)
 128     return ERR_PROXY_CONNECTION_FAILED;
 129
 130   // Reset the timer to just the length of time allowed for SOCKS handshake
 131   // so that a fast TCP connection plus a slow SOCKS failure doesn't take
 132   // longer to timeout than it should.
 133   ResetTimer(base::TimeDelta::FromSeconds(kSOCKSConnectJobTimeoutInSeconds));
 134   next_state_ = STATE_SOCKS_CONNECT;
 135   return result;
 136 }
 137
 138 int SOCKSConnectJob::DoSOCKSConnect() {
 139   next_state_ = STATE_SOCKS_CONNECT_COMPLETE;
 140
 141   // Add a SOCKS connection on top of the tcp socket.
 142   if (socks_params_->is_socks_v5()) {
 143     socket_.reset(new SOCKS5ClientSocket(transport_socket_handle_.release(),
 144                                          socks_params_->destination()));
 145   } else {
 146     socket_.reset(new SOCKSClientSocket(transport_socket_handle_.release(),
 147                                         socks_params_->destination(),
 148                                         resolver_));
 149   }
 150   return socket_->Connect(
 151       base::Bind(&SOCKSConnectJob::OnIOComplete, base::Unretained(this)));
 152 }
 153
 154 int SOCKSConnectJob::DoSOCKSConnectComplete(int result) {
 155   if (result != OK) {
 156     socket_->Disconnect();
 157     return result;
 158   }
 159
 160   set_socket(socket_.release());
 161   return result;
 162 }
 163
 164 int SOCKSConnectJob::ConnectInternal() {
 165   next_state_ = STATE_TRANSPORT_CONNECT;
 166   return DoLoop(OK);
 167 }
 168
 169 ConnectJob* SOCKSClientSocketPool::SOCKSConnectJobFactory::NewConnectJob(
 170     const std::string& group_name,
 171     const PoolBase::Request& request,
 172     ConnectJob::Delegate* delegate) const {
 173   return new SOCKSConnectJob(group_name,
 174                              request.params(),
 175                              ConnectionTimeout(),
 176                              transport_pool_,
 177                              host_resolver_,
 178                              delegate,
 179                              net_log_);
 180 }
 181
 182 base::TimeDelta
 183 SOCKSClientSocketPool::SOCKSConnectJobFactory::ConnectionTimeout() const {
 184   return transport_pool_->ConnectionTimeout() +
 185       base::TimeDelta::FromSeconds(kSOCKSConnectJobTimeoutInSeconds);
 186 }
 187
 188 SOCKSClientSocketPool::SOCKSClientSocketPool(
 189     int max_sockets,
 190     int max_sockets_per_group,
 191     ClientSocketPoolHistograms* histograms,
 192     HostResolver* host_resolver,
 193     TransportClientSocketPool* transport_pool,
 194     NetLog* net_log)
 195     : transport_pool_(transport_pool),
 196       base_(max_sockets, max_sockets_per_group, histograms,
 197             ClientSocketPool::unused_idle_socket_timeout(),
 198             ClientSocketPool::used_idle_socket_timeout(),
 199             new SOCKSConnectJobFactory(transport_pool,
 200                                        host_resolver,
 201                                        net_log)) {
 202   // We should always have a |transport_pool_| except in unit tests.
 203   if (transport_pool_)
 204     transport_pool_->AddLayeredPool(this);
 205 }
 206
 207 SOCKSClientSocketPool::~SOCKSClientSocketPool() {
 208   // We should always have a |transport_pool_| except in unit tests.
 209   if (transport_pool_)
 210     transport_pool_->RemoveLayeredPool(this);
 211 }
 212
 213 int SOCKSClientSocketPool::RequestSocket(
 214     const std::string& group_name, const void* socket_params,
 215     RequestPriority priority, ClientSocketHandle* handle,
 216     const CompletionCallback& callback, const BoundNetLog& net_log) {
 217   const scoped_refptr<SOCKSSocketParams>* casted_socket_params =
 218       static_cast<const scoped_refptr<SOCKSSocketParams>*>(socket_params);
 219
 220   return base_.RequestSocket(group_name, *casted_socket_params, priority,
 221                              handle, callback, net_log);
 222 }
 223
 224 void SOCKSClientSocketPool::RequestSockets(
 225     const std::string& group_name,
 226     const void* params,
 227     int num_sockets,
 228     const BoundNetLog& net_log) {
 229   const scoped_refptr<SOCKSSocketParams>* casted_params =
 230       static_cast<const scoped_refptr<SOCKSSocketParams>*>(params);
 231
 232   base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
 233 }
 234
 235 void SOCKSClientSocketPool::CancelRequest(const std::string& group_name,
 236                                           ClientSocketHandle* handle) {
 237   base_.CancelRequest(group_name, handle);
 238 }
 239
 240 void SOCKSClientSocketPool::ReleaseSocket(const std::string& group_name,
 241                                           StreamSocket* socket, int id) {
 242   base_.ReleaseSocket(group_name, socket, id);
 243 }
 244
 245 void SOCKSClientSocketPool::FlushWithError(int error) {
 246   base_.FlushWithError(error);
 247 }
 248
 249 bool SOCKSClientSocketPool::IsStalled() const {
 250   return base_.IsStalled() || transport_pool_->IsStalled();
 251 }
 252
 253 void SOCKSClientSocketPool::CloseIdleSockets() {
 254   base_.CloseIdleSockets();
 255 }
 256
 257 int SOCKSClientSocketPool::IdleSocketCount() const {
 258   return base_.idle_socket_count();
 259 }
 260
 261 int SOCKSClientSocketPool::IdleSocketCountInGroup(
 262     const std::string& group_name) const {
 263   return base_.IdleSocketCountInGroup(group_name);
 264 }
 265
 266 LoadState SOCKSClientSocketPool::GetLoadState(
 267     const std::string& group_name, const ClientSocketHandle* handle) const {
 268   return base_.GetLoadState(group_name, handle);
 269 }
 270
 271 void SOCKSClientSocketPool::AddLayeredPool(LayeredPool* layered_pool) {
 272   base_.AddLayeredPool(layered_pool);
 273 }
 274
 275 void SOCKSClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) {
 276   base_.RemoveLayeredPool(layered_pool);
 277 }
 278
 279 base::DictionaryValue* SOCKSClientSocketPool::GetInfoAsValue(
 280     const std::string& name,
 281     const std::string& type,
 282     bool include_nested_pools) const {
 283   base::DictionaryValue* dict = base_.GetInfoAsValue(name, type);
 284   if (include_nested_pools) {
 285     base::ListValue* list = new base::ListValue();
 286     list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool",
 287                                                  "transport_socket_pool",
 288                                                  false));
 289     dict->Set("nested_pools", list);
 290   }
 291   return dict;
 292 }
 293
 294 base::TimeDelta SOCKSClientSocketPool::ConnectionTimeout() const {
 295   return base_.ConnectionTimeout();
 296 }
 297
 298 ClientSocketPoolHistograms* SOCKSClientSocketPool::histograms() const {
 299   return base_.histograms();
 300 };
 301
 302 bool SOCKSClientSocketPool::CloseOneIdleConnection() {
 303   if (base_.CloseOneIdleSocket())
 304     return true;
 305   return base_.CloseOneIdleConnectionInLayeredPool();
 306 }
 307
 308 }  // namespace net