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 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_ 212
