Merge pull request #44 from jitsi/early-dtls

Fix early DTLS

modules/xmpp/JingleSessionPC.js

@@ -339,31 +339,41 @@ JingleSessionPC.prototype.sendAnswer = function (success, failure) {
 
 JingleSessionPC.prototype.createdAnswer = function (sdp, success, failure) {
     //logger.log('createAnswer callback');
+
     var self = this;
     this.localSDP = new SDP(sdp.sdp);
+
+    this._fixAnswerRFC4145Setup(
+            /* offer */ this.remoteSDP,
+            /* answer */ this.localSDP);
+
     var sendJingle = function (ssrcs) {
-                var accept = $iq({to: self.peerjid,
-                    type: 'set'})
-                    .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
-                        action: 'session-accept',
-                        initiator: self.initiator,
-                        responder: self.responder,
-                        sid: self.sid });
-                if (self.webrtcIceTcpDisable) {
-                    self.localSDP.removeTcpCandidates = true;
-                }
-                if (self.webrtcIceUdpDisable) {
-                    self.localSDP.removeUdpCandidates = true;
-                }
-                self.localSDP.toJingle(
-                    accept,
-                    self.initiator == self.me ? 'initiator' : 'responder',
-                    ssrcs);
-                self.fixJingle(accept);
-                self.connection.sendIQ(accept,
-                    success,
-                    self.newJingleErrorHandler(accept, failure),
-                    IQ_TIMEOUT);
+        var accept
+            = $iq({ to: self.peerjid, type: 'set' })
+                .c('jingle', { xmlns: 'urn:xmpp:jingle:1',
+                               action: 'session-accept',
+                               initiator: self.initiator,
+                               responder: self.responder,
+                               sid: self.sid });
+        if (self.webrtcIceTcpDisable) {
+            self.localSDP.removeTcpCandidates = true;
+        }
+        if (self.webrtcIceUdpDisable) {
+            self.localSDP.removeUdpCandidates = true;
+        }
+        self.localSDP.toJingle(
+                accept,
+                self.initiator == self.me ? 'initiator' : 'responder',
+                ssrcs);
+        self.fixJingle(accept);
+        self.connection.sendIQ(accept,
+                success,
+                self.newJingleErrorHandler(accept, failure),
+                IQ_TIMEOUT);
+        // XXX Videobridge needs WebRTC's answer (ICE ufrag and pwd, DTLS
+        // fingerprint and setup) ASAP in order to start the connection
+        // establishment.
+        self.connection.flush();
     };
     sdp.sdp = this.localSDP.raw;
     this.peerconnection.setLocalDescription(sdp,
@@ -389,6 +399,55 @@ JingleSessionPC.prototype.createdAnswer = function (sdp, success, failure) {
     }
 };
 
+/**
+ * Modifies the values of the setup attributes (defined by
+ * {@link http://tools.ietf.org/html/rfc4145#section-4}) of a specific SDP
+ * answer in order to overcome a delay of 1 second in the connection
+ * establishment between Chrome and Videobridge.
+ *
+ * @param {SDP} offer - the SDP offer to which the specified SDP answer is
+ * being prepared to respond
+ * @param {SDP} answer - the SDP to modify
+ * @private
+ */
+JingleSessionPC.prototype._fixAnswerRFC4145Setup = function (offer, answer) {
+    // XXX Videobridge is the (SDP) offerer and WebRTC (e.g. Chrome) is the
+    // answerer (as orchestrated by Jicofo). In accord with
+    // http://tools.ietf.org/html/rfc5245#section-5.2 and because both peers
+    // are ICE FULL agents, Videobridge will take on the controlling role and
+    // WebRTC will take on the controlled role. In accord with
+    // https://tools.ietf.org/html/rfc5763#section-5, Videobridge will use the
+    // setup attribute value of setup:actpass and WebRTC will be allowed to
+    // choose either the setup attribute value of setup:active or
+    // setup:passive. Chrome will by default choose setup:active because it is
+    // RECOMMENDED by the respective RFC since setup:passive adds additional
+    // latency. The case of setup:active allows WebRTC to send a DTLS
+    // ClientHello as soon as an ICE connectivity check of its succeeds.
+    // Unfortunately, Videobridge will be unable to respond immediately because
+    // may not have WebRTC's answer or may have not completed the ICE
+    // connectivity establishment. Even more unfortunate is that in the
+    // described scenario Chrome's DTLS implementation will insist on
+    // retransmitting its ClientHello after a second (the time is in accord
+    // with the respective RFC) and will thus cause the whole connection
+    // establishment to exceed at least 1 second. To work around Chrome's
+    // idiosyncracy, don't allow it to send a ClientHello i.e. change its
+    // default choice of setup:active to setup:passive.
+    if (offer && answer
+            && offer.media && answer.media
+            && offer.media.length == answer.media.length) {
+        answer.media.forEach(function (a, i) {
+            if (SDPUtil.find_line(
+                    offer.media[i],
+                    'a=setup:actpass',
+                    offer.session)) {
+                answer.media[i]
+                    = a.replace(/a=setup:active/g, 'a=setup:passive');
+            }
+        });
+        answer.raw = answer.session + answer.media.join('');
+    }
+}
+
 JingleSessionPC.prototype.terminate = function (reason,  text,
                                                 success, failure) {
     var term = $iq({to: this.peerjid,

modules/xmpp/SDP.js

@@ -146,8 +146,8 @@ SDP.prototype.toJingle = function (elem, thecreator) {
     var self = this;
     var i, j, k, mline, ssrc, rtpmap, tmp, lines;
     // new bundle plan
-    if (SDPUtil.find_line(this.session, 'a=group:')) {
-        lines = SDPUtil.find_lines(this.session, 'a=group:');
+    lines = SDPUtil.find_lines(this.session, 'a=group:');
+    if (lines.length) {
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
             var semantics = tmp.shift().substr(8);
@@ -166,16 +166,18 @@ SDP.prototype.toJingle = function (elem, thecreator) {
         {
             continue;
         }
-        if (SDPUtil.find_line(this.media[i], 'a=ssrc:')) {
-            ssrc = SDPUtil.find_line(this.media[i], 'a=ssrc:').substring(7).split(' ')[0]; // take the first
+        var assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
+        if (assrcline) {
+            ssrc = assrcline.substring(7).split(' ')[0]; // take the first
         } else {
             ssrc = false;
         }
 
         elem.c('content', {creator: thecreator, name: mline.media});
-        if (SDPUtil.find_line(this.media[i], 'a=mid:')) {
+        var amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
+        if (amidline) {
             // prefer identifier from a=mid if present
-            var mid = SDPUtil.parse_mid(SDPUtil.find_line(this.media[i], 'a=mid:'));
+            var mid = SDPUtil.parse_mid(amidline);
             elem.attrs({ name: mid });
         }
 
@@ -190,8 +192,9 @@ SDP.prototype.toJingle = function (elem, thecreator) {
                 rtpmap = SDPUtil.find_line(this.media[i], 'a=rtpmap:' + mline.fmt[j]);
                 elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
                 // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo value=bar/>
-                if (SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j])) {
-                    tmp = SDPUtil.parse_fmtp(SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]));
+                var afmtpline = SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]);
+                if (afmtpline) {
+                    tmp = SDPUtil.parse_fmtp(afmtpline);
                     for (k = 0; k < tmp.length; k++) {
                         elem.c('parameter', tmp[k]).up();
                     }
@@ -200,9 +203,9 @@ SDP.prototype.toJingle = function (elem, thecreator) {
 
                 elem.up();
             }
-            if (SDPUtil.find_line(this.media[i], 'a=crypto:', this.session)) {
+            var crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+            if (crypto.length) {
                 elem.c('encryption', {required: 1});
-                var crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
                 crypto.forEach(function(line) {
                     elem.c('crypto', SDPUtil.parse_crypto(line)).up();
                 });
@@ -293,8 +296,8 @@ SDP.prototype.toJingle = function (elem, thecreator) {
             this.rtcpFbToJingle(i, elem, '*');
 
             // XEP-0294
-            if (SDPUtil.find_line(this.media[i], 'a=extmap:')) {
-                lines = SDPUtil.find_lines(this.media[i], 'a=extmap:');
+            lines = SDPUtil.find_lines(this.media[i], 'a=extmap:');
+            if (lines.length) {
                 for (j = 0; j < lines.length; j++) {
                     tmp = SDPUtil.parse_extmap(lines[j]);
                     elem.c('rtp-hdrext', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
@@ -351,24 +354,19 @@ SDP.prototype.transportToJingle = function (mediaindex, elem) {
     elem.c('transport');
 
     // XEP-0343 DTLS/SCTP
-    if (SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:').length)
-    {
-        sctpmap = SDPUtil.find_line(
-            this.media[mediaindex], 'a=sctpmap:', self.session);
-        if (sctpmap)
-        {
-            sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
-            elem.c('sctpmap',
-                {
-                    xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
-                    number: sctpAttrs[0], /* SCTP port */
-                    protocol: sctpAttrs[1] /* protocol */
-                });
-            // Optional stream count attribute
-            if (sctpAttrs.length > 2)
-                elem.attrs({ streams: sctpAttrs[2]});
-            elem.up();
-        }
+    sctpmap
+        = SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:', self.session);
+    if (sctpmap) {
+        sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
+        elem.c('sctpmap', {
+                xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
+                number: sctpAttrs[0], /* SCTP port */
+                protocol: sctpAttrs[1] /* protocol */
+            });
+        // Optional stream count attribute
+        if (sctpAttrs.length > 2)
+            elem.attrs({ streams: sctpAttrs[2]});
+        elem.up();
     }
     // XEP-0320
     fingerprints = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);

modules/xmpp/SDPUtil.js

@@ -8,11 +8,12 @@ SDPUtil = {
     },
     iceparams: function (mediadesc, sessiondesc) {
         var data = null;
-        if (SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc) &&
-            SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc)) {
+        var ufrag, pwd;
+        if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
+                && (pwd = SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))) {
             data = {
-                ufrag: SDPUtil.parse_iceufrag(SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc)),
-                pwd: SDPUtil.parse_icepwd(SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))
+                ufrag: SDPUtil.parse_iceufrag(ufrag),
+                pwd: SDPUtil.parse_icepwd(pwd)
             };
         }
         return data;