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