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 21 namespace rtc { 22 23 struct HttpAuthContext; 24 class 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. 31 class 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: DirectSend(const void * pv,size_t cb)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. 59 class 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. 72 class 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". 86 class 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. 98 class 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. SetForceConnect(bool force)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. 144 class 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. 158 class 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. 190 class 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. 218 class 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