src/third_party/libjingle/source/talk/p2p/base/tcpport.h

   1 /*
   2  * libjingle
   3  * Copyright 2004--2005, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifndef WEBRTC_P2P_BASE_TCPPORT_H_
  29 #define WEBRTC_P2P_BASE_TCPPORT_H_
  30
  31 #include <list>
  32 #include <string>
  33 #include "webrtc/p2p/base/port.h"
  34 #include "webrtc/base/asyncpacketsocket.h"
  35
  36 namespace cricket {
  37
  38 class TCPConnection;
  39
  40 // Communicates using a local TCP port.
  41 //
  42 // This class is designed to allow subclasses to take advantage of the
  43 // connection management provided by this class.  A subclass should take of all
  44 // packet sending and preparation, but when a packet is received, it should
  45 // call this TCPPort::OnReadPacket (3 arg) to dispatch to a connection.
  46 class TCPPort : public Port {
  47  public:
  48   static TCPPort* Create(rtc::Thread* thread,
  49                          rtc::PacketSocketFactory* factory,
  50                          rtc::Network* network,
  51                          const rtc::IPAddress& ip,
  52                          int min_port, int max_port,
  53                          const std::string& username,
  54                          const std::string& password,
  55                          bool allow_listen) {
  56     TCPPort* port = new TCPPort(thread, factory, network,
  57                                 ip, min_port, max_port,
  58                                 username, password, allow_listen);
  59     if (!port->Init()) {
  60       delete port;
  61       port = NULL;
  62     }
  63     return port;
  64   }
  65   virtual ~TCPPort();
  66
  67   virtual Connection* CreateConnection(const Candidate& address,
  68                                        CandidateOrigin origin);
  69
  70   virtual void PrepareAddress();
  71
  72   virtual int GetOption(rtc::Socket::Option opt, int* value);
  73   virtual int SetOption(rtc::Socket::Option opt, int value);
  74   virtual int GetError();
  75
  76  protected:
  77   TCPPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
  78           rtc::Network* network, const rtc::IPAddress& ip,
  79           int min_port, int max_port, const std::string& username,
  80           const std::string& password, bool allow_listen);
  81   bool Init();
  82
  83   // Handles sending using the local TCP socket.
  84   virtual int SendTo(const void* data, size_t size,
  85                      const rtc::SocketAddress& addr,
  86                      const rtc::PacketOptions& options,
  87                      bool payload);
  88
  89   // Accepts incoming TCP connection.
  90   void OnNewConnection(rtc::AsyncPacketSocket* socket,
  91                        rtc::AsyncPacketSocket* new_socket);
  92
  93  private:
  94   struct Incoming {
  95     rtc::SocketAddress addr;
  96     rtc::AsyncPacketSocket* socket;
  97   };
  98
  99   rtc::AsyncPacketSocket* GetIncoming(
 100       const rtc::SocketAddress& addr, bool remove = false);
 101
 102   // Receives packet signal from the local TCP Socket.
 103   void OnReadPacket(rtc::AsyncPacketSocket* socket,
 104                     const char* data, size_t size,
 105                     const rtc::SocketAddress& remote_addr,
 106                     const rtc::PacketTime& packet_time);
 107
 108   void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 109
 110   void OnAddressReady(rtc::AsyncPacketSocket* socket,
 111                       const rtc::SocketAddress& address);
 112
 113   // TODO: Is this still needed?
 114   bool incoming_only_;
 115   bool allow_listen_;
 116   rtc::AsyncPacketSocket* socket_;
 117   int error_;
 118   std::list<Incoming> incoming_;
 119
 120   friend class TCPConnection;
 121 };
 122
 123 class TCPConnection : public Connection {
 124  public:
 125   // Connection is outgoing unless socket is specified
 126   TCPConnection(TCPPort* port, const Candidate& candidate,
 127                 rtc::AsyncPacketSocket* socket = 0);
 128   virtual ~TCPConnection();
 129
 130   virtual int Send(const void* data, size_t size,
 131                    const rtc::PacketOptions& options);
 132   virtual int GetError();
 133
 134   rtc::AsyncPacketSocket* socket() { return socket_; }
 135
 136  private:
 137   void OnConnect(rtc::AsyncPacketSocket* socket);
 138   void OnClose(rtc::AsyncPacketSocket* socket, int error);
 139   void OnReadPacket(rtc::AsyncPacketSocket* socket,
 140                     const char* data, size_t size,
 141                     const rtc::SocketAddress& remote_addr,
 142                     const rtc::PacketTime& packet_time);
 143   void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 144
 145   rtc::AsyncPacketSocket* socket_;
 146   int error_;
 147
 148   friend class TCPPort;
 149 };
 150
 151 }  // namespace cricket
 152
 153 #endif  // WEBRTC_P2P_BASE_TCPPORT_H_