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