Home | History | Annotate | Download | only in base 
      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:
     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.
    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