1/*
2 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#ifndef WEBRTC_BASE_SOCKETADAPTERS_H_
12#define WEBRTC_BASE_SOCKETADAPTERS_H_
13
14#include <map>
15#include <string>
16
17#include "webrtc/base/asyncsocket.h"
18#include "webrtc/base/cryptstring.h"
19#include "webrtc/base/logging.h"
20
21namespace rtc {
22
23struct HttpAuthContext;
24class ByteBuffer;
25
26///////////////////////////////////////////////////////////////////////////////
27
28// Implements a socket adapter that can buffer and process data internally,
29// as in the case of connecting to a proxy, where you must speak the proxy
30// protocol before commencing normal socket behavior.
31class BufferedReadAdapter : public AsyncSocketAdapter {
32 public:
33  BufferedReadAdapter(AsyncSocket* socket, size_t buffer_size);
34  ~BufferedReadAdapter() override;
35
36  int Send(const void* pv, size_t cb) override;
37  int Recv(void* pv, size_t cb) override;
38
39 protected:
40  int DirectSend(const void* pv, size_t cb) {
41    return AsyncSocketAdapter::Send(pv, cb);
42  }
43
44  void BufferInput(bool on = true);
45  virtual void ProcessInput(char* data, size_t* len) = 0;
46
47  void OnReadEvent(AsyncSocket* socket) override;
48
49 private:
50  char * buffer_;
51  size_t buffer_size_, data_len_;
52  bool buffering_;
53  RTC_DISALLOW_COPY_AND_ASSIGN(BufferedReadAdapter);
54};
55
56///////////////////////////////////////////////////////////////////////////////
57
58// Interface for implementing proxy server sockets.
59class AsyncProxyServerSocket : public BufferedReadAdapter {
60 public:
61  AsyncProxyServerSocket(AsyncSocket* socket, size_t buffer_size);
62  ~AsyncProxyServerSocket() override;
63  sigslot::signal2<AsyncProxyServerSocket*,
64                   const SocketAddress&>  SignalConnectRequest;
65  virtual void SendConnectResult(int err, const SocketAddress& addr) = 0;
66};
67
68///////////////////////////////////////////////////////////////////////////////
69
70// Implements a socket adapter that performs the client side of a
71// fake SSL handshake. Used for "ssltcp" P2P functionality.
72class AsyncSSLSocket : public BufferedReadAdapter {
73 public:
74  explicit AsyncSSLSocket(AsyncSocket* socket);
75
76  int Connect(const SocketAddress& addr) override;
77
78 protected:
79  void OnConnectEvent(AsyncSocket* socket) override;
80  void ProcessInput(char* data, size_t* len) override;
81  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket);
82};
83
84// Implements a socket adapter that performs the server side of a
85// fake SSL handshake. Used when implementing a relay server that does "ssltcp".
86class AsyncSSLServerSocket : public BufferedReadAdapter {
87 public:
88  explicit AsyncSSLServerSocket(AsyncSocket* socket);
89
90 protected:
91  void ProcessInput(char* data, size_t* len) override;
92  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLServerSocket);
93};
94
95///////////////////////////////////////////////////////////////////////////////
96
97// Implements a socket adapter that speaks the HTTP/S proxy protocol.
98class AsyncHttpsProxySocket : public BufferedReadAdapter {
99 public:
100  AsyncHttpsProxySocket(AsyncSocket* socket, const std::string& user_agent,
101    const SocketAddress& proxy,
102    const std::string& username, const CryptString& password);
103  ~AsyncHttpsProxySocket() override;
104
105  // If connect is forced, the adapter will always issue an HTTP CONNECT to the
106  // target address.  Otherwise, it will connect only if the destination port
107  // is not port 80.
108  void SetForceConnect(bool force) { force_connect_ = force; }
109
110  int Connect(const SocketAddress& addr) override;
111  SocketAddress GetRemoteAddress() const override;
112  int Close() override;
113  ConnState GetState() const override;
114
115 protected:
116  void OnConnectEvent(AsyncSocket* socket) override;
117  void OnCloseEvent(AsyncSocket* socket, int err) override;
118  void ProcessInput(char* data, size_t* len) override;
119
120  bool ShouldIssueConnect() const;
121  void SendRequest();
122  void ProcessLine(char* data, size_t len);
123  void EndResponse();
124  void Error(int error);
125
126 private:
127  SocketAddress proxy_, dest_;
128  std::string agent_, user_, headers_;
129  CryptString pass_;
130  bool force_connect_;
131  size_t content_length_;
132  int defer_error_;
133  bool expect_close_;
134  enum ProxyState {
135    PS_INIT, PS_LEADER, PS_AUTHENTICATE, PS_SKIP_HEADERS, PS_ERROR_HEADERS,
136    PS_TUNNEL_HEADERS, PS_SKIP_BODY, PS_TUNNEL, PS_WAIT_CLOSE, PS_ERROR
137  } state_;
138  HttpAuthContext * context_;
139  std::string unknown_mechanisms_;
140  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxySocket);
141};
142
143/* TODO: Implement this.
144class AsyncHttpsProxyServerSocket : public AsyncProxyServerSocket {
145 public:
146  explicit AsyncHttpsProxyServerSocket(AsyncSocket* socket);
147
148 private:
149  virtual void ProcessInput(char * data, size_t& len);
150  void Error(int error);
151  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxyServerSocket);
152};
153*/
154
155///////////////////////////////////////////////////////////////////////////////
156
157// Implements a socket adapter that speaks the SOCKS proxy protocol.
158class AsyncSocksProxySocket : public BufferedReadAdapter {
159 public:
160  AsyncSocksProxySocket(AsyncSocket* socket, const SocketAddress& proxy,
161    const std::string& username, const CryptString& password);
162  ~AsyncSocksProxySocket() override;
163
164  int Connect(const SocketAddress& addr) override;
165  SocketAddress GetRemoteAddress() const override;
166  int Close() override;
167  ConnState GetState() const override;
168
169 protected:
170  void OnConnectEvent(AsyncSocket* socket) override;
171  void ProcessInput(char* data, size_t* len) override;
172
173  void SendHello();
174  void SendConnect();
175  void SendAuth();
176  void Error(int error);
177
178 private:
179  enum State {
180    SS_INIT, SS_HELLO, SS_AUTH, SS_CONNECT, SS_TUNNEL, SS_ERROR
181  };
182  State state_;
183  SocketAddress proxy_, dest_;
184  std::string user_;
185  CryptString pass_;
186  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxySocket);
187};
188
189// Implements a proxy server socket for the SOCKS protocol.
190class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket {
191 public:
192  explicit AsyncSocksProxyServerSocket(AsyncSocket* socket);
193
194 private:
195  void ProcessInput(char* data, size_t* len) override;
196  void DirectSend(const ByteBuffer& buf);
197
198  void HandleHello(ByteBuffer* request);
199  void SendHelloReply(uint8_t method);
200  void HandleAuth(ByteBuffer* request);
201  void SendAuthReply(uint8_t result);
202  void HandleConnect(ByteBuffer* request);
203  void SendConnectResult(int result, const SocketAddress& addr) override;
204
205  void Error(int error);
206
207  static const int kBufferSize = 1024;
208  enum State {
209    SS_HELLO, SS_AUTH, SS_CONNECT, SS_CONNECT_PENDING, SS_TUNNEL, SS_ERROR
210  };
211  State state_;
212  RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxyServerSocket);
213};
214
215///////////////////////////////////////////////////////////////////////////////
216
217// Implements a socket adapter that logs everything that it sends and receives.
218class LoggingSocketAdapter : public AsyncSocketAdapter {
219 public:
220  LoggingSocketAdapter(AsyncSocket* socket, LoggingSeverity level,
221                 const char * label, bool hex_mode = false);
222
223  int Send(const void* pv, size_t cb) override;
224  int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
225  int Recv(void* pv, size_t cb) override;
226  int RecvFrom(void* pv, size_t cb, SocketAddress* paddr) override;
227  int Close() override;
228
229 protected:
230  void OnConnectEvent(AsyncSocket* socket) override;
231  void OnCloseEvent(AsyncSocket* socket, int err) override;
232
233 private:
234  LoggingSeverity level_;
235  std::string label_;
236  bool hex_mode_;
237  LogMultilineState lms_;
238  RTC_DISALLOW_COPY_AND_ASSIGN(LoggingSocketAdapter);
239};
240
241///////////////////////////////////////////////////////////////////////////////
242
243}  // namespace rtc
244
245#endif  // WEBRTC_BASE_SOCKETADAPTERS_H_
246