1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// Copyright (c) 2011 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_
#pragma once
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "googleurl/src/gurl.h"
#include "net/base/address_list.h"
#include "net/base/completion_callback.h"
#include "net/base/host_resolver.h"
#include "net/base/net_errors.h"
#include "net/base/net_log.h"
#include "net/socket/client_socket.h"
#include "testing/gtest/include/gtest/gtest_prod.h"
namespace net {
class ClientSocketHandle;
class BoundNetLog;
// This ClientSocket is used to setup a SOCKSv5 handshake with a socks proxy.
// Currently no SOCKSv5 authentication is supported.
class SOCKS5ClientSocket : public ClientSocket {
public:
// Takes ownership of the |transport_socket|, which should already be
// connected by the time Connect() is called.
//
// |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(ClientSocketHandle* transport_socket,
const HostResolver::RequestInfo& req_info);
// Deprecated constructor (http://crbug.com/37810) that takes a ClientSocket.
SOCKS5ClientSocket(ClientSocket* transport_socket,
const HostResolver::RequestInfo& req_info);
// On destruction Disconnect() is called.
virtual ~SOCKS5ClientSocket();
// ClientSocket methods:
// Does the SOCKS handshake and completes the protocol.
virtual int Connect(CompletionCallback* callback
#ifdef ANDROID
, bool wait_for_connect
#endif
);
virtual void Disconnect();
virtual bool IsConnected() const;
virtual bool IsConnectedAndIdle() const;
virtual const BoundNetLog& NetLog() const;
virtual void SetSubresourceSpeculation();
virtual void SetOmniboxSpeculation();
virtual bool WasEverUsed() const;
virtual bool UsingTCPFastOpen() const;
// Socket methods:
virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback);
virtual bool SetReceiveBufferSize(int32 size);
virtual bool SetSendBufferSize(int32 size);
virtual int GetPeerAddress(AddressList* address) const;
virtual int GetLocalAddress(IPEndPoint* address) const;
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 kSOCKS5Version;
static const uint8 kTunnelCommand;
static const uint8 kNullByte;
void DoCallback(int result);
void OnIOComplete(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;
CompletionCallbackImpl<SOCKS5ClientSocket> io_callback_;
// Stores the underlying socket.
scoped_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;
HostResolver::RequestInfo host_request_info_;
BoundNetLog net_log_;
DISALLOW_COPY_AND_ASSIGN(SOCKS5ClientSocket);
};
} // namespace net
#endif // NET_SOCKET_SOCKS5_CLIENT_SOCKET_H_
|
