1 // Copyright (c) 2011 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_SOCKS5_CLIENT_SOCKET_H_ 6 #define NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/basictypes.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "googleurl/src/gurl.h" 15 #include "net/base/address_list.h" 16 #include "net/base/completion_callback.h" 17 #include "net/base/host_resolver.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/net_log.h" 20 #include "net/socket/client_socket.h" 21 #include "testing/gtest/include/gtest/gtest_prod.h" 22 23 namespace net { 24 25 class ClientSocketHandle; 26 class BoundNetLog; 27 28 // This ClientSocket is used to setup a SOCKSv5 handshake with a socks proxy. 29 // Currently no SOCKSv5 authentication is supported. 30 class SOCKS5ClientSocket : public ClientSocket { 31 public: 32 // Takes ownership of the |transport_socket|, which should already be 33 // connected by the time Connect() is called. 34 // 35 // |req_info| contains the hostname and port to which the socket above will 36 // communicate to via the SOCKS layer. 37 // 38 // Although SOCKS 5 supports 3 different modes of addressing, we will 39 // always pass it a hostname. This means the DNS resolving is done 40 // proxy side. 41 SOCKS5ClientSocket(ClientSocketHandle* transport_socket, 42 const HostResolver::RequestInfo& req_info); 43 44 // Deprecated constructor (http://crbug.com/37810) that takes a ClientSocket. 45 SOCKS5ClientSocket(ClientSocket* transport_socket, 46 const HostResolver::RequestInfo& req_info); 47 48 // On destruction Disconnect() is called. 49 virtual ~SOCKS5ClientSocket(); 50 51 // ClientSocket methods: 52 53 // Does the SOCKS handshake and completes the protocol. 54 virtual int Connect(CompletionCallback* callback 55 #ifdef ANDROID 56 , bool wait_for_connect 57 , bool valid_uid 58 , uid_t calling_uid 59 #endif 60 ); 61 virtual void Disconnect(); 62 virtual bool IsConnected() const; 63 virtual bool IsConnectedAndIdle() const; 64 virtual const BoundNetLog& NetLog() const; 65 virtual void SetSubresourceSpeculation(); 66 virtual void SetOmniboxSpeculation(); 67 virtual bool WasEverUsed() const; 68 virtual bool UsingTCPFastOpen() const; 69 70 // Socket methods: 71 virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); 72 virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback); 73 74 virtual bool SetReceiveBufferSize(int32 size); 75 virtual bool SetSendBufferSize(int32 size); 76 77 virtual int GetPeerAddress(AddressList* address) const; 78 virtual int GetLocalAddress(IPEndPoint* address) const; 79 80 private: 81 enum State { 82 STATE_GREET_WRITE, 83 STATE_GREET_WRITE_COMPLETE, 84 STATE_GREET_READ, 85 STATE_GREET_READ_COMPLETE, 86 STATE_HANDSHAKE_WRITE, 87 STATE_HANDSHAKE_WRITE_COMPLETE, 88 STATE_HANDSHAKE_READ, 89 STATE_HANDSHAKE_READ_COMPLETE, 90 STATE_NONE, 91 }; 92 93 // Addressing type that can be specified in requests or responses. 94 enum SocksEndPointAddressType { 95 kEndPointDomain = 0x03, 96 kEndPointResolvedIPv4 = 0x01, 97 kEndPointResolvedIPv6 = 0x04, 98 }; 99 100 static const unsigned int kGreetReadHeaderSize; 101 static const unsigned int kWriteHeaderSize; 102 static const unsigned int kReadHeaderSize; 103 static const uint8 kSOCKS5Version; 104 static const uint8 kTunnelCommand; 105 static const uint8 kNullByte; 106 107 void DoCallback(int result); 108 void OnIOComplete(int result); 109 110 int DoLoop(int last_io_result); 111 int DoHandshakeRead(); 112 int DoHandshakeReadComplete(int result); 113 int DoHandshakeWrite(); 114 int DoHandshakeWriteComplete(int result); 115 int DoGreetRead(); 116 int DoGreetReadComplete(int result); 117 int DoGreetWrite(); 118 int DoGreetWriteComplete(int result); 119 120 // Writes the SOCKS handshake buffer into |handshake| 121 // and return OK on success. 122 int BuildHandshakeWriteBuffer(std::string* handshake) const; 123 124 CompletionCallbackImpl<SOCKS5ClientSocket> io_callback_; 125 126 // Stores the underlying socket. 127 scoped_ptr<ClientSocketHandle> transport_; 128 129 State next_state_; 130 131 // Stores the callback to the layer above, called on completing Connect(). 132 CompletionCallback* user_callback_; 133 134 // This IOBuffer is used by the class to read and write 135 // SOCKS handshake data. The length contains the expected size to 136 // read or write. 137 scoped_refptr<IOBuffer> handshake_buf_; 138 139 // While writing, this buffer stores the complete write handshake data. 140 // While reading, it stores the handshake information received so far. 141 std::string buffer_; 142 143 // This becomes true when the SOCKS handshake has completed and the 144 // overlying connection is free to communicate. 145 bool completed_handshake_; 146 147 // These contain the bytes sent / received by the SOCKS handshake. 148 size_t bytes_sent_; 149 size_t bytes_received_; 150 151 size_t read_header_size; 152 153 HostResolver::RequestInfo host_request_info_; 154 155 BoundNetLog net_log_; 156 157 DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocket); 158 }; 159 160 } // namespace net 161 162 #endif // NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_ 163