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   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(int method);
    199   void HandleAuth(ByteBuffer* request);
    200   void SendAuthReply(int 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_
    245