Add DTLS, ICE and SCTP Transport to WASM

Only available in the browser, not in wrtc yet.

Resolves #2099

Author: Sean-Der

dtlstransport_js.go

@@ -0,0 +1,28 @@
+//go:build js && wasm
+// +build js,wasm
+
+package webrtc
+
+import "syscall/js"
+
+// DTLSTransport allows an application access to information about the DTLS
+// transport over which RTP and RTCP packets are sent and received by
+// RTPSender and RTPReceiver, as well other data such as SCTP packets sent
+// and received by data channels.
+type DTLSTransport struct {
+	// Pointer to the underlying JavaScript DTLSTransport object.
+	underlying js.Value
+}
+
+// ICETransport returns the currently-configured *ICETransport or nil
+// if one has not been configured
+func (r *DTLSTransport) ICETransport() *ICETransport {
+	underlying := r.underlying.Get("iceTransport")
+	if underlying.IsNull() || underlying.IsUndefined() {
+		return nil
+	}
+
+	return &ICETransport{
+		underlying: underlying,
+	}
+}

examples/data-channels/jsfiddle/main.go

@@ -35,6 +35,11 @@ func main() {
 	})
 	sendChannel.OnOpen(func() {
 		fmt.Println("sendChannel has opened")
+
+		candidatePair, err := pc.SCTP().Transport().ICETransport().GetSelectedCandidatePair()
+
+		fmt.Println(candidatePair)
+		fmt.Println(err)
 	})
 	sendChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
 		log(fmt.Sprintf("Message from DataChannel %s payload %s", sendChannel.Label(), string(msg.Data)))
@@ -93,6 +98,33 @@ func main() {
 		}()
 		return js.Undefined()
 	}))
+	js.Global().Set("copySDP", js.FuncOf(func(_ js.Value, _ []js.Value) interface{} {
+		go func() {
+			defer func() {
+				if e := recover(); e != nil {
+					switch e := e.(type) {
+					case error:
+						handleError(e)
+					default:
+						handleError(fmt.Errorf("recovered with non-error value: (%T) %s", e, e))
+					}
+				}
+			}()
+
+			browserSDP := getElementByID("localSessionDescription")
+
+			browserSDP.Call("focus")
+			browserSDP.Call("select")
+
+			copyStatus := js.Global().Get("document").Call("execCommand", "copy")
+			if copyStatus.Bool() {
+				log("Copying SDP was successful")
+			} else {
+				log("Copying SDP was unsuccessful")
+			}
+		}()
+		return js.Undefined()
+	}))
 
 	// Stay alive
 	select {}

icetransport_js.go

@@ -0,0 +1,27 @@
+//go:build js && wasm
+// +build js,wasm
+
+package webrtc
+
+import "syscall/js"
+
+// ICETransport allows an application access to information about the ICE
+// transport over which packets are sent and received.
+type ICETransport struct {
+	// Pointer to the underlying JavaScript ICETransport object.
+	underlying js.Value
+}
+
+// GetSelectedCandidatePair returns the selected candidate pair on which packets are sent
+// if there is no selected pair nil is returned
+func (t *ICETransport) GetSelectedCandidatePair() (*ICECandidatePair, error) {
+	val := t.underlying.Call("getSelectedCandidatePair")
+	if val.IsNull() || val.IsUndefined() {
+		return nil, nil
+	}
+
+	return NewICECandidatePair(
+		valueToICECandidate(val.Get("local")),
+		valueToICECandidate(val.Get("remote")),
+	), nil
+}

peerconnection_js.go

@@ -523,6 +523,21 @@ func (pc *PeerConnection) GetTransceivers() (transceivers []*RTPTransceiver) {
 	return
 }
 
+// SCTP returns the SCTPTransport for this PeerConnection
+//
+// The SCTP transport over which SCTP data is sent and received. If SCTP has not been negotiated, the value is nil.
+// https://www.w3.org/TR/webrtc/#attributes-15
+func (pc *PeerConnection) SCTP() *SCTPTransport {
+	underlying := pc.underlying.Get("sctp")
+	if underlying.IsNull() || underlying.IsUndefined() {
+		return nil
+	}
+
+	return &SCTPTransport{
+		underlying: underlying,
+	}
+}
+
 // Converts a Configuration to js.Value so it can be passed
 // through to the JavaScript WebRTC API. Any zero values are converted to
 // js.Undefined(), which will result in the default value being used.

peerconnection_test.go

@@ -83,6 +83,24 @@ func offerMediaHasDirection(offer SessionDescription, kind RTPCodecType, directi
 	return false
 }
 
+func untilConnectionState(state PeerConnectionState, peers ...*PeerConnection) *sync.WaitGroup {
+	var triggered sync.WaitGroup
+	triggered.Add(len(peers))
+
+	for _, p := range peers {
+		done := false
+		hdlr := func(p PeerConnectionState) {
+			if !done && p == state {
+				done = true
+				triggered.Done()
+			}
+		}
+
+		p.OnConnectionStateChange(hdlr)
+	}
+	return &triggered
+}
+
 func TestNew(t *testing.T) {
 	pc, err := NewPeerConnection(Configuration{
 		ICEServers: []ICEServer{
@@ -716,3 +734,17 @@ func TestAddTransceiver(t *testing.T) {
 		assert.NoError(t, pc.Close())
 	}
 }
+
+// Assert that SCTPTransport -> DTLSTransport -> ICETransport works after connected
+func TestTransportChain(t *testing.T) {
+	offer, answer, err := newPair()
+	assert.NoError(t, err)
+
+	peerConnectionsConnected := untilConnectionState(PeerConnectionStateConnected, offer, answer)
+	assert.NoError(t, signalPair(offer, answer))
+	peerConnectionsConnected.Wait()
+
+	assert.NotNil(t, offer.SCTP().Transport().ICETransport())
+
+	closePairNow(t, offer, answer)
+}

rtpsender_test.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"errors"
 	"io"
-	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -17,21 +16,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func untilConnectionState(state PeerConnectionState, peers ...*PeerConnection) *sync.WaitGroup {
-	var triggered sync.WaitGroup
-	triggered.Add(len(peers))
-
-	hdlr := func(p PeerConnectionState) {
-		if p == state {
-			triggered.Done()
-		}
-	}
-	for _, p := range peers {
-		p.OnConnectionStateChange(hdlr)
-	}
-	return &triggered
-}
-
 func Test_RTPSender_ReplaceTrack(t *testing.T) {
 	lim := test.TimeOut(time.Second * 10)
 	defer lim.Stop()

sctptransport_js.go

@@ -0,0 +1,24 @@
+//go:build js && wasm
+// +build js,wasm
+
+package webrtc
+
+import "syscall/js"
+
+// SCTPTransport provides details about the SCTP transport.
+type SCTPTransport struct {
+	// Pointer to the underlying JavaScript SCTPTransport object.
+	underlying js.Value
+}
+
+// Transport returns the DTLSTransport instance the SCTPTransport is sending over.
+func (r *SCTPTransport) Transport() *DTLSTransport {
+	underlying := r.underlying.Get("transport")
+	if underlying.IsNull() || underlying.IsUndefined() {
+		return nil
+	}
+
+	return &DTLSTransport{
+		underlying: underlying,
+	}
+}