Only initialize usrsctp when it's used and uninitialize when it's not being used.

webrtc/media/sctp/sctpdataengine.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/media/sctp/sctpdataengine.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 
 #include <memory>
 #include <sstream>
 #include <vector>
 
 #include "usrsctplib/usrsctp.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/copyonwritebuffer.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/streamparams.h"
 
+namespace cricket {
+// The biggest SCTP packet.  Starting from a 'safe' wire MTU value of 1280,
+// take off 80 bytes for DTLS/TURN/TCP/IP overhead.
+static const size_t kSctpMtu = 1200;
+
+// The size of the SCTP association send buffer.  256kB, the usrsctp default.
+static const int kSendBufferSize = 262144;
+
+struct SctpInboundPacket {
+  rtc::CopyOnWriteBuffer buffer;
+  ReceiveDataParams params;
+  // The |flags| parameter is used by SCTP to distinguish notification packets
+  // from other types of packets.
+  int flags;
+};
+
 namespace {
-typedef cricket::SctpDataMediaChannel::StreamSet StreamSet;
+// Set the initial value of the static SCTP Data Engines reference count.
+int g_usrsctp_usage_count = 0;
+rtc::GlobalLockPod g_usrsctp_lock_;
+
+typedef SctpDataMediaChannel::StreamSet StreamSet;
+
 // Returns a comma-separated, human-readable list of the stream IDs in 's'
 std::string ListStreams(const StreamSet& s) {
   std::stringstream result;
   bool first = true;
   for (StreamSet::const_iterator it = s.begin(); it != s.end(); ++it) {
     if (!first) {
       result << ", " << *it;
     } else {
       result << *it;
       first = false;
@@ skipping 36 matching lines @@
   std::stringstream result;
   for (int i = 0; i < num_elems; ++i) {
     if (i) {
       result << ", " << array[i];
     } else {
       result << array[i];
     }
   }
   return result.str();
 }
-}  // namespace
 
-namespace cricket {
 typedef rtc::ScopedMessageData<SctpInboundPacket> InboundPacketMessage;
 typedef rtc::ScopedMessageData<rtc::CopyOnWriteBuffer> OutboundPacketMessage;
 
-// The biggest SCTP packet.  Starting from a 'safe' wire MTU value of 1280,
-// take off 80 bytes for DTLS/TURN/TCP/IP overhead.
-static const size_t kSctpMtu = 1200;
-
-// The size of the SCTP association send buffer.  256kB, the usrsctp default.
-static const int kSendBufferSize = 262144;
 enum {
   MSG_SCTPINBOUNDPACKET = 1,   // MessageData is SctpInboundPacket
   MSG_SCTPOUTBOUNDPACKET = 2,  // MessageData is rtc:Buffer
 };
 
-struct SctpInboundPacket {
-  rtc::CopyOnWriteBuffer buffer;
-  ReceiveDataParams params;
-  // The |flags| parameter is used by SCTP to distinguish notification packets
-  // from other types of packets.
-  int flags;
-};
-
 // Helper for logging SCTP messages.
-static void debug_sctp_printf(const char *format, ...) {
+void DebugSctpPrintf(const char* format, ...) {
+#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
   char s[255];
   va_list ap;
   va_start(ap, format);
   vsnprintf(s, sizeof(s), format, ap);
   LOG(LS_INFO) << "SCTP: " << s;
   va_end(ap);
+#endif
 }
 
 // Get the PPID to use for the terminating fragment of this type.
-static SctpDataMediaChannel::PayloadProtocolIdentifier GetPpid(
-    cricket::DataMessageType type) {
+SctpDataMediaChannel::PayloadProtocolIdentifier GetPpid(DataMessageType type) {
   switch (type) {
   default:
-  case cricket::DMT_NONE:
+  case DMT_NONE:
     return SctpDataMediaChannel::PPID_NONE;
-  case cricket::DMT_CONTROL:
+  case DMT_CONTROL:
     return SctpDataMediaChannel::PPID_CONTROL;
-  case cricket::DMT_BINARY:
+  case DMT_BINARY:
     return SctpDataMediaChannel::PPID_BINARY_LAST;
-  case cricket::DMT_TEXT:
+  case DMT_TEXT:
     return SctpDataMediaChannel::PPID_TEXT_LAST;
   };
 }
 
-static bool GetDataMediaType(
-    SctpDataMediaChannel::PayloadProtocolIdentifier ppid,
-    cricket::DataMessageType *dest) {
+bool GetDataMediaType(SctpDataMediaChannel::PayloadProtocolIdentifier ppid,
+                      DataMessageType* dest) {
   ASSERT(dest != NULL);
   switch (ppid) {
     case SctpDataMediaChannel::PPID_BINARY_PARTIAL:
     case SctpDataMediaChannel::PPID_BINARY_LAST:
-      *dest = cricket::DMT_BINARY;
+      *dest = DMT_BINARY;
       return true;
 
     case SctpDataMediaChannel::PPID_TEXT_PARTIAL:
     case SctpDataMediaChannel::PPID_TEXT_LAST:
-      *dest = cricket::DMT_TEXT;
+      *dest = DMT_TEXT;
       return true;
 
     case SctpDataMediaChannel::PPID_CONTROL:
-      *dest = cricket::DMT_CONTROL;
+      *dest = DMT_CONTROL;
       return true;
 
     case SctpDataMediaChannel::PPID_NONE:
-      *dest = cricket::DMT_NONE;
+      *dest = DMT_NONE;
       return true;
 
     default:
       return false;
   }
 }
 
 // Log the packet in text2pcap format, if log level is at LS_VERBOSE.
-static void VerboseLogPacket(const void *data, size_t length, int direction) {
+void VerboseLogPacket(const void* data, size_t length, int direction) {
   if (LOG_CHECK_LEVEL(LS_VERBOSE) && length > 0) {
     char *dump_buf;
     // Some downstream project uses an older version of usrsctp that expects
     // a non-const "void*" as first parameter when dumping the packet, so we
     // need to cast the const away here to avoid a compiler error.
     if ((dump_buf = usrsctp_dumppacket(
         const_cast<void*>(data), length, direction)) != NULL) {
       LOG(LS_VERBOSE) << dump_buf;
       usrsctp_freedumpbuffer(dump_buf);
     }
   }
 }
 
 // This is the callback usrsctp uses when there's data to send on the network
 // that has been wrapped appropriatly for the SCTP protocol.
-static int OnSctpOutboundPacket(void* addr, void* data, size_t length,
-                                uint8_t tos, uint8_t set_df) {
+int OnSctpOutboundPacket(void* addr,
+                         void* data,
+                         size_t length,
+                         uint8_t tos,
+                         uint8_t set_df) {
   SctpDataMediaChannel* channel = static_cast<SctpDataMediaChannel*>(addr);
   LOG(LS_VERBOSE) << "global OnSctpOutboundPacket():"
                   << "addr: " << addr << "; length: " << length
                   << "; tos: " << std::hex << static_cast<int>(tos)
                   << "; set_df: " << std::hex << static_cast<int>(set_df);
 
   VerboseLogPacket(addr, length, SCTP_DUMP_OUTBOUND);
   // Note: We have to copy the data; the caller will delete it.
   auto* msg = new OutboundPacketMessage(
       new rtc::CopyOnWriteBuffer(reinterpret_cast<uint8_t*>(data), length));
   channel->worker_thread()->Post(channel, MSG_SCTPOUTBOUNDPACKET, msg);
   return 0;
 }
 
 // This is the callback called from usrsctp when data has been received, after
 // a packet has been interpreted and parsed by usrsctp and found to contain
 // payload data. It is called by a usrsctp thread. It is assumed this function
 // will free the memory used by 'data'.
-static int OnSctpInboundPacket(struct socket* sock, union sctp_sockstore addr,
-                               void* data, size_t length,
-                               struct sctp_rcvinfo rcv, int flags,
-                               void* ulp_info) {
+int OnSctpInboundPacket(struct socket* sock,
+                        union sctp_sockstore addr,
+                        void* data,
+                        size_t length,
+                        struct sctp_rcvinfo rcv,
+                        int flags,
+                        void* ulp_info) {
   SctpDataMediaChannel* channel = static_cast<SctpDataMediaChannel*>(ulp_info);
   // Post data to the channel's receiver thread (copying it).
   // TODO(ldixon): Unclear if copy is needed as this method is responsible for
   // memory cleanup. But this does simplify code.
   const SctpDataMediaChannel::PayloadProtocolIdentifier ppid =
       static_cast<SctpDataMediaChannel::PayloadProtocolIdentifier>(
           rtc::HostToNetwork32(rcv.rcv_ppid));
-  cricket::DataMessageType type = cricket::DMT_NONE;
+  DataMessageType type = DMT_NONE;
   if (!GetDataMediaType(ppid, &type) && !(flags & MSG_NOTIFICATION)) {
     // It's neither a notification nor a recognized data packet.  Drop it.
     LOG(LS_ERROR) << "Received an unknown PPID " << ppid
                   << " on an SCTP packet.  Dropping.";
   } else {
     SctpInboundPacket* packet = new SctpInboundPacket;
     packet->buffer.SetData(reinterpret_cast<uint8_t*>(data), length);
     packet->params.ssrc = rcv.rcv_sid;
     packet->params.seq_num = rcv.rcv_ssn;
     packet->params.timestamp = rcv.rcv_tsn;
     packet->params.type = type;
     packet->flags = flags;
     // The ownership of |packet| transfers to |msg|.
     InboundPacketMessage* msg = new InboundPacketMessage(packet);
     channel->worker_thread()->Post(channel, MSG_SCTPINBOUNDPACKET, msg);
   }
   free(data);
   return 1;
 }
 
-// Set the initial value of the static SCTP Data Engines reference count.
-int SctpDataEngine::usrsctp_engines_count = 0;
+void InitializeUsrSctp() {
+  LOG(LS_INFO) << __FUNCTION__;
+  // First argument is udp_encapsulation_port, which is not releveant for our
+  // AF_CONN use of sctp.
+  usrsctp_init(0, &OnSctpOutboundPacket, &DebugSctpPrintf);
 
-SctpDataEngine::SctpDataEngine() {
-  if (usrsctp_engines_count == 0) {
-    // First argument is udp_encapsulation_port, which is not releveant for our
-    // AF_CONN use of sctp.
-    usrsctp_init(0, cricket::OnSctpOutboundPacket, debug_sctp_printf);
+  // To turn on/off detailed SCTP debugging. You will also need to have the
+  // SCTP_DEBUG cpp defines flag.
+  // usrsctp_sysctl_set_sctp_debug_on(SCTP_DEBUG_ALL);
 
-    // To turn on/off detailed SCTP debugging. You will also need to have the
-    // SCTP_DEBUG cpp defines flag.
-    // usrsctp_sysctl_set_sctp_debug_on(SCTP_DEBUG_ALL);
+  // TODO(ldixon): Consider turning this on/off.
+  usrsctp_sysctl_set_sctp_ecn_enable(0);
 
-    // TODO(ldixon): Consider turning this on/off.
-    usrsctp_sysctl_set_sctp_ecn_enable(0);
+  // This is harmless, but we should find out when the library default
+  // changes.
+  int send_size = usrsctp_sysctl_get_sctp_sendspace();
+  if (send_size != kSendBufferSize) {
+    LOG(LS_ERROR) << "Got different send size than expected: " << send_size;
+  }
 
-    // This is harmless, but we should find out when the library default
-    // changes.
-    int send_size = usrsctp_sysctl_get_sctp_sendspace();
-    if (send_size != kSendBufferSize) {
-      LOG(LS_ERROR) << "Got different send size than expected: " << send_size;
+  // TODO(ldixon): Consider turning this on/off.
+  // This is not needed right now (we don't do dynamic address changes):
+  // If SCTP Auto-ASCONF is enabled, the peer is informed automatically
+  // when a new address is added or removed. This feature is enabled by
+  // default.
+  // usrsctp_sysctl_set_sctp_auto_asconf(0);
+
+  // TODO(ldixon): Consider turning this on/off.
+  // Add a blackhole sysctl. Setting it to 1 results in no ABORTs
+  // being sent in response to INITs, setting it to 2 results
+  // in no ABORTs being sent for received OOTB packets.
+  // This is similar to the TCP sysctl.
+  //
+  // See: http://lakerest.net/pipermail/sctp-coders/2012-January/009438.html
+  // See: http://svnweb.freebsd.org/base?view=revision&revision=229805
+  // usrsctp_sysctl_set_sctp_blackhole(2);
+
+  // Set the number of default outgoing streams.  This is the number we'll
+  // send in the SCTP INIT message.  The 'appropriate default' in the
+  // second paragraph of
+  // http://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-05#section-6.2
+  // is kMaxSctpSid.
+  usrsctp_sysctl_set_sctp_nr_outgoing_streams_default(kMaxSctpSid);
+}
+
+void UninitializeUsrSctp() {
+  LOG(LS_INFO) << __FUNCTION__;
+  // usrsctp_finish() may fail if it's called too soon after the channels are
+  // closed. Wait and try again until it succeeds for up to 3 seconds.
+  for (size_t i = 0; i < 300; ++i) {
+    if (usrsctp_finish() == 0) {
+      return;
     }
 
-    // TODO(ldixon): Consider turning this on/off.
-    // This is not needed right now (we don't do dynamic address changes):
-    // If SCTP Auto-ASCONF is enabled, the peer is informed automatically
-    // when a new address is added or removed. This feature is enabled by
-    // default.
-    // usrsctp_sysctl_set_sctp_auto_asconf(0);
-
-    // TODO(ldixon): Consider turning this on/off.
-    // Add a blackhole sysctl. Setting it to 1 results in no ABORTs
-    // being sent in response to INITs, setting it to 2 results
-    // in no ABORTs being sent for received OOTB packets.
-    // This is similar to the TCP sysctl.
-    //
-    // See: http://lakerest.net/pipermail/sctp-coders/2012-January/009438.html
-    // See: http://svnweb.freebsd.org/base?view=revision&revision=229805
-    // usrsctp_sysctl_set_sctp_blackhole(2);
-
-    // Set the number of default outgoing streams.  This is the number we'll
-    // send in the SCTP INIT message.  The 'appropriate default' in the
-    // second paragraph of
-    // http://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-05#section-6.2
-    // is cricket::kMaxSctpSid.
-    usrsctp_sysctl_set_sctp_nr_outgoing_streams_default(
-        cricket::kMaxSctpSid);
+    rtc::Thread::SleepMs(10);
   }
-  usrsctp_engines_count++;
-
-  cricket::DataCodec codec(kGoogleSctpDataCodecId, kGoogleSctpDataCodecName);
-  codec.SetParam(kCodecParamPort, kSctpDefaultPort);
-  codecs_.push_back(codec);
+  LOG(LS_ERROR) << "Failed to shutdown usrsctp.";
 }
 
-SctpDataEngine::~SctpDataEngine() {
-  usrsctp_engines_count--;
-  LOG(LS_VERBOSE) << "usrsctp_engines_count:" << usrsctp_engines_count;
+void IncrementUsrSctpUsageCount() {
+  rtc::GlobalLockScope lock(&g_usrsctp_lock_);
+  if (!g_usrsctp_usage_count) {
+    InitializeUsrSctp();
+  }
+  ++g_usrsctp_usage_count;
+}
 
-  if (usrsctp_engines_count == 0) {
-    // usrsctp_finish() may fail if it's called too soon after the channels are
-    // closed. Wait and try again until it succeeds for up to 3 seconds.
-    for (size_t i = 0; i < 300; ++i) {
-      if (usrsctp_finish() == 0)
-        return;
-
-      rtc::Thread::SleepMs(10);
-    }
-    LOG(LS_ERROR) << "Failed to shutdown usrsctp.";
+void DecrementUsrSctpUsageCount() {
+  rtc::GlobalLockScope lock(&g_usrsctp_lock_);
+  --g_usrsctp_usage_count;
+  if (!g_usrsctp_usage_count) {
+    UninitializeUsrSctp();
   }
 }
 
+DataCodec GetSctpDataCodec() {
+  DataCodec codec(kGoogleSctpDataCodecId, kGoogleSctpDataCodecName);
+  codec.SetParam(kCodecParamPort, kSctpDefaultPort);
+  return codec;
+}
+
+}  // namespace
+
+SctpDataEngine::SctpDataEngine() : codecs_(1, GetSctpDataCodec()) {}
+
+SctpDataEngine::~SctpDataEngine() {}
+
+// Called on the worker thread.
 DataMediaChannel* SctpDataEngine::CreateChannel(
     DataChannelType data_channel_type) {
   if (data_channel_type != DCT_SCTP) {
     return NULL;
   }
   return new SctpDataMediaChannel(rtc::Thread::Current());
 }
 
 // static
-SctpDataMediaChannel* SctpDataEngine::GetChannelFromSocket(
+SctpDataMediaChannel* SctpDataMediaChannel::GetChannelFromSocket(
     struct socket* sock) {
   struct sockaddr* addrs = nullptr;
   int naddrs = usrsctp_getladdrs(sock, 0, &addrs);
   if (naddrs <= 0 || addrs[0].sa_family != AF_CONN) {
     return nullptr;
   }
   // usrsctp_getladdrs() returns the addresses bound to this socket, which
   // contains the SctpDataMediaChannel* as sconn_addr.  Read the pointer,
   // then free the list of addresses once we have the pointer.  We only open
   // AF_CONN sockets, and they should all have the sconn_addr set to the
   // pointer that created them, so [0] is as good as any other.
   struct sockaddr_conn* sconn =
       reinterpret_cast<struct sockaddr_conn*>(&addrs[0]);
   SctpDataMediaChannel* channel =
       reinterpret_cast<SctpDataMediaChannel*>(sconn->sconn_addr);
   usrsctp_freeladdrs(addrs);
 
   return channel;
 }
 
 // static
-int SctpDataEngine::SendThresholdCallback(struct socket* sock,
-                                          uint32_t sb_free) {
+int SctpDataMediaChannel::SendThresholdCallback(struct socket* sock,
+                                                uint32_t sb_free) {
   // Fired on our I/O thread.  SctpDataMediaChannel::OnPacketReceived() gets
   // a packet containing acknowledgments, which goes into usrsctp_conninput,
   // and then back here.
   SctpDataMediaChannel* channel = GetChannelFromSocket(sock);
   if (!channel) {
     LOG(LS_ERROR) << "SendThresholdCallback: Failed to get channel for socket "
                   << sock;
     return 0;
   }
   channel->OnSendThresholdCallback();
@@ skipping 31 matching lines @@
   return sconn;
 }
 
 bool SctpDataMediaChannel::OpenSctpSocket() {
   if (sock_) {
     LOG(LS_VERBOSE) << debug_name_
                     << "->Ignoring attempt to re-create existing socket.";
     return false;
   }
 
+  IncrementUsrSctpUsageCount();
+
   // If kSendBufferSize isn't reflective of reality, we log an error, but we
   // still have to do something reasonable here.  Look up what the buffer's
   // real size is and set our threshold to something reasonable.
   const static int kSendThreshold = usrsctp_sysctl_get_sctp_sendspace() / 2;
 
-  sock_ = usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP,
-                         cricket::OnSctpInboundPacket,
-                         &SctpDataEngine::SendThresholdCallback,
-                         kSendThreshold, this);
+  sock_ = usrsctp_socket(
+      AF_CONN, SOCK_STREAM, IPPROTO_SCTP, OnSctpInboundPacket,
+      &SctpDataMediaChannel::SendThresholdCallback, kSendThreshold, this);
   if (!sock_) {
     LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to create SCTP socket.";
+    DecrementUsrSctpUsageCount();
     return false;
   }
 
   // Make the socket non-blocking. Connect, close, shutdown etc will not block
   // the thread waiting for the socket operation to complete.
   if (usrsctp_set_non_blocking(sock_, 1) < 0) {
     LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to set SCTP to non blocking.";
     return false;
   }
 
@@ skipping 68 matching lines @@
 
 void SctpDataMediaChannel::CloseSctpSocket() {
   sending_ = false;
   if (sock_) {
     // We assume that SO_LINGER option is set to close the association when
     // close is called. This means that any pending packets in usrsctp will be
     // discarded instead of being sent.
     usrsctp_close(sock_);
     sock_ = NULL;
     usrsctp_deregister_address(this);
+
+    DecrementUsrSctpUsageCount();
   }
 }
 
 bool SctpDataMediaChannel::Connect() {
   LOG(LS_VERBOSE) << debug_name_ << "->Connect().";
 
   // If we already have a socket connection, just return.
   if (sock_) {
     LOG(LS_WARNING) << debug_name_ << "->Connect(): Ignored as socket "
                                       "is already established.";
@@ skipping 91 matching lines @@
     *result = SDR_ERROR;
   }
 
   if (!sending_) {
     LOG(LS_WARNING) << debug_name_ << "->SendData(...): "
                     << "Not sending packet with ssrc=" << params.ssrc
                     << " len=" << payload.size() << " before SetSend(true).";
     return false;
   }
 
-  if (params.type != cricket::DMT_CONTROL &&
+  if (params.type != DMT_CONTROL &&
       open_streams_.find(params.ssrc) == open_streams_.end()) {
     LOG(LS_WARNING) << debug_name_ << "->SendData(...): "
                     << "Not sending data because ssrc is unknown: "
                     << params.ssrc;
     return false;
   }
 
   //
   // Send data using SCTP.
   ssize_t send_res = 0;  // result from usrsctp_sendv.
@@ skipping 97 matching lines @@
                     << " len=" << buffer.size() << " before SetReceive(true).";
   }
 }
 
 bool SctpDataMediaChannel::AddStream(const StreamParams& stream) {
   if (!stream.has_ssrcs()) {
     return false;
   }
 
   const uint32_t ssrc = stream.first_ssrc();
-  if (ssrc >= cricket::kMaxSctpSid) {
+  if (ssrc >= kMaxSctpSid) {
     LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
                     << "Not adding data stream '" << stream.id
                     << "' with ssrc=" << ssrc
                     << " because stream ssrc is too high.";
     return false;
   } else if (open_streams_.find(ssrc) != open_streams_.end()) {
     LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
                     << "Not adding data stream '" << stream.id
                     << "' with ssrc=" << ssrc
                     << " because stream is already open.";
@@ skipping 246 matching lines @@
                   << "SCTP seems to have made a packet that is bigger "
                   << "than its official MTU: " << buffer->size()
                   << " vs max of " << kSctpMtu
                   << " even after adding " << kSctpOverhead
                   << " extra SCTP overhead";
   }
   MediaChannel::SendPacket(buffer, rtc::PacketOptions());
 }
 
 bool SctpDataMediaChannel::SendQueuedStreamResets() {
-  if (!sent_reset_streams_.empty() || queued_reset_streams_.empty())
+  if (!sent_reset_streams_.empty() || queued_reset_streams_.empty()) {
     return true;
+  }
 
   LOG(LS_VERBOSE) << "SendQueuedStreamResets[" << debug_name_ << "]: Sending ["
                   << ListStreams(queued_reset_streams_) << "], Open: ["
                   << ListStreams(open_streams_) << "], Sent: ["
                   << ListStreams(sent_reset_streams_) << "]";
 
   const size_t num_streams = queued_reset_streams_.size();
   const size_t num_bytes =
       sizeof(struct sctp_reset_streams) + (num_streams * sizeof(uint16_t));
 
@@ skipping 34 matching lines @@
     }
     case MSG_SCTPOUTBOUNDPACKET: {
       std::unique_ptr<OutboundPacketMessage> pdata(
           static_cast<OutboundPacketMessage*>(msg->pdata));
       OnPacketFromSctpToNetwork(pdata->data().get());
       break;
     }
   }
 }
 }  // namespace cricket