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