net/socket/socks_client_socket_pool.h

   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 #ifndef NET_SOCKET_SOCKS_CLIENT_SOCKET_POOL_H_
   6 #define NET_SOCKET_SOCKS_CLIENT_SOCKET_POOL_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/time/time.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/dns/host_resolver.h"
  17 #include "net/socket/client_socket_pool.h"
  18 #include "net/socket/client_socket_pool_base.h"
  19 #include "net/socket/client_socket_pool_histograms.h"
  20
  21 namespace net {
  22
  23 class ConnectJobFactory;
  24 class TransportClientSocketPool;
  25 class TransportSocketParams;
  26
  27 class NET_EXPORT_PRIVATE SOCKSSocketParams
  28     : public base::RefCounted<SOCKSSocketParams> {
  29  public:
  30   SOCKSSocketParams(const scoped_refptr<TransportSocketParams>& proxy_server,
  31                     bool socks_v5, const HostPortPair& host_port_pair);
  32
  33   const scoped_refptr<TransportSocketParams>& transport_params() const {
  34     return transport_params_;
  35   }
  36   const HostResolver::RequestInfo& destination() const { return destination_; }
  37   bool is_socks_v5() const { return socks_v5_; }
  38   bool ignore_limits() const { return ignore_limits_; }
  39
  40  private:
  41   friend class base::RefCounted<SOCKSSocketParams>;
  42   ~SOCKSSocketParams();
  43
  44   // The transport (likely TCP) connection must point toward the proxy server.
  45   const scoped_refptr<TransportSocketParams> transport_params_;
  46   // This is the HTTP destination.
  47   HostResolver::RequestInfo destination_;
  48   const bool socks_v5_;
  49   bool ignore_limits_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(SOCKSSocketParams);
  52 };
  53
  54 // SOCKSConnectJob handles the handshake to a socks server after setting up
  55 // an underlying transport socket.
  56 class SOCKSConnectJob : public ConnectJob {
  57  public:
  58   SOCKSConnectJob(const std::string& group_name,
  59                   RequestPriority priority,
  60                   const scoped_refptr<SOCKSSocketParams>& params,
  61                   const base::TimeDelta& timeout_duration,
  62                   TransportClientSocketPool* transport_pool,
  63                   HostResolver* host_resolver,
  64                   Delegate* delegate,
  65                   NetLog* net_log);
  66   ~SOCKSConnectJob() override;
  67
  68   // ConnectJob methods.
  69   LoadState GetLoadState() const override;
  70
  71  private:
  72   enum State {
  73     STATE_TRANSPORT_CONNECT,
  74     STATE_TRANSPORT_CONNECT_COMPLETE,
  75     STATE_SOCKS_CONNECT,
  76     STATE_SOCKS_CONNECT_COMPLETE,
  77     STATE_NONE,
  78   };
  79
  80   void OnIOComplete(int result);
  81
  82   // Runs the state transition loop.
  83   int DoLoop(int result);
  84
  85   int DoTransportConnect();
  86   int DoTransportConnectComplete(int result);
  87   int DoSOCKSConnect();
  88   int DoSOCKSConnectComplete(int result);
  89
  90   // Begins the transport connection and the SOCKS handshake.  Returns OK on
  91   // success and ERR_IO_PENDING if it cannot immediately service the request.
  92   // Otherwise, it returns a net error code.
  93   int ConnectInternal() override;
  94
  95   scoped_refptr<SOCKSSocketParams> socks_params_;
  96   TransportClientSocketPool* const transport_pool_;
  97   HostResolver* const resolver_;
  98
  99   State next_state_;
 100   CompletionCallback callback_;
 101   scoped_ptr<ClientSocketHandle> transport_socket_handle_;
 102   scoped_ptr<StreamSocket> socket_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(SOCKSConnectJob);
 105 };
 106
 107 class NET_EXPORT_PRIVATE SOCKSClientSocketPool
 108     : public ClientSocketPool, public HigherLayeredPool {
 109  public:
 110   typedef SOCKSSocketParams SocketParams;
 111
 112   SOCKSClientSocketPool(
 113       int max_sockets,
 114       int max_sockets_per_group,
 115       ClientSocketPoolHistograms* histograms,
 116       HostResolver* host_resolver,
 117       TransportClientSocketPool* transport_pool,
 118       NetLog* net_log);
 119
 120   ~SOCKSClientSocketPool() override;
 121
 122   // ClientSocketPool implementation.
 123   int RequestSocket(const std::string& group_name,
 124                     const void* connect_params,
 125                     RequestPriority priority,
 126                     ClientSocketHandle* handle,
 127                     const CompletionCallback& callback,
 128                     const BoundNetLog& net_log) override;
 129
 130   void RequestSockets(const std::string& group_name,
 131                       const void* params,
 132                       int num_sockets,
 133                       const BoundNetLog& net_log) override;
 134
 135   void CancelRequest(const std::string& group_name,
 136                      ClientSocketHandle* handle) override;
 137
 138   void ReleaseSocket(const std::string& group_name,
 139                      scoped_ptr<StreamSocket> socket,
 140                      int id) override;
 141
 142   void FlushWithError(int error) override;
 143
 144   void CloseIdleSockets() override;
 145
 146   int IdleSocketCount() const override;
 147
 148   int IdleSocketCountInGroup(const std::string& group_name) const override;
 149
 150   LoadState GetLoadState(const std::string& group_name,
 151                          const ClientSocketHandle* handle) const override;
 152
 153   base::DictionaryValue* GetInfoAsValue(
 154       const std::string& name,
 155       const std::string& type,
 156       bool include_nested_pools) const override;
 157
 158   base::TimeDelta ConnectionTimeout() const override;
 159
 160   ClientSocketPoolHistograms* histograms() const override;
 161
 162   // LowerLayeredPool implementation.
 163   bool IsStalled() const override;
 164
 165   void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 166
 167   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 168
 169   // HigherLayeredPool implementation.
 170   bool CloseOneIdleConnection() override;
 171
 172  private:
 173   typedef ClientSocketPoolBase<SOCKSSocketParams> PoolBase;
 174
 175   class SOCKSConnectJobFactory : public PoolBase::ConnectJobFactory {
 176    public:
 177     SOCKSConnectJobFactory(TransportClientSocketPool* transport_pool,
 178                            HostResolver* host_resolver,
 179                            NetLog* net_log)
 180         : transport_pool_(transport_pool),
 181           host_resolver_(host_resolver),
 182           net_log_(net_log) {}
 183
 184     ~SOCKSConnectJobFactory() override {}
 185
 186     // ClientSocketPoolBase::ConnectJobFactory methods.
 187     scoped_ptr<ConnectJob> NewConnectJob(
 188         const std::string& group_name,
 189         const PoolBase::Request& request,
 190         ConnectJob::Delegate* delegate) const override;
 191
 192     base::TimeDelta ConnectionTimeout() const override;
 193
 194    private:
 195     TransportClientSocketPool* const transport_pool_;
 196     HostResolver* const host_resolver_;
 197     NetLog* net_log_;
 198
 199     DISALLOW_COPY_AND_ASSIGN(SOCKSConnectJobFactory);
 200   };
 201
 202   TransportClientSocketPool* const transport_pool_;
 203   PoolBase base_;
 204
 205   DISALLOW_COPY_AND_ASSIGN(SOCKSClientSocketPool);
 206 };
 207
 208 }  // namespace net
 209
 210 #endif  // NET_SOCKET_SOCKS_CLIENT_SOCKET_POOL_H_