| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_ |
| #define NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <string> |
| |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "net/base/address_list.h" |
| #include "net/base/completion_callback.h" |
| #include "net/base/net_errors.h" |
| #include "net/dns/host_resolver.h" |
| #include "net/log/net_log.h" |
| #include "net/socket/stream_socket.h" |
| #include "url/gurl.h" |
| |
| namespace net { |
| |
| class ClientSocketHandle; |
| class BoundNetLog; |
| |
| // This StreamSocket is used to setup a SOCKSv5 handshake with a socks proxy. |
| // Currently no SOCKSv5 authentication is supported. |
| class NET_EXPORT_PRIVATE SOCKS5ClientSocket : public StreamSocket { |
| public: |
| // |req_info| contains the hostname and port to which the socket above will |
| // communicate to via the SOCKS layer. |
| // |
| // Although SOCKS 5 supports 3 different modes of addressing, we will |
| // always pass it a hostname. This means the DNS resolving is done |
| // proxy side. |
| SOCKS5ClientSocket(std::unique_ptr<ClientSocketHandle> transport_socket, |
| const HostResolver::RequestInfo& req_info); |
| |
| // On destruction Disconnect() is called. |
| ~SOCKS5ClientSocket() override; |
| |
| // StreamSocket implementation. |
| |
| // Does the SOCKS handshake and completes the protocol. |
| int Connect(const CompletionCallback& callback) override; |
| void Disconnect() override; |
| bool IsConnected() const override; |
| bool IsConnectedAndIdle() const override; |
| const BoundNetLog& NetLog() const override; |
| void SetSubresourceSpeculation() override; |
| void SetOmniboxSpeculation() override; |
| bool WasEverUsed() const override; |
| bool WasNpnNegotiated() const override; |
| NextProto GetNegotiatedProtocol() const override; |
| bool GetSSLInfo(SSLInfo* ssl_info) override; |
| void GetConnectionAttempts(ConnectionAttempts* out) const override; |
| void ClearConnectionAttempts() override {} |
| void AddConnectionAttempts(const ConnectionAttempts& attempts) override {} |
| int64_t GetTotalReceivedBytes() const override; |
| |
| // Socket implementation. |
| int Read(IOBuffer* buf, |
| int buf_len, |
| const CompletionCallback& callback) override; |
| int Write(IOBuffer* buf, |
| int buf_len, |
| const CompletionCallback& callback) override; |
| |
| int SetReceiveBufferSize(int32_t size) override; |
| int SetSendBufferSize(int32_t size) override; |
| |
| int GetPeerAddress(IPEndPoint* address) const override; |
| int GetLocalAddress(IPEndPoint* address) const override; |
| |
| private: |
| enum State { |
| STATE_GREET_WRITE, |
| STATE_GREET_WRITE_COMPLETE, |
| STATE_GREET_READ, |
| STATE_GREET_READ_COMPLETE, |
| STATE_HANDSHAKE_WRITE, |
| STATE_HANDSHAKE_WRITE_COMPLETE, |
| STATE_HANDSHAKE_READ, |
| STATE_HANDSHAKE_READ_COMPLETE, |
| STATE_NONE, |
| }; |
| |
| // Addressing type that can be specified in requests or responses. |
| enum SocksEndPointAddressType { |
| kEndPointDomain = 0x03, |
| kEndPointResolvedIPv4 = 0x01, |
| kEndPointResolvedIPv6 = 0x04, |
| }; |
| |
| static const unsigned int kGreetReadHeaderSize; |
| static const unsigned int kWriteHeaderSize; |
| static const unsigned int kReadHeaderSize; |
| static const uint8_t kSOCKS5Version; |
| static const uint8_t kTunnelCommand; |
| static const uint8_t kNullByte; |
| |
| void DoCallback(int result); |
| void OnIOComplete(int result); |
| void OnReadWriteComplete(const CompletionCallback& callback, int result); |
| |
| int DoLoop(int last_io_result); |
| int DoHandshakeRead(); |
| int DoHandshakeReadComplete(int result); |
| int DoHandshakeWrite(); |
| int DoHandshakeWriteComplete(int result); |
| int DoGreetRead(); |
| int DoGreetReadComplete(int result); |
| int DoGreetWrite(); |
| int DoGreetWriteComplete(int result); |
| |
| // Writes the SOCKS handshake buffer into |handshake| |
| // and return OK on success. |
| int BuildHandshakeWriteBuffer(std::string* handshake) const; |
| |
| CompletionCallback io_callback_; |
| |
| // Stores the underlying socket. |
| std::unique_ptr<ClientSocketHandle> transport_; |
| |
| State next_state_; |
| |
| // Stores the callback to the layer above, called on completing Connect(). |
| CompletionCallback user_callback_; |
| |
| // This IOBuffer is used by the class to read and write |
| // SOCKS handshake data. The length contains the expected size to |
| // read or write. |
| scoped_refptr<IOBuffer> handshake_buf_; |
| |
| // While writing, this buffer stores the complete write handshake data. |
| // While reading, it stores the handshake information received so far. |
| std::string buffer_; |
| |
| // This becomes true when the SOCKS handshake has completed and the |
| // overlying connection is free to communicate. |
| bool completed_handshake_; |
| |
| // These contain the bytes sent / received by the SOCKS handshake. |
| size_t bytes_sent_; |
| size_t bytes_received_; |
| |
| size_t read_header_size; |
| |
| bool was_ever_used_; |
| |
| HostResolver::RequestInfo host_request_info_; |
| |
| BoundNetLog net_log_; |
| |
| DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocket); |
| }; |
| |
| } // namespace net |
| |
| #endif // NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_ |