Bug 855623: Add 'protocol' field, and support external negotiation r=tuexen,ehugg

jesup · jesup · commit 8472648180a2 · 2013-03-31T21:09:26.000-04:00
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -679,10 +679,13 @@ PeerConnectionImpl::InitializeDataChannel(uint16_t aLocalport,
 
 NS_IMETHODIMP
 PeerConnectionImpl::CreateDataChannel(const nsACString& aLabel,
+                                      const nsACString& aProtocol,
                                       uint16_t aType,
                                       bool outOfOrderAllowed,
                                       uint16_t aMaxTime,
                                       uint16_t aMaxNum,
+                                      bool aExternalNegotiated,
+                                      uint16_t aStream,
                                       nsIDOMDataChannel** aRetval)
 {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
@@ -697,10 +700,10 @@ PeerConnectionImpl::CreateDataChannel(const nsACString& aLabel,
     return NS_ERROR_FAILURE;
   }
   dataChannel = mDataConnection->Open(
-    aLabel, theType, !outOfOrderAllowed,
+    aLabel, aProtocol, theType, !outOfOrderAllowed,
     aType == mozilla::DataChannelConnection::PARTIAL_RELIABLE_REXMIT ? aMaxNum :
     (aType == mozilla::DataChannelConnection::PARTIAL_RELIABLE_TIMED ? aMaxTime : 0),
-    nullptr, nullptr
+    nullptr, nullptr, aExternalNegotiated, aStream
   );
   NS_ENSURE_TRUE(dataChannel,NS_ERROR_FAILURE);
 
diff --git a/netwerk/sctp/datachannel/DataChannel.cpp b/netwerk/sctp/datachannel/DataChannel.cpp
@@ -838,12 +838,14 @@ DataChannelConnection::SendControlMessage(void *msg, uint32_t len, uint16_t stre
 
 int32_t
 DataChannelConnection::SendOpenRequestMessage(const nsACString& label,
+                                              const nsACString& protocol,
                                               uint16_t stream, bool unordered,
                                               uint16_t prPolicy, uint32_t prValue)
 {
-  int len = label.Length(); // not including nul
+  int label_len = label.Length(); // not including nul
+  int proto_len = protocol.Length(); // not including nul
   struct rtcweb_datachannel_open_request *req =
-    (struct rtcweb_datachannel_open_request*) moz_xmalloc(sizeof(*req)+len);
+    (struct rtcweb_datachannel_open_request*) moz_xmalloc(sizeof(*req)+label_len+proto_len+1);
    // careful - ok because request includes 1 char label
 
   memset(req, 0, sizeof(struct rtcweb_datachannel_open_request));
@@ -869,9 +871,13 @@ DataChannelConnection::SendOpenRequestMessage(const nsACString& label,
   }
   req->reliability_params = htons((uint16_t)prValue); /* XXX Why 16-bit */
   req->priority = htons(0); /* XXX: add support */
+  req->label_length = label_len;
+  req->protocol_length = proto_len;
   strcpy(&req->label[0], PromiseFlatCString(label).get());
+  strcpy(&req->label[req->label_length+1], PromiseFlatCString(protocol).get());
 
-  int32_t result = SendControlMessage(req, sizeof(*req)+len, stream);
+  // sizeof(*req) already includes +1 byte for label, need nul for both strings
+  int32_t result = SendControlMessage(req, sizeof(*req)+label_len+proto_len+1, stream);
 
   moz_free(req);
   return result;
@@ -907,7 +913,8 @@ DataChannelConnection::SendDeferredMessages()
 
     // Only one of these should be set....
     if (channel->mFlags & DATA_CHANNEL_FLAGS_SEND_REQ) {
-      if (SendOpenRequestMessage(channel->mLabel, channel->mStream,
+      if (SendOpenRequestMessage(channel->mLabel, channel->mProtocol,
+                                 channel->mStream,
                                  channel->mFlags & DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED,
                                  channel->mPrPolicy, channel->mPrValue)) {
         channel->mFlags &= ~DATA_CHANNEL_FLAGS_SEND_REQ;
@@ -996,15 +1003,10 @@ DataChannelConnection::HandleOpenRequestMessage(const struct rtcweb_datachannel_
   uint16_t prPolicy;
   uint32_t flags;
   nsCString label(nsDependentCString(req->label));
+  nsCString protocol(nsDependentCString(&req->label[req->label_length+1]));
 
   mLock.AssertCurrentThreadOwns();
 
-  if ((channel = FindChannelByStream(stream))) {
-    LOG(("ERROR: HandleOpenRequestMessage: channel for stream %u is in state %d instead of CLOSED.",
-         stream, channel->mState));
-    /* XXX: some error handling */
-    return;
-  }
   switch (req->channel_type) {
     case DATA_CHANNEL_RELIABLE:
       prPolicy = SCTP_PR_SCTP_NONE;
@@ -1021,19 +1023,41 @@ DataChannelConnection::HandleOpenRequestMessage(const struct rtcweb_datachannel_
   }
   prValue = ntohs(req->reliability_params);
   flags = ntohs(req->flags) & DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED;
+
+  if ((channel = FindChannelByStream(stream))) {
+    if (!(channel->mFlags & DATA_CHANNEL_FLAGS_EXTERNAL_NEGOTIATED)) {
+      LOG(("ERROR: HandleOpenRequestMessage: channel for stream %u is in state %d instead of CLOSED.",
+           stream, channel->mState));
+     /* XXX: some error handling */
+    } else {
+      LOG(("Open for externally negotiated channel %u", stream));
+      // XXX should also check protocol, maybe label
+      if (prPolicy != channel->mPrPolicy ||
+          prValue != channel->mPrValue ||
+          flags != (channel->mFlags & DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED))
+      {
+        LOG(("WARNING: external negotiation mismatch with OpenRequest:"
+             "channel %u, policy %u/%u, value %u/%u, flags %x/%x",
+             stream, prPolicy, channel->mPrPolicy,
+             prValue, channel->mPrValue, flags, channel->mFlags));
+      }
+    }
+    return;
+  }
   channel = new DataChannel(this,
                             stream,
                             DataChannel::CONNECTING,
                             label,
+                            protocol,
                             prPolicy, prValue,
                             flags,
                             nullptr, nullptr);
   mStreams[stream] = channel;
 
   channel->mState = DataChannel::WAITING_TO_OPEN;
 
-  LOG(("%s: sending ON_CHANNEL_CREATED for %s: %u", __FUNCTION__,
-       channel->mLabel.get(), stream));
+  LOG(("%s: sending ON_CHANNEL_CREATED for %s/%s: %u", __FUNCTION__,
+       channel->mLabel.get(), channel->mProtocol.get(), stream));
   NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
                             DataChannelOnMessageAvailable::ON_CHANNEL_CREATED,
                             this, channel));
@@ -1691,15 +1715,20 @@ DataChannelConnection::ReceiveCallback(struct socket* sock, void *data, size_t d
 }
 
 already_AddRefed<DataChannel>
-DataChannelConnection::Open(const nsACString& label, Type type, bool inOrder,
+DataChannelConnection::Open(const nsACString& label, const nsACString& protocol,
+                            Type type, bool inOrder,
                             uint32_t prValue, DataChannelListener *aListener,
-                            nsISupports *aContext)
+                            nsISupports *aContext, bool aExternalNegotiated,
+                            uint16_t aStream)
 {
+  // aStream == INVALID_STREAM to have the protocol allocate
   uint16_t prPolicy = SCTP_PR_SCTP_NONE;
   uint32_t flags;
 
-  LOG(("DC Open: label %s, type %u, inorder %d, prValue %u, listener %p, context %p",
-       PromiseFlatCString(label).get(), type, inOrder, prValue, aListener, aContext));
+  LOG(("DC Open: label %s/%s, type %u, inorder %d, prValue %u, listener %p, context %p, external: %s, stream %u",
+       PromiseFlatCString(label).get(), PromiseFlatCString(protocol).get(),
+       type, inOrder, prValue, aListener, aContext,
+       aExternalNegotiated ? "true" : "false", aStream));
   switch (type) {
     case DATA_CHANNEL_RELIABLE:
       prPolicy = SCTP_PR_SCTP_NONE;
@@ -1715,13 +1744,24 @@ DataChannelConnection::Open(const nsACString& label, Type type, bool inOrder,
     return nullptr;
   }
 
+  if (aStream != INVALID_STREAM && mStreams[aStream]) {
+    LOG(("ERROR: external negotiation of already-open channel %u", aStream));
+    // XXX How do we indicate this up to the application?  Probably the
+    // caller's job, but we may need to return an error code.
+    return nullptr;
+  }
+
   flags = !inOrder ? DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED : 0;
   nsRefPtr<DataChannel> channel(new DataChannel(this,
-                                                INVALID_STREAM,
+                                                aStream,
                                                 DataChannel::CONNECTING,
-                                                label, type, prValue,
+                                                label, protocol,
+                                                type, prValue,
                                                 flags,
                                                 aListener, aContext));
+  if (aExternalNegotiated) {
+    channel->mFlags |= DATA_CHANNEL_FLAGS_EXTERNAL_NEGOTIATED;
+  }
 
   MutexAutoLock lock(mLock); // OpenFinish assumes this
   return OpenFinish(channel.forget());
@@ -1731,38 +1771,42 @@ DataChannelConnection::Open(const nsACString& label, Type type, bool inOrder,
 already_AddRefed<DataChannel>
 DataChannelConnection::OpenFinish(already_AddRefed<DataChannel> aChannel)
 {
-  uint16_t stream = FindFreeStream(); // may be INVALID_STREAM!
   nsRefPtr<DataChannel> channel(aChannel);
+  uint16_t stream = channel->mStream;
 
-  mLock.AssertCurrentThreadOwns();
+  if (stream == INVALID_STREAM) {
+    stream = FindFreeStream(); // may be INVALID_STREAM!
 
-  LOG(("Finishing open: channel %p, stream = %u", channel.get(), stream));
+    mLock.AssertCurrentThreadOwns();
 
-  if (stream == INVALID_STREAM) {
-    if (!RequestMoreStreams()) {
-      channel->mState = CLOSED;
-      if (channel->mFlags & DATA_CHANNEL_FLAGS_FINISH_OPEN) {
-        // We already returned the channel to the app.
-        NS_ERROR("Failed to request more streams");
-        NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
-                                  DataChannelOnMessageAvailable::ON_CHANNEL_CLOSED, this,
-                                  channel));
-        return channel.forget();
+    LOG(("Finishing open: channel %p, stream = %u", channel.get(), stream));
+
+    if (stream == INVALID_STREAM) {
+      if (!RequestMoreStreams()) {
+        channel->mState = CLOSED;
+        if (channel->mFlags & DATA_CHANNEL_FLAGS_FINISH_OPEN) {
+          // We already returned the channel to the app.
+          NS_ERROR("Failed to request more streams");
+          NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
+                                    DataChannelOnMessageAvailable::ON_CHANNEL_CLOSED, this,
+                                    channel));
+          return channel.forget();
+        }
+        // we'll be destroying the channel, but it never really got set up
+        // Alternative would be to RUN_ON_THREAD(channel.forget(),::Destroy,...) and
+        // Dispatch it to ourselves
+        return nullptr;
       }
-      // we'll be destroying the channel, but it never really got set up
-      // Alternative would be to RUN_ON_THREAD(channel.forget(),::Destroy,...) and
-      // Dispatch it to ourselves
-      return nullptr;
+      LOG(("Queuing channel %p to finish open", channel.get()));
+      // Also serves to mark we told the app
+      channel->mFlags |= DATA_CHANNEL_FLAGS_FINISH_OPEN;
+      channel->AddRef(); // we need a ref for the nsDeQue and one to return
+      mPending.Push(channel);
+      return channel.forget();
     }
-    LOG(("Queuing channel %p to finish open", channel.get()));
-    // Also serves to mark we told the app
-    channel->mFlags |= DATA_CHANNEL_FLAGS_FINISH_OPEN;
-    channel->AddRef(); // we need a ref for the nsDeQue and one to return
-    mPending.Push(channel);
-    return channel.forget();
+    channel->mStream = stream;
   }
   mStreams[stream] = channel;
-  channel->mStream = stream;
 
 #ifdef TEST_QUEUED_DATA
   // It's painful to write a test for this...
@@ -1771,38 +1815,45 @@ DataChannelConnection::OpenFinish(already_AddRefed<DataChannel> aChannel)
   SendMsgInternal(channel, "Help me!", 8, DATA_CHANNEL_PPID_DOMSTRING);
 #endif
 
-  if (!SendOpenRequestMessage(channel->mLabel, stream,
-                              !!(channel->mFlags & DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED),
-                              channel->mPrPolicy, channel->mPrValue)) {
-    LOG(("SendOpenRequest failed, errno = %d", errno));
-    if (errno == EAGAIN || errno == EWOULDBLOCK) {
-      channel->mFlags |= DATA_CHANNEL_FLAGS_SEND_REQ;
-      StartDefer();
-    } else {
-      if (channel->mFlags & DATA_CHANNEL_FLAGS_FINISH_OPEN) {
-        // We already returned the channel to the app.
-        NS_ERROR("Failed to send open request");
-        NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
-                                  DataChannelOnMessageAvailable::ON_CHANNEL_CLOSED, this,
-                                  channel));
+  if (!(channel->mFlags & DATA_CHANNEL_FLAGS_EXTERNAL_NEGOTIATED)) {
+    if (!SendOpenRequestMessage(channel->mLabel, channel->mProtocol,
+                                stream,
+                                !!(channel->mFlags & DATA_CHANNEL_FLAG_OUT_OF_ORDER_ALLOWED),
+                                channel->mPrPolicy, channel->mPrValue)) {
+      LOG(("SendOpenRequest failed, errno = %d", errno));
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        channel->mFlags |= DATA_CHANNEL_FLAGS_SEND_REQ;
+        StartDefer();
+
+        return channel.forget();
+      } else {
+        if (channel->mFlags & DATA_CHANNEL_FLAGS_FINISH_OPEN) {
+          // We already returned the channel to the app.
+          NS_ERROR("Failed to send open request");
+          NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
+                                    DataChannelOnMessageAvailable::ON_CHANNEL_CLOSED, this,
+                                    channel));
+        }
+        // If we haven't returned the channel yet, it will get destroyed when we exit
+        // this function.
+        mStreams[stream] = nullptr;
+        channel->mStream = INVALID_STREAM;
+        // we'll be destroying the channel
+        channel->mState = CLOSED;
+        return nullptr;
       }
-      // If we haven't returned the channel yet, it will get destroyed when we exit
-      // this function.
-      mStreams[stream] = nullptr;
-      channel->mStream = INVALID_STREAM;
-      // we'll be destroying the channel
-      channel->mState = CLOSED;
-      return nullptr;
+      /* NOTREACHED */
     }
-  } else {
-    channel->mState = OPEN;
-    channel->mReady = true;
-    // FIX?  Move into DOMDataChannel?  I don't think we can send it yet here
-    LOG(("%s: sending ON_CHANNEL_OPEN for %p", __FUNCTION__, channel.get()));
-    NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
-                              DataChannelOnMessageAvailable::ON_CHANNEL_OPEN, this,
-                              channel));
   }
+  // Either externally negotiated or we sent Open
+  channel->mState = OPEN;
+  channel->mReady = true;
+  // FIX?  Move into DOMDataChannel?  I don't think we can send it yet here
+  LOG(("%s: sending ON_CHANNEL_OPEN for %p", __FUNCTION__, channel.get()));
+  NS_DispatchToMainThread(new DataChannelOnMessageAvailable(
+                            DataChannelOnMessageAvailable::ON_CHANNEL_OPEN, this,
+                            channel));
+
   return channel.forget();
 }
 
diff --git a/netwerk/sctp/datachannel/DataChannel.h b/netwerk/sctp/datachannel/DataChannel.h
@@ -163,10 +163,13 @@ class DataChannelConnection: public nsITimerCallback
   } Type;
 
   already_AddRefed<DataChannel> Open(const nsACString& label,
+                                     const nsACString& protocol,
                                      Type type, bool inOrder,
                                      uint32_t prValue,
                                      DataChannelListener *aListener,
-                                     nsISupports *aContext);
+                                     nsISupports *aContext,
+                                     bool aExternalNegotiated,
+                                     uint16_t aStream);
 
   void Close(DataChannel *aChannel);
   // CloseInt() must be called with mLock held
@@ -219,7 +222,8 @@ class DataChannelConnection: public nsITimerCallback
   uint16_t FindFreeStream();
   bool RequestMoreStreams(int32_t aNeeded = 16);
   int32_t SendControlMessage(void *msg, uint32_t len, uint16_t streamOut);
-  int32_t SendOpenRequestMessage(const nsACString& label,uint16_t streamOut,
+  int32_t SendOpenRequestMessage(const nsACString& label, const nsACString& protocol,
+                                 uint16_t streamOut,
                                  bool unordered, uint16_t prPolicy, uint32_t prValue);
   int32_t SendMsgInternal(DataChannel *channel, const char *data,
                           uint32_t length, uint32_t ppid);
@@ -314,6 +318,7 @@ class DataChannel {
               uint16_t stream,
               uint16_t state,
               const nsACString& label,
+              const nsACString& protocol,
               uint16_t policy, uint32_t value,
               uint32_t flags,
               DataChannelListener *aListener,
@@ -323,6 +328,7 @@ class DataChannel {
     , mContext(aContext)
     , mConnection(connection)
     , mLabel(label)
+    , mProtocol(protocol)
     , mState(state)
     , mReady(false)
     , mStream(stream)
@@ -396,6 +402,8 @@ class DataChannel {
   void SetReadyState(uint16_t aState) { mState = aState; }
 
   void GetLabel(nsAString& aLabel) { CopyUTF8toUTF16(mLabel, aLabel); }
+  void GetProtocol(nsAString& aProtocol) { CopyUTF8toUTF16(mProtocol, aProtocol); }
+  void GetStream(uint16_t *aStream) { *aStream = mStream; }
 
   void AppReady();
 
@@ -414,6 +422,7 @@ class DataChannel {
 
   nsRefPtr<DataChannelConnection> mConnection;
   nsCString mLabel;
+  nsCString mProtocol;
   uint16_t mState;
   bool     mReady;
   uint16_t mStream;
diff --git a/netwerk/sctp/datachannel/DataChannelProtocol.h b/netwerk/sctp/datachannel/DataChannelProtocol.h
