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#include "talk/media/sctp/sctpdataengine.h"
29
30#include <stdarg.h>
31#include <stdio.h>
32#include <sstream>
33#include <vector>
34
35#include "talk/media/base/codec.h"
36#include "talk/media/base/constants.h"
37#include "talk/media/base/streamparams.h"
38#include "usrsctplib/usrsctp.h"
39#include "webrtc/base/buffer.h"
40#include "webrtc/base/helpers.h"
41#include "webrtc/base/logging.h"
42#include "webrtc/base/safe_conversions.h"
43
44namespace {
45typedef cricket::SctpDataMediaChannel::StreamSet StreamSet;
46// Returns a comma-separated, human-readable list of the stream IDs in 's'
47std::string ListStreams(const StreamSet& s) {
48  std::stringstream result;
49  bool first = true;
50  for (StreamSet::const_iterator it = s.begin(); it != s.end(); ++it) {
51    if (!first) {
52      result << ", " << *it;
53    } else {
54      result << *it;
55      first = false;
56    }
57  }
58  return result.str();
59}
60
61// Returns a pipe-separated, human-readable list of the SCTP_STREAM_RESET
62// flags in 'flags'
63std::string ListFlags(int flags) {
64  std::stringstream result;
65  bool first = true;
66  // Skip past the first 12 chars (strlen("SCTP_STREAM_"))
67#define MAKEFLAG(X) { X, #X + 12}
68  struct flaginfo_t {
69    int value;
70    const char* name;
71  } flaginfo[] = {
72    MAKEFLAG(SCTP_STREAM_RESET_INCOMING_SSN),
73    MAKEFLAG(SCTP_STREAM_RESET_OUTGOING_SSN),
74    MAKEFLAG(SCTP_STREAM_RESET_DENIED),
75    MAKEFLAG(SCTP_STREAM_RESET_FAILED),
76    MAKEFLAG(SCTP_STREAM_CHANGE_DENIED)
77  };
78#undef MAKEFLAG
79  for (int i = 0; i < ARRAY_SIZE(flaginfo); ++i) {
80    if (flags & flaginfo[i].value) {
81      if (!first) result << " | ";
82      result << flaginfo[i].name;
83      first = false;
84    }
85  }
86  return result.str();
87}
88
89// Returns a comma-separated, human-readable list of the integers in 'array'.
90// All 'num_elems' of them.
91std::string ListArray(const uint16* array, int num_elems) {
92  std::stringstream result;
93  for (int i = 0; i < num_elems; ++i) {
94    if (i) {
95      result << ", " << array[i];
96    } else {
97      result << array[i];
98    }
99  }
100  return result.str();
101}
102}  // namespace
103
104namespace cricket {
105typedef rtc::ScopedMessageData<SctpInboundPacket> InboundPacketMessage;
106typedef rtc::ScopedMessageData<rtc::Buffer> OutboundPacketMessage;
107
108// The biggest SCTP packet.  Starting from a 'safe' wire MTU value of 1280,
109// take off 80 bytes for DTLS/TURN/TCP/IP overhead.
110static const size_t kSctpMtu = 1200;
111
112enum {
113  MSG_SCTPINBOUNDPACKET = 1,   // MessageData is SctpInboundPacket
114  MSG_SCTPOUTBOUNDPACKET = 2,  // MessageData is rtc:Buffer
115};
116
117struct SctpInboundPacket {
118  rtc::Buffer buffer;
119  ReceiveDataParams params;
120  // The |flags| parameter is used by SCTP to distinguish notification packets
121  // from other types of packets.
122  int flags;
123};
124
125// Helper for logging SCTP messages.
126static void debug_sctp_printf(const char *format, ...) {
127  char s[255];
128  va_list ap;
129  va_start(ap, format);
130  vsnprintf(s, sizeof(s), format, ap);
131  LOG(LS_INFO) << "SCTP: " << s;
132  va_end(ap);
133}
134
135// Get the PPID to use for the terminating fragment of this type.
136static SctpDataMediaChannel::PayloadProtocolIdentifier GetPpid(
137    cricket::DataMessageType type) {
138  switch (type) {
139  default:
140  case cricket::DMT_NONE:
141    return SctpDataMediaChannel::PPID_NONE;
142  case cricket::DMT_CONTROL:
143    return SctpDataMediaChannel::PPID_CONTROL;
144  case cricket::DMT_BINARY:
145    return SctpDataMediaChannel::PPID_BINARY_LAST;
146  case cricket::DMT_TEXT:
147    return SctpDataMediaChannel::PPID_TEXT_LAST;
148  };
149}
150
151static bool GetDataMediaType(
152    SctpDataMediaChannel::PayloadProtocolIdentifier ppid,
153    cricket::DataMessageType *dest) {
154  ASSERT(dest != NULL);
155  switch (ppid) {
156    case SctpDataMediaChannel::PPID_BINARY_PARTIAL:
157    case SctpDataMediaChannel::PPID_BINARY_LAST:
158      *dest = cricket::DMT_BINARY;
159      return true;
160
161    case SctpDataMediaChannel::PPID_TEXT_PARTIAL:
162    case SctpDataMediaChannel::PPID_TEXT_LAST:
163      *dest = cricket::DMT_TEXT;
164      return true;
165
166    case SctpDataMediaChannel::PPID_CONTROL:
167      *dest = cricket::DMT_CONTROL;
168      return true;
169
170    case SctpDataMediaChannel::PPID_NONE:
171      *dest = cricket::DMT_NONE;
172      return true;
173
174    default:
175      return false;
176  }
177}
178
179// This is the callback usrsctp uses when there's data to send on the network
180// that has been wrapped appropriatly for the SCTP protocol.
181static int OnSctpOutboundPacket(void* addr, void* data, size_t length,
182                                uint8_t tos, uint8_t set_df) {
183  SctpDataMediaChannel* channel = static_cast<SctpDataMediaChannel*>(addr);
184  LOG(LS_VERBOSE) << "global OnSctpOutboundPacket():"
185                  << "addr: " << addr << "; length: " << length
186                  << "; tos: " << std::hex << static_cast<int>(tos)
187                  << "; set_df: " << std::hex << static_cast<int>(set_df);
188  // Note: We have to copy the data; the caller will delete it.
189  OutboundPacketMessage* msg =
190      new OutboundPacketMessage(new rtc::Buffer(data, length));
191  channel->worker_thread()->Post(channel, MSG_SCTPOUTBOUNDPACKET, msg);
192  return 0;
193}
194
195// This is the callback called from usrsctp when data has been received, after
196// a packet has been interpreted and parsed by usrsctp and found to contain
197// payload data. It is called by a usrsctp thread. It is assumed this function
198// will free the memory used by 'data'.
199static int OnSctpInboundPacket(struct socket* sock, union sctp_sockstore addr,
200                               void* data, size_t length,
201                               struct sctp_rcvinfo rcv, int flags,
202                               void* ulp_info) {
203  SctpDataMediaChannel* channel = static_cast<SctpDataMediaChannel*>(ulp_info);
204  // Post data to the channel's receiver thread (copying it).
205  // TODO(ldixon): Unclear if copy is needed as this method is responsible for
206  // memory cleanup. But this does simplify code.
207  const SctpDataMediaChannel::PayloadProtocolIdentifier ppid =
208      static_cast<SctpDataMediaChannel::PayloadProtocolIdentifier>(
209          rtc::HostToNetwork32(rcv.rcv_ppid));
210  cricket::DataMessageType type = cricket::DMT_NONE;
211  if (!GetDataMediaType(ppid, &type) && !(flags & MSG_NOTIFICATION)) {
212    // It's neither a notification nor a recognized data packet.  Drop it.
213    LOG(LS_ERROR) << "Received an unknown PPID " << ppid
214                  << " on an SCTP packet.  Dropping.";
215  } else {
216    SctpInboundPacket* packet = new SctpInboundPacket;
217    packet->buffer.SetData(data, length);
218    packet->params.ssrc = rcv.rcv_sid;
219    packet->params.seq_num = rcv.rcv_ssn;
220    packet->params.timestamp = rcv.rcv_tsn;
221    packet->params.type = type;
222    packet->flags = flags;
223    // The ownership of |packet| transfers to |msg|.
224    InboundPacketMessage* msg = new InboundPacketMessage(packet);
225    channel->worker_thread()->Post(channel, MSG_SCTPINBOUNDPACKET, msg);
226  }
227  free(data);
228  return 1;
229}
230
231// Set the initial value of the static SCTP Data Engines reference count.
232int SctpDataEngine::usrsctp_engines_count = 0;
233
234SctpDataEngine::SctpDataEngine() {
235  if (usrsctp_engines_count == 0) {
236    // First argument is udp_encapsulation_port, which is not releveant for our
237    // AF_CONN use of sctp.
238    usrsctp_init(0, cricket::OnSctpOutboundPacket, debug_sctp_printf);
239
240    // To turn on/off detailed SCTP debugging. You will also need to have the
241    // SCTP_DEBUG cpp defines flag.
242    // usrsctp_sysctl_set_sctp_debug_on(SCTP_DEBUG_ALL);
243
244    // TODO(ldixon): Consider turning this on/off.
245    usrsctp_sysctl_set_sctp_ecn_enable(0);
246
247    // TODO(ldixon): Consider turning this on/off.
248    // This is not needed right now (we don't do dynamic address changes):
249    // If SCTP Auto-ASCONF is enabled, the peer is informed automatically
250    // when a new address is added or removed. This feature is enabled by
251    // default.
252    // usrsctp_sysctl_set_sctp_auto_asconf(0);
253
254    // TODO(ldixon): Consider turning this on/off.
255    // Add a blackhole sysctl. Setting it to 1 results in no ABORTs
256    // being sent in response to INITs, setting it to 2 results
257    // in no ABORTs being sent for received OOTB packets.
258    // This is similar to the TCP sysctl.
259    //
260    // See: http://lakerest.net/pipermail/sctp-coders/2012-January/009438.html
261    // See: http://svnweb.freebsd.org/base?view=revision&revision=229805
262    // usrsctp_sysctl_set_sctp_blackhole(2);
263
264    // Set the number of default outgoing streams.  This is the number we'll
265    // send in the SCTP INIT message.  The 'appropriate default' in the
266    // second paragraph of
267    // http://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-05#section-6.2
268    // is cricket::kMaxSctpSid.
269    usrsctp_sysctl_set_sctp_nr_outgoing_streams_default(
270        cricket::kMaxSctpSid);
271  }
272  usrsctp_engines_count++;
273
274  cricket::DataCodec codec(kGoogleSctpDataCodecId, kGoogleSctpDataCodecName, 0);
275  codec.SetParam(kCodecParamPort, kSctpDefaultPort);
276  codecs_.push_back(codec);
277}
278
279SctpDataEngine::~SctpDataEngine() {
280  usrsctp_engines_count--;
281  LOG(LS_VERBOSE) << "usrsctp_engines_count:" << usrsctp_engines_count;
282
283  if (usrsctp_engines_count == 0) {
284    // usrsctp_finish() may fail if it's called too soon after the channels are
285    // closed. Wait and try again until it succeeds for up to 3 seconds.
286    for (size_t i = 0; i < 300; ++i) {
287      if (usrsctp_finish() == 0)
288        return;
289
290      rtc::Thread::SleepMs(10);
291    }
292    LOG(LS_ERROR) << "Failed to shutdown usrsctp.";
293  }
294}
295
296DataMediaChannel* SctpDataEngine::CreateChannel(
297    DataChannelType data_channel_type) {
298  if (data_channel_type != DCT_SCTP) {
299    return NULL;
300  }
301  return new SctpDataMediaChannel(rtc::Thread::Current());
302}
303
304SctpDataMediaChannel::SctpDataMediaChannel(rtc::Thread* thread)
305    : worker_thread_(thread),
306      local_port_(kSctpDefaultPort),
307      remote_port_(kSctpDefaultPort),
308      sock_(NULL),
309      sending_(false),
310      receiving_(false),
311      debug_name_("SctpDataMediaChannel") {
312}
313
314SctpDataMediaChannel::~SctpDataMediaChannel() {
315  CloseSctpSocket();
316}
317
318sockaddr_conn SctpDataMediaChannel::GetSctpSockAddr(int port) {
319  sockaddr_conn sconn = {0};
320  sconn.sconn_family = AF_CONN;
321#ifdef HAVE_SCONN_LEN
322  sconn.sconn_len = sizeof(sockaddr_conn);
323#endif
324  // Note: conversion from int to uint16_t happens here.
325  sconn.sconn_port = rtc::HostToNetwork16(port);
326  sconn.sconn_addr = this;
327  return sconn;
328}
329
330bool SctpDataMediaChannel::OpenSctpSocket() {
331  if (sock_) {
332    LOG(LS_VERBOSE) << debug_name_
333                    << "->Ignoring attempt to re-create existing socket.";
334    return false;
335  }
336  sock_ = usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP,
337                         cricket::OnSctpInboundPacket, NULL, 0, this);
338  if (!sock_) {
339    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to create SCTP socket.";
340    return false;
341  }
342
343  // Make the socket non-blocking. Connect, close, shutdown etc will not block
344  // the thread waiting for the socket operation to complete.
345  if (usrsctp_set_non_blocking(sock_, 1) < 0) {
346    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to set SCTP to non blocking.";
347    return false;
348  }
349
350  // This ensures that the usrsctp close call deletes the association. This
351  // prevents usrsctp from calling OnSctpOutboundPacket with references to
352  // this class as the address.
353  linger linger_opt;
354  linger_opt.l_onoff = 1;
355  linger_opt.l_linger = 0;
356  if (usrsctp_setsockopt(sock_, SOL_SOCKET, SO_LINGER, &linger_opt,
357                         sizeof(linger_opt))) {
358    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to set SO_LINGER.";
359    return false;
360  }
361
362  // Enable stream ID resets.
363  struct sctp_assoc_value stream_rst;
364  stream_rst.assoc_id = SCTP_ALL_ASSOC;
365  stream_rst.assoc_value = 1;
366  if (usrsctp_setsockopt(sock_, IPPROTO_SCTP, SCTP_ENABLE_STREAM_RESET,
367                         &stream_rst, sizeof(stream_rst))) {
368    LOG_ERRNO(LS_ERROR) << debug_name_
369                        << "Failed to set SCTP_ENABLE_STREAM_RESET.";
370    return false;
371  }
372
373  // Nagle.
374  uint32_t nodelay = 1;
375  if (usrsctp_setsockopt(sock_, IPPROTO_SCTP, SCTP_NODELAY, &nodelay,
376                         sizeof(nodelay))) {
377    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to set SCTP_NODELAY.";
378    return false;
379  }
380
381  // Disable MTU discovery
382  struct sctp_paddrparams params;
383  params.spp_assoc_id = 0;
384  params.spp_flags = SPP_PMTUD_DISABLE;
385  params.spp_pathmtu = kSctpMtu;
386  if (usrsctp_setsockopt(sock_, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, &params,
387      sizeof(params))) {
388    LOG_ERRNO(LS_ERROR) << debug_name_
389                        << "Failed to set SCTP_PEER_ADDR_PARAMS.";
390    return false;
391  }
392
393  // Subscribe to SCTP event notifications.
394  int event_types[] = {SCTP_ASSOC_CHANGE,
395                       SCTP_PEER_ADDR_CHANGE,
396                       SCTP_SEND_FAILED_EVENT,
397                       SCTP_SENDER_DRY_EVENT,
398                       SCTP_STREAM_RESET_EVENT};
399  struct sctp_event event = {0};
400  event.se_assoc_id = SCTP_ALL_ASSOC;
401  event.se_on = 1;
402  for (size_t i = 0; i < ARRAY_SIZE(event_types); i++) {
403    event.se_type = event_types[i];
404    if (usrsctp_setsockopt(sock_, IPPROTO_SCTP, SCTP_EVENT, &event,
405                           sizeof(event)) < 0) {
406      LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to set SCTP_EVENT type: "
407                          << event.se_type;
408      return false;
409    }
410  }
411
412  // Register this class as an address for usrsctp. This is used by SCTP to
413  // direct the packets received (by the created socket) to this class.
414  usrsctp_register_address(this);
415  sending_ = true;
416  return true;
417}
418
419void SctpDataMediaChannel::CloseSctpSocket() {
420  sending_ = false;
421  if (sock_) {
422    // We assume that SO_LINGER option is set to close the association when
423    // close is called. This means that any pending packets in usrsctp will be
424    // discarded instead of being sent.
425    usrsctp_close(sock_);
426    sock_ = NULL;
427    usrsctp_deregister_address(this);
428  }
429}
430
431bool SctpDataMediaChannel::Connect() {
432  LOG(LS_VERBOSE) << debug_name_ << "->Connect().";
433
434  // If we already have a socket connection, just return.
435  if (sock_) {
436    LOG(LS_WARNING) << debug_name_ << "->Connect(): Ignored as socket "
437                                      "is already established.";
438    return true;
439  }
440
441  // If no socket (it was closed) try to start it again. This can happen when
442  // the socket we are connecting to closes, does an sctp shutdown handshake,
443  // or behaves unexpectedly causing us to perform a CloseSctpSocket.
444  if (!sock_ && !OpenSctpSocket()) {
445    return false;
446  }
447
448  // Note: conversion from int to uint16_t happens on assignment.
449  sockaddr_conn local_sconn = GetSctpSockAddr(local_port_);
450  if (usrsctp_bind(sock_, reinterpret_cast<sockaddr *>(&local_sconn),
451                   sizeof(local_sconn)) < 0) {
452    LOG_ERRNO(LS_ERROR) << debug_name_ << "->Connect(): "
453                        << ("Failed usrsctp_bind");
454    CloseSctpSocket();
455    return false;
456  }
457
458  // Note: conversion from int to uint16_t happens on assignment.
459  sockaddr_conn remote_sconn = GetSctpSockAddr(remote_port_);
460  int connect_result = usrsctp_connect(
461      sock_, reinterpret_cast<sockaddr *>(&remote_sconn), sizeof(remote_sconn));
462  if (connect_result < 0 && errno != SCTP_EINPROGRESS) {
463    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed usrsctp_connect. got errno="
464                        << errno << ", but wanted " << SCTP_EINPROGRESS;
465    CloseSctpSocket();
466    return false;
467  }
468  return true;
469}
470
471void SctpDataMediaChannel::Disconnect() {
472  // TODO(ldixon): Consider calling |usrsctp_shutdown(sock_, ...)| to do a
473  // shutdown handshake and remove the association.
474  CloseSctpSocket();
475}
476
477bool SctpDataMediaChannel::SetSend(bool send) {
478  if (!sending_ && send) {
479    return Connect();
480  }
481  if (sending_ && !send) {
482    Disconnect();
483  }
484  return true;
485}
486
487bool SctpDataMediaChannel::SetReceive(bool receive) {
488  receiving_ = receive;
489  return true;
490}
491
492bool SctpDataMediaChannel::AddSendStream(const StreamParams& stream) {
493  return AddStream(stream);
494}
495
496bool SctpDataMediaChannel::RemoveSendStream(uint32 ssrc) {
497  return ResetStream(ssrc);
498}
499
500bool SctpDataMediaChannel::AddRecvStream(const StreamParams& stream) {
501  // SCTP DataChannels are always bi-directional and calling AddSendStream will
502  // enable both sending and receiving on the stream. So AddRecvStream is a
503  // no-op.
504  return true;
505}
506
507bool SctpDataMediaChannel::RemoveRecvStream(uint32 ssrc) {
508  // SCTP DataChannels are always bi-directional and calling RemoveSendStream
509  // will disable both sending and receiving on the stream. So RemoveRecvStream
510  // is a no-op.
511  return true;
512}
513
514bool SctpDataMediaChannel::SendData(
515    const SendDataParams& params,
516    const rtc::Buffer& payload,
517    SendDataResult* result) {
518  if (result) {
519    // Preset |result| to assume an error.  If SendData succeeds, we'll
520    // overwrite |*result| once more at the end.
521    *result = SDR_ERROR;
522  }
523
524  if (!sending_) {
525    LOG(LS_WARNING) << debug_name_ << "->SendData(...): "
526                    << "Not sending packet with ssrc=" << params.ssrc
527                    << " len=" << payload.length() << " before SetSend(true).";
528    return false;
529  }
530
531  if (params.type != cricket::DMT_CONTROL &&
532      open_streams_.find(params.ssrc) == open_streams_.end()) {
533    LOG(LS_WARNING) << debug_name_ << "->SendData(...): "
534                    << "Not sending data because ssrc is unknown: "
535                    << params.ssrc;
536    return false;
537  }
538
539  //
540  // Send data using SCTP.
541  ssize_t send_res = 0;  // result from usrsctp_sendv.
542  struct sctp_sendv_spa spa = {0};
543  spa.sendv_flags |= SCTP_SEND_SNDINFO_VALID;
544  spa.sendv_sndinfo.snd_sid = params.ssrc;
545  spa.sendv_sndinfo.snd_ppid = rtc::HostToNetwork32(
546      GetPpid(params.type));
547
548  // Ordered implies reliable.
549  if (!params.ordered) {
550    spa.sendv_sndinfo.snd_flags |= SCTP_UNORDERED;
551    if (params.max_rtx_count >= 0 || params.max_rtx_ms == 0) {
552      spa.sendv_flags |= SCTP_SEND_PRINFO_VALID;
553      spa.sendv_prinfo.pr_policy = SCTP_PR_SCTP_RTX;
554      spa.sendv_prinfo.pr_value = params.max_rtx_count;
555    } else {
556      spa.sendv_flags |= SCTP_SEND_PRINFO_VALID;
557      spa.sendv_prinfo.pr_policy = SCTP_PR_SCTP_TTL;
558      spa.sendv_prinfo.pr_value = params.max_rtx_ms;
559    }
560  }
561
562  // We don't fragment.
563  send_res = usrsctp_sendv(sock_, payload.data(),
564                           static_cast<size_t>(payload.length()),
565                           NULL, 0, &spa,
566                           rtc::checked_cast<socklen_t>(sizeof(spa)),
567                           SCTP_SENDV_SPA, 0);
568  if (send_res < 0) {
569    if (errno == SCTP_EWOULDBLOCK) {
570      *result = SDR_BLOCK;
571      LOG(LS_INFO) << debug_name_ << "->SendData(...): EWOULDBLOCK returned";
572    } else {
573      LOG_ERRNO(LS_ERROR) << "ERROR:" << debug_name_
574                          << "->SendData(...): "
575                          << " usrsctp_sendv: ";
576    }
577    return false;
578  }
579  if (result) {
580    // Only way out now is success.
581    *result = SDR_SUCCESS;
582  }
583  return true;
584}
585
586// Called by network interface when a packet has been received.
587void SctpDataMediaChannel::OnPacketReceived(
588    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
589  LOG(LS_VERBOSE) << debug_name_ << "->OnPacketReceived(...): " << " length="
590                  << packet->length() << ", sending: " << sending_;
591  // Only give receiving packets to usrsctp after if connected. This enables two
592  // peers to each make a connect call, but for them not to receive an INIT
593  // packet before they have called connect; least the last receiver of the INIT
594  // packet will have called connect, and a connection will be established.
595  if (sending_) {
596    // Pass received packet to SCTP stack. Once processed by usrsctp, the data
597    // will be will be given to the global OnSctpInboundData, and then,
598    // marshalled by a Post and handled with OnMessage.
599    usrsctp_conninput(this, packet->data(), packet->length(), 0);
600  } else {
601    // TODO(ldixon): Consider caching the packet for very slightly better
602    // reliability.
603  }
604}
605
606void SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(
607    SctpInboundPacket* packet) {
608  LOG(LS_VERBOSE) << debug_name_ << "->OnInboundPacketFromSctpToChannel(...): "
609                  << "Received SCTP data:"
610                  << " ssrc=" << packet->params.ssrc
611                  << " notification: " << (packet->flags & MSG_NOTIFICATION)
612                  << " length=" << packet->buffer.length();
613  // Sending a packet with data == NULL (no data) is SCTPs "close the
614  // connection" message. This sets sock_ = NULL;
615  if (!packet->buffer.length() || !packet->buffer.data()) {
616    LOG(LS_INFO) << debug_name_ << "->OnInboundPacketFromSctpToChannel(...): "
617                                   "No data, closing.";
618    return;
619  }
620  if (packet->flags & MSG_NOTIFICATION) {
621    OnNotificationFromSctp(&packet->buffer);
622  } else {
623    OnDataFromSctpToChannel(packet->params, &packet->buffer);
624  }
625}
626
627void SctpDataMediaChannel::OnDataFromSctpToChannel(
628    const ReceiveDataParams& params, rtc::Buffer* buffer) {
629  if (receiving_) {
630    LOG(LS_VERBOSE) << debug_name_ << "->OnDataFromSctpToChannel(...): "
631                    << "Posting with length: " << buffer->length()
632                    << " on stream " << params.ssrc;
633    // Reports all received messages to upper layers, no matter whether the sid
634    // is known.
635    SignalDataReceived(params, buffer->data(), buffer->length());
636  } else {
637    LOG(LS_WARNING) << debug_name_ << "->OnDataFromSctpToChannel(...): "
638                    << "Not receiving packet with sid=" << params.ssrc
639                    << " len=" <<  buffer->length()
640                    << " before SetReceive(true).";
641  }
642}
643
644bool SctpDataMediaChannel::AddStream(const StreamParams& stream) {
645  if (!stream.has_ssrcs()) {
646    return false;
647  }
648
649  const uint32 ssrc = stream.first_ssrc();
650  if (open_streams_.find(ssrc) != open_streams_.end()) {
651    LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
652                    << "Not adding data stream '" << stream.id
653                    << "' with ssrc=" << ssrc
654                    << " because stream is already open.";
655    return false;
656  } else if (queued_reset_streams_.find(ssrc) != queued_reset_streams_.end()
657             || sent_reset_streams_.find(ssrc) != sent_reset_streams_.end()) {
658    LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
659                    << "Not adding data stream '" << stream.id
660                    << "' with ssrc=" << ssrc
661                    << " because stream is still closing.";
662    return false;
663  }
664
665  open_streams_.insert(ssrc);
666  return true;
667}
668
669bool SctpDataMediaChannel::ResetStream(uint32 ssrc) {
670  // We typically get this called twice for the same stream, once each for
671  // Send and Recv.
672  StreamSet::iterator found = open_streams_.find(ssrc);
673
674  if (found == open_streams_.end()) {
675    LOG(LS_VERBOSE) << debug_name_ << "->ResetStream(" << ssrc << "): "
676                    << "stream not found.";
677    return false;
678  } else {
679    LOG(LS_VERBOSE) << debug_name_ << "->ResetStream(" << ssrc << "): "
680                    << "Removing and queuing RE-CONFIG chunk.";
681    open_streams_.erase(found);
682  }
683
684  // SCTP won't let you have more than one stream reset pending at a time, but
685  // you can close multiple streams in a single reset.  So, we keep an internal
686  // queue of streams-to-reset, and send them as one reset message in
687  // SendQueuedStreamResets().
688  queued_reset_streams_.insert(ssrc);
689
690  // Signal our stream-reset logic that it should try to send now, if it can.
691  SendQueuedStreamResets();
692
693  // The stream will actually get removed when we get the acknowledgment.
694  return true;
695}
696
697void SctpDataMediaChannel::OnNotificationFromSctp(rtc::Buffer* buffer) {
698  const sctp_notification& notification =
699      reinterpret_cast<const sctp_notification&>(*buffer->data());
700  ASSERT(notification.sn_header.sn_length == buffer->length());
701
702  // TODO(ldixon): handle notifications appropriately.
703  switch (notification.sn_header.sn_type) {
704    case SCTP_ASSOC_CHANGE:
705      LOG(LS_VERBOSE) << "SCTP_ASSOC_CHANGE";
706      OnNotificationAssocChange(notification.sn_assoc_change);
707      break;
708    case SCTP_REMOTE_ERROR:
709      LOG(LS_INFO) << "SCTP_REMOTE_ERROR";
710      break;
711    case SCTP_SHUTDOWN_EVENT:
712      LOG(LS_INFO) << "SCTP_SHUTDOWN_EVENT";
713      break;
714    case SCTP_ADAPTATION_INDICATION:
715      LOG(LS_INFO) << "SCTP_ADAPTATION_INDICATION";
716      break;
717    case SCTP_PARTIAL_DELIVERY_EVENT:
718      LOG(LS_INFO) << "SCTP_PARTIAL_DELIVERY_EVENT";
719      break;
720    case SCTP_AUTHENTICATION_EVENT:
721      LOG(LS_INFO) << "SCTP_AUTHENTICATION_EVENT";
722      break;
723    case SCTP_SENDER_DRY_EVENT:
724      LOG(LS_VERBOSE) << "SCTP_SENDER_DRY_EVENT";
725      SignalReadyToSend(true);
726      break;
727    // TODO(ldixon): Unblock after congestion.
728    case SCTP_NOTIFICATIONS_STOPPED_EVENT:
729      LOG(LS_INFO) << "SCTP_NOTIFICATIONS_STOPPED_EVENT";
730      break;
731    case SCTP_SEND_FAILED_EVENT:
732      LOG(LS_INFO) << "SCTP_SEND_FAILED_EVENT";
733      break;
734    case SCTP_STREAM_RESET_EVENT:
735      OnStreamResetEvent(&notification.sn_strreset_event);
736      break;
737    case SCTP_ASSOC_RESET_EVENT:
738      LOG(LS_INFO) << "SCTP_ASSOC_RESET_EVENT";
739      break;
740    case SCTP_STREAM_CHANGE_EVENT:
741      LOG(LS_INFO) << "SCTP_STREAM_CHANGE_EVENT";
742      // An acknowledgment we get after our stream resets have gone through,
743      // if they've failed.  We log the message, but don't react -- we don't
744      // keep around the last-transmitted set of SSIDs we wanted to close for
745      // error recovery.  It doesn't seem likely to occur, and if so, likely
746      // harmless within the lifetime of a single SCTP association.
747      break;
748    default:
749      LOG(LS_WARNING) << "Unknown SCTP event: "
750                      << notification.sn_header.sn_type;
751      break;
752  }
753}
754
755void SctpDataMediaChannel::OnNotificationAssocChange(
756    const sctp_assoc_change& change) {
757  switch (change.sac_state) {
758    case SCTP_COMM_UP:
759      LOG(LS_VERBOSE) << "Association change SCTP_COMM_UP";
760      break;
761    case SCTP_COMM_LOST:
762      LOG(LS_INFO) << "Association change SCTP_COMM_LOST";
763      break;
764    case SCTP_RESTART:
765      LOG(LS_INFO) << "Association change SCTP_RESTART";
766      break;
767    case SCTP_SHUTDOWN_COMP:
768      LOG(LS_INFO) << "Association change SCTP_SHUTDOWN_COMP";
769      break;
770    case SCTP_CANT_STR_ASSOC:
771      LOG(LS_INFO) << "Association change SCTP_CANT_STR_ASSOC";
772      break;
773    default:
774      LOG(LS_INFO) << "Association change UNKNOWN";
775      break;
776  }
777}
778
779void SctpDataMediaChannel::OnStreamResetEvent(
780    const struct sctp_stream_reset_event* evt) {
781  // A stream reset always involves two RE-CONFIG chunks for us -- we always
782  // simultaneously reset a sid's sequence number in both directions.  The
783  // requesting side transmits a RE-CONFIG chunk and waits for the peer to send
784  // one back.  Both sides get this SCTP_STREAM_RESET_EVENT when they receive
785  // RE-CONFIGs.
786  const int num_ssrcs = (evt->strreset_length - sizeof(*evt)) /
787      sizeof(evt->strreset_stream_list[0]);
788  LOG(LS_VERBOSE) << "SCTP_STREAM_RESET_EVENT(" << debug_name_
789                  << "): Flags = 0x"
790                  << std::hex << evt->strreset_flags << " ("
791                  << ListFlags(evt->strreset_flags) << ")";
792  LOG(LS_VERBOSE) << "Assoc = " << evt->strreset_assoc_id << ", Streams = ["
793                  << ListArray(evt->strreset_stream_list, num_ssrcs)
794                  << "], Open: ["
795                  << ListStreams(open_streams_) << "], Q'd: ["
796                  << ListStreams(queued_reset_streams_) << "], Sent: ["
797                  << ListStreams(sent_reset_streams_) << "]";
798
799  // If both sides try to reset some streams at the same time (even if they're
800  // disjoint sets), we can get reset failures.
801  if (evt->strreset_flags & SCTP_STREAM_RESET_FAILED) {
802    // OK, just try again.  The stream IDs sent over when the RESET_FAILED flag
803    // is set seem to be garbage values.  Ignore them.
804    queued_reset_streams_.insert(
805        sent_reset_streams_.begin(),
806        sent_reset_streams_.end());
807    sent_reset_streams_.clear();
808
809  } else if (evt->strreset_flags & SCTP_STREAM_RESET_INCOMING_SSN) {
810    // Each side gets an event for each direction of a stream.  That is,
811    // closing sid k will make each side receive INCOMING and OUTGOING reset
812    // events for k.  As per RFC6525, Section 5, paragraph 2, each side will
813    // get an INCOMING event first.
814    for (int i = 0; i < num_ssrcs; i++) {
815      const int stream_id = evt->strreset_stream_list[i];
816
817      // See if this stream ID was closed by our peer or ourselves.
818      StreamSet::iterator it = sent_reset_streams_.find(stream_id);
819
820      // The reset was requested locally.
821      if (it != sent_reset_streams_.end()) {
822        LOG(LS_VERBOSE) << "SCTP_STREAM_RESET_EVENT(" << debug_name_
823                        << "): local sid " << stream_id << " acknowledged.";
824        sent_reset_streams_.erase(it);
825
826      } else if ((it = open_streams_.find(stream_id))
827                 != open_streams_.end()) {
828        // The peer requested the reset.
829        LOG(LS_VERBOSE) << "SCTP_STREAM_RESET_EVENT(" << debug_name_
830                        << "): closing sid " << stream_id;
831        open_streams_.erase(it);
832        SignalStreamClosedRemotely(stream_id);
833
834      } else if ((it = queued_reset_streams_.find(stream_id))
835                 != queued_reset_streams_.end()) {
836        // The peer requested the reset, but there was a local reset
837        // queued.
838        LOG(LS_VERBOSE) << "SCTP_STREAM_RESET_EVENT(" << debug_name_
839                        << "): double-sided close for sid " << stream_id;
840        // Both sides want the stream closed, and the peer got to send the
841        // RE-CONFIG first.  Treat it like the local Remove(Send|Recv)Stream
842        // finished quickly.
843        queued_reset_streams_.erase(it);
844
845      } else {
846        // This stream is unknown.  Sometimes this can be from an
847        // RESET_FAILED-related retransmit.
848        LOG(LS_VERBOSE) << "SCTP_STREAM_RESET_EVENT(" << debug_name_
849                        << "): Unknown sid " << stream_id;
850      }
851    }
852  }
853
854  // Always try to send the queued RESET because this call indicates that the
855  // last local RESET or remote RESET has made some progress.
856  SendQueuedStreamResets();
857}
858
859// Puts the specified |param| from the codec identified by |id| into |dest|
860// and returns true.  Or returns false if it wasn't there, leaving |dest|
861// untouched.
862static bool GetCodecIntParameter(const std::vector<DataCodec>& codecs,
863                                 int id, const std::string& name,
864                                 const std::string& param, int* dest) {
865  std::string value;
866  Codec match_pattern;
867  match_pattern.id = id;
868  match_pattern.name = name;
869  for (size_t i = 0; i < codecs.size(); ++i) {
870    if (codecs[i].Matches(match_pattern)) {
871      if (codecs[i].GetParam(param, &value)) {
872        *dest = rtc::FromString<int>(value);
873        return true;
874      }
875    }
876  }
877  return false;
878}
879
880bool SctpDataMediaChannel::SetSendCodecs(const std::vector<DataCodec>& codecs) {
881  return GetCodecIntParameter(
882      codecs, kGoogleSctpDataCodecId, kGoogleSctpDataCodecName, kCodecParamPort,
883      &remote_port_);
884}
885
886bool SctpDataMediaChannel::SetRecvCodecs(const std::vector<DataCodec>& codecs) {
887  return GetCodecIntParameter(
888      codecs, kGoogleSctpDataCodecId, kGoogleSctpDataCodecName, kCodecParamPort,
889      &local_port_);
890}
891
892void SctpDataMediaChannel::OnPacketFromSctpToNetwork(
893    rtc::Buffer* buffer) {
894  if (buffer->length() > kSctpMtu) {
895    LOG(LS_ERROR) << debug_name_ << "->OnPacketFromSctpToNetwork(...): "
896                  << "SCTP seems to have made a packet that is bigger "
897                     "than its official MTU.";
898  }
899  MediaChannel::SendPacket(buffer);
900}
901
902bool SctpDataMediaChannel::SendQueuedStreamResets() {
903  if (!sent_reset_streams_.empty() || queued_reset_streams_.empty())
904    return true;
905
906  LOG(LS_VERBOSE) << "SendQueuedStreamResets[" << debug_name_ << "]: Sending ["
907                  << ListStreams(queued_reset_streams_) << "], Open: ["
908                  << ListStreams(open_streams_) << "], Sent: ["
909                  << ListStreams(sent_reset_streams_) << "]";
910
911  const size_t num_streams = queued_reset_streams_.size();
912  const size_t num_bytes = sizeof(struct sctp_reset_streams)
913    + (num_streams * sizeof(uint16));
914
915  std::vector<uint8> reset_stream_buf(num_bytes, 0);
916  struct sctp_reset_streams* resetp = reinterpret_cast<sctp_reset_streams*>(
917      &reset_stream_buf[0]);
918  resetp->srs_assoc_id = SCTP_ALL_ASSOC;
919  resetp->srs_flags = SCTP_STREAM_RESET_INCOMING | SCTP_STREAM_RESET_OUTGOING;
920  resetp->srs_number_streams = rtc::checked_cast<uint16_t>(num_streams);
921  int result_idx = 0;
922  for (StreamSet::iterator it = queued_reset_streams_.begin();
923       it != queued_reset_streams_.end(); ++it) {
924    resetp->srs_stream_list[result_idx++] = *it;
925  }
926
927  int ret = usrsctp_setsockopt(
928      sock_, IPPROTO_SCTP, SCTP_RESET_STREAMS, resetp,
929      rtc::checked_cast<socklen_t>(reset_stream_buf.size()));
930  if (ret < 0) {
931    LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to send a stream reset for "
932                        << num_streams << " streams";
933    return false;
934  }
935
936  // sent_reset_streams_ is empty, and all the queued_reset_streams_ go into
937  // it now.
938  queued_reset_streams_.swap(sent_reset_streams_);
939  return true;
940}
941
942void SctpDataMediaChannel::OnMessage(rtc::Message* msg) {
943  switch (msg->message_id) {
944    case MSG_SCTPINBOUNDPACKET: {
945      rtc::scoped_ptr<InboundPacketMessage> pdata(
946          static_cast<InboundPacketMessage*>(msg->pdata));
947      OnInboundPacketFromSctpToChannel(pdata->data().get());
948      break;
949    }
950    case MSG_SCTPOUTBOUNDPACKET: {
951      rtc::scoped_ptr<OutboundPacketMessage> pdata(
952          static_cast<OutboundPacketMessage*>(msg->pdata));
953      OnPacketFromSctpToNetwork(pdata->data().get());
954      break;
955    }
956  }
957}
958}  // namespace cricket
959