src/third_party/webrtc/base/socketadapters.h

   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   virtual ~BufferedReadAdapter();
  35
  36   virtual int Send(const void* pv, size_t cb);
  37   virtual int Recv(void* pv, size_t cb);
  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   virtual void OnReadEvent(AsyncSocket * socket);
  48
  49  private:
  50   char * buffer_;
  51   size_t buffer_size_, data_len_;
  52   bool buffering_;
  53   DISALLOW_EVIL_CONSTRUCTORS(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       : BufferedReadAdapter(socket, buffer_size) {}
  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   virtual int Connect(const SocketAddress& addr);
  77
  78  protected:
  79   virtual void OnConnectEvent(AsyncSocket* socket);
  80   virtual void ProcessInput(char* data, size_t* len);
  81   DISALLOW_EVIL_CONSTRUCTORS(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   virtual void ProcessInput(char* data, size_t* len);
  92   DISALLOW_EVIL_CONSTRUCTORS(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   virtual ~AsyncHttpsProxySocket();
 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   virtual int Connect(const SocketAddress& addr);
 111   virtual SocketAddress GetRemoteAddress() const;
 112   virtual int Close();
 113   virtual ConnState GetState() const;
 114
 115  protected:
 116   virtual void OnConnectEvent(AsyncSocket* socket);
 117   virtual void OnCloseEvent(AsyncSocket* socket, int err);
 118   virtual void ProcessInput(char* data, size_t* len);
 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   DISALLOW_EVIL_CONSTRUCTORS(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   DISALLOW_EVIL_CONSTRUCTORS(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
 163   virtual int Connect(const SocketAddress& addr);
 164   virtual SocketAddress GetRemoteAddress() const;
 165   virtual int Close();
 166   virtual ConnState GetState() const;
 167
 168  protected:
 169   virtual void OnConnectEvent(AsyncSocket* socket);
 170   virtual void ProcessInput(char* data, size_t* len);
 171
 172   void SendHello();
 173   void SendConnect();
 174   void SendAuth();
 175   void Error(int error);
 176
 177  private:
 178   enum State {
 179     SS_INIT, SS_HELLO, SS_AUTH, SS_CONNECT, SS_TUNNEL, SS_ERROR
 180   };
 181   State state_;
 182   SocketAddress proxy_, dest_;
 183   std::string user_;
 184   CryptString pass_;
 185   DISALLOW_EVIL_CONSTRUCTORS(AsyncSocksProxySocket);
 186 };
 187
 188 // Implements a proxy server socket for the SOCKS protocol.
 189 class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket {
 190  public:
 191   explicit AsyncSocksProxyServerSocket(AsyncSocket* socket);
 192
 193  private:
 194   virtual void ProcessInput(char* data, size_t* len);
 195   void DirectSend(const ByteBuffer& buf);
 196
 197   void HandleHello(ByteBuffer* request);
 198   void SendHelloReply(uint8 method);
 199   void HandleAuth(ByteBuffer* request);
 200   void SendAuthReply(uint8 result);
 201   void HandleConnect(ByteBuffer* request);
 202   virtual void SendConnectResult(int result, const SocketAddress& addr);
 203
 204   void Error(int error);
 205
 206   static const int kBufferSize = 1024;
 207   enum State {
 208     SS_HELLO, SS_AUTH, SS_CONNECT, SS_CONNECT_PENDING, SS_TUNNEL, SS_ERROR
 209   };
 210   State state_;
 211   DISALLOW_EVIL_CONSTRUCTORS(AsyncSocksProxyServerSocket);
 212 };
 213
 214 ///////////////////////////////////////////////////////////////////////////////
 215
 216 // Implements a socket adapter that logs everything that it sends and receives.
 217 class LoggingSocketAdapter : public AsyncSocketAdapter {
 218  public:
 219   LoggingSocketAdapter(AsyncSocket* socket, LoggingSeverity level,
 220                  const char * label, bool hex_mode = false);
 221
 222   virtual int Send(const void *pv, size_t cb);
 223   virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr);
 224   virtual int Recv(void *pv, size_t cb);
 225   virtual int RecvFrom(void *pv, size_t cb, SocketAddress *paddr);
 226   virtual int Close();
 227
 228  protected:
 229   virtual void OnConnectEvent(AsyncSocket * socket);
 230   virtual void OnCloseEvent(AsyncSocket * socket, int err);
 231
 232  private:
 233   LoggingSeverity level_;
 234   std::string label_;
 235   bool hex_mode_;
 236   LogMultilineState lms_;
 237   DISALLOW_EVIL_CONSTRUCTORS(LoggingSocketAdapter);
 238 };
 239
 240 ///////////////////////////////////////////////////////////////////////////////
 241
 242 }  // namespace rtc
 243
 244 #endif  // WEBRTC_BASE_SOCKETADAPTERS_H_