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_H_ 6 #define NET_SOCKET_SOCKS_CLIENT_SOCKET_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/gtest_prod_util.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "net/base/address_list.h" 15 #include "net/base/completion_callback.h" 16 #include "net/base/net_errors.h" 17 #include "net/base/net_log.h" 18 #include "net/dns/host_resolver.h" 19 #include "net/dns/single_request_host_resolver.h" 20 #include "net/socket/stream_socket.h" 21 22 namespace net { 23 24 class ClientSocketHandle; 25 class BoundNetLog; 26 27 // The SOCKS client socket implementation 28 class NET_EXPORT_PRIVATE SOCKSClientSocket : public StreamSocket { 29 public: 30 // |req_info| contains the hostname and port to which the socket above will 31 // communicate to via the socks layer. For testing the referrer is optional. 32 SOCKSClientSocket(scoped_ptr<ClientSocketHandle> transport_socket, 33 const HostResolver::RequestInfo& req_info, 34 RequestPriority priority, 35 HostResolver* host_resolver); 36 37 // On destruction Disconnect() is called. 38 virtual ~SOCKSClientSocket(); 39 40 // StreamSocket implementation. 41 42 // Does the SOCKS handshake and completes the protocol. 43 virtual int Connect(const CompletionCallback& callback) OVERRIDE; 44 virtual void Disconnect() OVERRIDE; 45 virtual bool IsConnected() const OVERRIDE; 46 virtual bool IsConnectedAndIdle() const OVERRIDE; 47 virtual const BoundNetLog& NetLog() const OVERRIDE; 48 virtual void SetSubresourceSpeculation() OVERRIDE; 49 virtual void SetOmniboxSpeculation() OVERRIDE; 50 virtual bool WasEverUsed() const OVERRIDE; 51 virtual bool UsingTCPFastOpen() const OVERRIDE; 52 virtual bool WasNpnNegotiated() const OVERRIDE; 53 virtual NextProto GetNegotiatedProtocol() const OVERRIDE; 54 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE; 55 56 // Socket implementation. 57 virtual int Read(IOBuffer* buf, 58 int buf_len, 59 const CompletionCallback& callback) OVERRIDE; 60 virtual int Write(IOBuffer* buf, 61 int buf_len, 62 const CompletionCallback& callback) OVERRIDE; 63 64 virtual int SetReceiveBufferSize(int32 size) OVERRIDE; 65 virtual int SetSendBufferSize(int32 size) OVERRIDE; 66 67 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE; 68 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE; 69 70 private: 71 FRIEND_TEST_ALL_PREFIXES(SOCKSClientSocketTest, CompleteHandshake); 72 FRIEND_TEST_ALL_PREFIXES(SOCKSClientSocketTest, SOCKS4AFailedDNS); 73 FRIEND_TEST_ALL_PREFIXES(SOCKSClientSocketTest, SOCKS4AIfDomainInIPv6); 74 75 enum State { 76 STATE_RESOLVE_HOST, 77 STATE_RESOLVE_HOST_COMPLETE, 78 STATE_HANDSHAKE_WRITE, 79 STATE_HANDSHAKE_WRITE_COMPLETE, 80 STATE_HANDSHAKE_READ, 81 STATE_HANDSHAKE_READ_COMPLETE, 82 STATE_NONE, 83 }; 84 85 void DoCallback(int result); 86 void OnIOComplete(int result); 87 void OnReadWriteComplete(const CompletionCallback& callback, int result); 88 89 int DoLoop(int last_io_result); 90 int DoResolveHost(); 91 int DoResolveHostComplete(int result); 92 int DoHandshakeRead(); 93 int DoHandshakeReadComplete(int result); 94 int DoHandshakeWrite(); 95 int DoHandshakeWriteComplete(int result); 96 97 const std::string BuildHandshakeWriteBuffer() const; 98 99 // Stores the underlying socket. 100 scoped_ptr<ClientSocketHandle> transport_; 101 102 State next_state_; 103 104 // Stores the callbacks to the layer above, called on completing Connect(). 105 CompletionCallback user_callback_; 106 107 // This IOBuffer is used by the class to read and write 108 // SOCKS handshake data. The length contains the expected size to 109 // read or write. 110 scoped_refptr<IOBuffer> handshake_buf_; 111 112 // While writing, this buffer stores the complete write handshake data. 113 // While reading, it stores the handshake information received so far. 114 std::string buffer_; 115 116 // This becomes true when the SOCKS handshake has completed and the 117 // overlying connection is free to communicate. 118 bool completed_handshake_; 119 120 // These contain the bytes sent / received by the SOCKS handshake. 121 size_t bytes_sent_; 122 size_t bytes_received_; 123 124 // This becomes true when the socket is used to send or receive data. 125 bool was_ever_used_; 126 127 // Used to resolve the hostname to which the SOCKS proxy will connect. 128 SingleRequestHostResolver host_resolver_; 129 AddressList addresses_; 130 HostResolver::RequestInfo host_request_info_; 131 RequestPriority priority_; 132 133 BoundNetLog net_log_; 134 135 DISALLOW_COPY_AND_ASSIGN(SOCKSClientSocket); 136 }; 137 138 } // namespace net 139 140 #endif // NET_SOCKET_SOCKS_CLIENT_SOCKET_H_ 141