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