net/socket/socks5_client_socket.h

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