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
35namespace cricket {
36// Some ERRNO values get re-#defined to WSA* equivalents in some talk/
37// headers.  We save the original ones in an enum.
38enum 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"
51struct sockaddr_conn;
52struct sctp_assoc_change;
53struct sctp_stream_reset_event;
54// Defined by <sys/socket.h>
55struct socket;
56namespace cricket {
57// The highest stream ID (Sid) that SCTP allows, and the number of streams we
58// tell SCTP we're going to use.
59const 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)
65const 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]
91class 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.
107struct SctpInboundPacket;
108
109class 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 SetStartSendBandwidth(int bps) { return true; }
176  virtual bool SetMaxSendBandwidth(int bps) { return true; }
177  virtual bool SetRecvRtpHeaderExtensions(
178      const std::vector<RtpHeaderExtension>& extensions) { return true; }
179  virtual bool SetSendRtpHeaderExtensions(
180      const std::vector<RtpHeaderExtension>& extensions) { return true; }
181  virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs);
182  virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
183  virtual void OnRtcpReceived(rtc::Buffer* packet,
184                              const rtc::PacketTime& packet_time) {}
185  virtual void OnReadyToSend(bool ready) {}
186
187  // Helper for debugging.
188  void set_debug_name(const std::string& debug_name) {
189    debug_name_ = debug_name;
190  }
191  const std::string& debug_name() const { return debug_name_; }
192
193 private:
194  sockaddr_conn GetSctpSockAddr(int port);
195
196  // Creates the socket and connects. Sets sending_ to true.
197  bool Connect();
198  // Closes the socket. Sets sending_ to false.
199  void Disconnect();
200
201  // Returns false when openning the socket failed; when successfull sets
202  // sending_ to true
203  bool OpenSctpSocket();
204  // Sets sending_ to false and sock_ to NULL.
205  void CloseSctpSocket();
206
207  // Sends a SCTP_RESET_STREAM for all streams in closing_ssids_.
208  bool SendQueuedStreamResets();
209
210  // Adds a stream.
211  bool AddStream(const StreamParams &sp);
212  // Queues a stream for reset.
213  bool ResetStream(uint32 ssrc);
214
215  // Called by OnMessage to send packet on the network.
216  void OnPacketFromSctpToNetwork(rtc::Buffer* buffer);
217  // Called by OnMessage to decide what to do with the packet.
218  void OnInboundPacketFromSctpToChannel(SctpInboundPacket* packet);
219  void OnDataFromSctpToChannel(const ReceiveDataParams& params,
220                               rtc::Buffer* buffer);
221  void OnNotificationFromSctp(rtc::Buffer* buffer);
222  void OnNotificationAssocChange(const sctp_assoc_change& change);
223
224  void OnStreamResetEvent(const struct sctp_stream_reset_event* evt);
225
226  // Responsible for marshalling incoming data to the channels listeners, and
227  // outgoing data to the network interface.
228  rtc::Thread* worker_thread_;
229  // The local and remote SCTP port to use. These are passed along the wire
230  // and the listener and connector must be using the same port. It is not
231  // related to the ports at the IP level.  If set to -1, we default to
232  // kSctpDefaultPort.
233  int local_port_;
234  int remote_port_;
235  struct socket* sock_;  // The socket created by usrsctp_socket(...).
236
237  // sending_ is true iff there is a connected socket.
238  bool sending_;
239  // receiving_ controls whether inbound packets are thrown away.
240  bool receiving_;
241
242  // When a data channel opens a stream, it goes into open_streams_.  When we
243  // want to close it, the stream's ID goes into queued_reset_streams_.  When
244  // we actually transmit a RE-CONFIG chunk with that stream ID, the ID goes
245  // into sent_reset_streams_.  When we get a response RE-CONFIG chunk back
246  // acknowledging the reset, we remove the stream ID from
247  // sent_reset_streams_.  We use sent_reset_streams_ to differentiate
248  // between acknowledgment RE-CONFIG and peer-initiated RE-CONFIGs.
249  StreamSet open_streams_;
250  StreamSet queued_reset_streams_;
251  StreamSet sent_reset_streams_;
252
253  // A human-readable name for debugging messages.
254  std::string debug_name_;
255};
256
257}  // namespace cricket
258
259#endif  // TALK_MEDIA_SCTP_SCTPDATAENGINE_H_
260