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.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/base/host_resolver.h"
  17 #include "net/socket/client_socket_pool_base.h"
  18 #include "net/socket/client_socket_pool_histograms.h"
  19 #include "net/socket/client_socket_pool.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                     RequestPriority priority);
  33
  34   const scoped_refptr<TransportSocketParams>& transport_params() const {
  35     return transport_params_;
  36   }
  37   const HostResolver::RequestInfo& destination() const { return destination_; }
  38   bool is_socks_v5() const { return socks_v5_; }
  39   bool ignore_limits() const { return ignore_limits_; }
  40
  41  private:
  42   friend class base::RefCounted<SOCKSSocketParams>;
  43   ~SOCKSSocketParams();
  44
  45   // The transport (likely TCP) connection must point toward the proxy server.
  46   const scoped_refptr<TransportSocketParams> transport_params_;
  47   // This is the HTTP destination.
  48   HostResolver::RequestInfo destination_;
  49   const bool socks_v5_;
  50   bool ignore_limits_;
  51
  52   DISALLOW_COPY_AND_ASSIGN(SOCKSSocketParams);
  53 };
  54
  55 // SOCKSConnectJob handles the handshake to a socks server after setting up
  56 // an underlying transport socket.
  57 class SOCKSConnectJob : public ConnectJob {
  58  public:
  59   SOCKSConnectJob(const std::string& group_name,
  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   virtual ~SOCKSConnectJob();
  67
  68   // ConnectJob methods.
  69   virtual 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   virtual 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 LayeredPool {
 109  public:
 110   SOCKSClientSocketPool(
 111       int max_sockets,
 112       int max_sockets_per_group,
 113       ClientSocketPoolHistograms* histograms,
 114       HostResolver* host_resolver,
 115       TransportClientSocketPool* transport_pool,
 116       NetLog* net_log);
 117
 118   virtual ~SOCKSClientSocketPool();
 119
 120   // ClientSocketPool implementation.
 121   virtual int RequestSocket(const std::string& group_name,
 122                             const void* connect_params,
 123                             RequestPriority priority,
 124                             ClientSocketHandle* handle,
 125                             const CompletionCallback& callback,
 126                             const BoundNetLog& net_log) OVERRIDE;
 127
 128   virtual void RequestSockets(const std::string& group_name,
 129                               const void* params,
 130                               int num_sockets,
 131                               const BoundNetLog& net_log) OVERRIDE;
 132
 133   virtual void CancelRequest(const std::string& group_name,
 134                              ClientSocketHandle* handle) OVERRIDE;
 135
 136   virtual void ReleaseSocket(const std::string& group_name,
 137                              StreamSocket* socket,
 138                              int id) OVERRIDE;
 139
 140   virtual void FlushWithError(int error) OVERRIDE;
 141
 142   virtual bool IsStalled() const OVERRIDE;
 143
 144   virtual void CloseIdleSockets() OVERRIDE;
 145
 146   virtual int IdleSocketCount() const OVERRIDE;
 147
 148   virtual int IdleSocketCountInGroup(
 149       const std::string& group_name) const OVERRIDE;
 150
 151   virtual LoadState GetLoadState(
 152       const std::string& group_name,
 153       const ClientSocketHandle* handle) const OVERRIDE;
 154
 155   virtual void AddLayeredPool(LayeredPool* layered_pool) OVERRIDE;
 156
 157   virtual void RemoveLayeredPool(LayeredPool* layered_pool) OVERRIDE;
 158
 159   virtual base::DictionaryValue* GetInfoAsValue(
 160       const std::string& name,
 161       const std::string& type,
 162       bool include_nested_pools) const OVERRIDE;
 163
 164   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 165
 166   virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
 167
 168   // LayeredPool implementation.
 169   virtual bool CloseOneIdleConnection() OVERRIDE;
 170
 171  private:
 172   typedef ClientSocketPoolBase<SOCKSSocketParams> PoolBase;
 173
 174   class SOCKSConnectJobFactory : public PoolBase::ConnectJobFactory {
 175    public:
 176     SOCKSConnectJobFactory(TransportClientSocketPool* transport_pool,
 177                            HostResolver* host_resolver,
 178                            NetLog* net_log)
 179         : transport_pool_(transport_pool),
 180           host_resolver_(host_resolver),
 181           net_log_(net_log) {}
 182
 183     virtual ~SOCKSConnectJobFactory() {}
 184
 185     // ClientSocketPoolBase::ConnectJobFactory methods.
 186     virtual ConnectJob* NewConnectJob(
 187         const std::string& group_name,
 188         const PoolBase::Request& request,
 189         ConnectJob::Delegate* delegate) const OVERRIDE;
 190
 191     virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 192
 193    private:
 194     TransportClientSocketPool* const transport_pool_;
 195     HostResolver* const host_resolver_;
 196     NetLog* net_log_;
 197
 198     DISALLOW_COPY_AND_ASSIGN(SOCKSConnectJobFactory);
 199   };
 200
 201   TransportClientSocketPool* const transport_pool_;
 202   PoolBase base_;
 203
 204   DISALLOW_COPY_AND_ASSIGN(SOCKSClientSocketPool);
 205 };
 206
 207 REGISTER_SOCKET_PARAMS_FOR_POOL(SOCKSClientSocketPool, SOCKSSocketParams);
 208
 209 }  // namespace net
 210
 211 #endif  // NET_SOCKET_SOCKS_CLIENT_SOCKET_POOL_H_