src/third_party/libjingle/source/talk/media/sctp/sctpdataengine.h

   1 /*
   2  * libjingle SCTP
   3  * Copyright 2012 Google Inc, and Robin Seggelmann
   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 TALK_MEDIA_SCTP_SCTPDATAENGINE_H_
  29 #define TALK_MEDIA_SCTP_SCTPDATAENGINE_H_
  30
  31 #include <errno.h>
  32 #include <string>
  33 #include <vector>
  34
  35 namespace cricket {
  36 // Some ERRNO values get re-#defined to WSA* equivalents in some talk/
  37 // headers.  We save the original ones in an enum.
  38 enum PreservedErrno {
  39   SCTP_EINPROGRESS = EINPROGRESS,
  40   SCTP_EWOULDBLOCK = EWOULDBLOCK
  41 };
  42 }  // namespace cricket
  43
  44 #include "talk/media/base/codec.h"
  45 #include "talk/media/base/mediachannel.h"
  46 #include "talk/media/base/mediaengine.h"
  47 #include "webrtc/base/buffer.h"
  48 #include "webrtc/base/scoped_ptr.h"
  49
  50 // Defined by "usrsctplib/usrsctp.h"
  51 struct sockaddr_conn;
  52 struct sctp_assoc_change;
  53 struct sctp_stream_reset_event;
  54 // Defined by <sys/socket.h>
  55 struct socket;
  56 namespace cricket {
  57 // The highest stream ID (Sid) that SCTP allows, and the number of streams we
  58 // tell SCTP we're going to use.
  59 const uint32 kMaxSctpSid = 1023;
  60
  61 // This is the default SCTP port to use. It is passed along the wire and the
  62 // connectee and connector must be using the same port. It is not related to the
  63 // ports at the IP level. (Corresponds to: sockaddr_conn.sconn_port in
  64 // usrsctp.h)
  65 const int kSctpDefaultPort = 5000;
  66
  67 // A DataEngine that interacts with usrsctp.
  68 //
  69 // From channel calls, data flows like this:
  70 // [worker thread (although it can in princple be another thread)]
  71 //  1.  SctpDataMediaChannel::SendData(data)
  72 //  2.  usrsctp_sendv(data)
  73 // [worker thread returns; sctp thread then calls the following]
  74 //  3.  OnSctpOutboundPacket(wrapped_data)
  75 // [sctp thread returns having posted a message for the worker thread]
  76 //  4.  SctpDataMediaChannel::OnMessage(wrapped_data)
  77 //  5.  SctpDataMediaChannel::OnPacketFromSctpToNetwork(wrapped_data)
  78 //  6.  NetworkInterface::SendPacket(wrapped_data)
  79 //  7.  ... across network ... a packet is sent back ...
  80 //  8.  SctpDataMediaChannel::OnPacketReceived(wrapped_data)
  81 //  9.  usrsctp_conninput(wrapped_data)
  82 // [worker thread returns; sctp thread then calls the following]
  83 //  10.  OnSctpInboundData(data)
  84 // [sctp thread returns having posted a message fot the worker thread]
  85 //  11. SctpDataMediaChannel::OnMessage(inboundpacket)
  86 //  12. SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(inboundpacket)
  87 //  13. SctpDataMediaChannel::OnDataFromSctpToChannel(data)
  88 //  14. SctpDataMediaChannel::SignalDataReceived(data)
  89 // [from the same thread, methods registered/connected to
  90 //  SctpDataMediaChannel are called with the recieved data]
  91 class SctpDataEngine : public DataEngineInterface {
  92  public:
  93   SctpDataEngine();
  94   virtual ~SctpDataEngine();
  95
  96   virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type);
  97
  98   virtual const std::vector<DataCodec>& data_codecs() { return codecs_; }
  99
 100  private:
 101   static int usrsctp_engines_count;
 102   std::vector<DataCodec> codecs_;
 103 };
 104
 105 // TODO(ldixon): Make into a special type of TypedMessageData.
 106 // Holds data to be passed on to a channel.
 107 struct SctpInboundPacket;
 108
 109 class SctpDataMediaChannel : public DataMediaChannel,
 110                              public rtc::MessageHandler {
 111  public:
 112   // DataMessageType is used for the SCTP "Payload Protocol Identifier", as
 113   // defined in http://tools.ietf.org/html/rfc4960#section-14.4
 114   //
 115   // For the list of IANA approved values see:
 116   // http://www.iana.org/assignments/sctp-parameters/sctp-parameters.xml
 117   // The value is not used by SCTP itself. It indicates the protocol running
 118   // on top of SCTP.
 119   enum PayloadProtocolIdentifier {
 120     PPID_NONE = 0,  // No protocol is specified.
 121     // Matches the PPIDs in mozilla source and
 122     // https://datatracker.ietf.org/doc/draft-ietf-rtcweb-data-protocol Sec. 9
 123     // They're not yet assigned by IANA.
 124     PPID_CONTROL = 50,
 125     PPID_BINARY_PARTIAL = 52,
 126     PPID_BINARY_LAST = 53,
 127     PPID_TEXT_PARTIAL = 54,
 128     PPID_TEXT_LAST = 51
 129   };
 130
 131   typedef std::set<uint32> StreamSet;
 132
 133   // Given a thread which will be used to post messages (received data) to this
 134   // SctpDataMediaChannel instance.
 135   explicit SctpDataMediaChannel(rtc::Thread* thread);
 136   virtual ~SctpDataMediaChannel();
 137
 138   // When SetSend is set to true, connects. When set to false, disconnects.
 139   // Calling: "SetSend(true); SetSend(false); SetSend(true);" will connect,
 140   // disconnect, and reconnect.
 141   virtual bool SetSend(bool send);
 142   // Unless SetReceive(true) is called, received packets will be discarded.
 143   virtual bool SetReceive(bool receive);
 144
 145   virtual bool AddSendStream(const StreamParams& sp);
 146   virtual bool RemoveSendStream(uint32 ssrc);
 147   virtual bool AddRecvStream(const StreamParams& sp);
 148   virtual bool RemoveRecvStream(uint32 ssrc);
 149
 150   // Called when Sctp gets data. The data may be a notification or data for
 151   // OnSctpInboundData. Called from the worker thread.
 152   virtual void OnMessage(rtc::Message* msg);
 153   // Send data down this channel (will be wrapped as SCTP packets then given to
 154   // sctp that will then post the network interface by OnMessage).
 155   // Returns true iff successful data somewhere on the send-queue/network.
 156   virtual bool SendData(const SendDataParams& params,
 157                         const rtc::Buffer& payload,
 158                         SendDataResult* result = NULL);
 159   // A packet is received from the network interface. Posted to OnMessage.
 160   virtual void OnPacketReceived(rtc::Buffer* packet,
 161                                 const rtc::PacketTime& packet_time);
 162
 163   // Exposed to allow Post call from c-callbacks.
 164   rtc::Thread* worker_thread() const { return worker_thread_; }
 165
 166   // TODO(ldixon): add a DataOptions class to mediachannel.h
 167   virtual bool SetOptions(int options) { return false; }
 168   virtual int GetOptions() const { return 0; }
 169
 170   // Many of these things are unused by SCTP, but are needed to fulfill
 171   // the MediaChannel interface.
 172   // TODO(pthatcher): Cleanup MediaChannel interface, or at least
 173   // don't try calling these and return false.  Right now, things
 174   // don't work if we return false.
 175   virtual bool SetMaxSendBandwidth(int bps) { return true; }
 176   virtual bool SetRecvRtpHeaderExtensions(
 177       const std::vector<RtpHeaderExtension>& extensions) { return true; }
 178   virtual bool SetSendRtpHeaderExtensions(
 179       const std::vector<RtpHeaderExtension>& extensions) { return true; }
 180   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs);
 181   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
 182   virtual void OnRtcpReceived(rtc::Buffer* packet,
 183                               const rtc::PacketTime& packet_time) {}
 184   virtual void OnReadyToSend(bool ready) {}
 185
 186   // Helper for debugging.
 187   void set_debug_name(const std::string& debug_name) {
 188     debug_name_ = debug_name;
 189   }
 190   const std::string& debug_name() const { return debug_name_; }
 191
 192  private:
 193   sockaddr_conn GetSctpSockAddr(int port);
 194
 195   // Creates the socket and connects. Sets sending_ to true.
 196   bool Connect();
 197   // Closes the socket. Sets sending_ to false.
 198   void Disconnect();
 199
 200   // Returns false when openning the socket failed; when successfull sets
 201   // sending_ to true
 202   bool OpenSctpSocket();
 203   // Sets sending_ to false and sock_ to NULL.
 204   void CloseSctpSocket();
 205
 206   // Sends a SCTP_RESET_STREAM for all streams in closing_ssids_.
 207   bool SendQueuedStreamResets();
 208
 209   // Adds a stream.
 210   bool AddStream(const StreamParams &sp);
 211   // Queues a stream for reset.
 212   bool ResetStream(uint32 ssrc);
 213
 214   // Called by OnMessage to send packet on the network.
 215   void OnPacketFromSctpToNetwork(rtc::Buffer* buffer);
 216   // Called by OnMessage to decide what to do with the packet.
 217   void OnInboundPacketFromSctpToChannel(SctpInboundPacket* packet);
 218   void OnDataFromSctpToChannel(const ReceiveDataParams& params,
 219                                rtc::Buffer* buffer);
 220   void OnNotificationFromSctp(rtc::Buffer* buffer);
 221   void OnNotificationAssocChange(const sctp_assoc_change& change);
 222
 223   void OnStreamResetEvent(const struct sctp_stream_reset_event* evt);
 224
 225   // Responsible for marshalling incoming data to the channels listeners, and
 226   // outgoing data to the network interface.
 227   rtc::Thread* worker_thread_;
 228   // The local and remote SCTP port to use. These are passed along the wire
 229   // and the listener and connector must be using the same port. It is not
 230   // related to the ports at the IP level.  If set to -1, we default to
 231   // kSctpDefaultPort.
 232   int local_port_;
 233   int remote_port_;
 234   struct socket* sock_;  // The socket created by usrsctp_socket(...).
 235
 236   // sending_ is true iff there is a connected socket.
 237   bool sending_;
 238   // receiving_ controls whether inbound packets are thrown away.
 239   bool receiving_;
 240
 241   // When a data channel opens a stream, it goes into open_streams_.  When we
 242   // want to close it, the stream's ID goes into queued_reset_streams_.  When
 243   // we actually transmit a RE-CONFIG chunk with that stream ID, the ID goes
 244   // into sent_reset_streams_.  When we get a response RE-CONFIG chunk back
 245   // acknowledging the reset, we remove the stream ID from
 246   // sent_reset_streams_.  We use sent_reset_streams_ to differentiate
 247   // between acknowledgment RE-CONFIG and peer-initiated RE-CONFIGs.
 248   StreamSet open_streams_;
 249   StreamSet queued_reset_streams_;
 250   StreamSet sent_reset_streams_;
 251
 252   // A human-readable name for debugging messages.
 253   std::string debug_name_;
 254 };
 255
 256 }  // namespace cricket
 257
 258 #endif  // TALK_MEDIA_SCTP_SCTPDATAENGINE_H_