node-datachannel 0.10.1 → 0.12.0

package/polyfill/RTCPeerConnection.js

@@ -1,10 +1,11 @@
+import 'node-domexception';
 import NodeDataChannel from '../lib/index.js';
 import RTCSessionDescription from './RTCSessionDescription.js';
 import RTCDataChannel from './RTCDataChannel.js';
 import RTCIceCandidate from './RTCIceCandidate.js';
 import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
 import RTCSctpTransport from './RTCSctpTransport.js';
-import 'node-domexception';
+import * as exceptions from './Exception.js';
 
 export default class _RTCPeerConnection extends EventTarget {
     static async generateCertificate() {
@@ -15,6 +16,7 @@ export default class _RTCPeerConnection extends EventTarget {
     #localOffer;
     #localAnswer;
     #dataChannels;
+    #dataChannelsClosed = 0;
     #config;
     #canTrickleIceCandidates;
     #sctp;
@@ -32,32 +34,106 @@ export default class _RTCPeerConnection extends EventTarget {
     onsignalingstatechange;
     ontrack;
 
-    constructor(init = {}) {
+    _checkConfiguration(config) {
+        if (config && config.iceServers === undefined) config.iceServers = [];
+        if (config && config.iceTransportPolicy === undefined) config.iceTransportPolicy = 'all';
+
+        if (config?.iceServers === null) throw new TypeError('IceServers cannot be null');
+
+        // Check for all the properties of iceServers
+        if (Array.isArray(config?.iceServers)) {
+            for (let i = 0; i < config.iceServers.length; i++) {
+                if (config.iceServers[i] === null) throw new TypeError('IceServers cannot be null');
+                if (config.iceServers[i] === undefined) throw new TypeError('IceServers cannot be undefined');
+                if (Object.keys(config.iceServers[i]).length === 0) throw new TypeError('IceServers cannot be empty');
+
+                // If iceServers is string convert to array
+                if (typeof config.iceServers[i].urls === 'string')
+                    config.iceServers[i].urls = [config.iceServers[i].urls];
+
+                // urls can not be empty
+                if (config.iceServers[i].urls?.some((url) => url == ''))
+                    throw exceptions.SyntaxError('IceServers urls cannot be empty');
+
+                // urls should be valid URLs and match the protocols "stun:|turn:|turns:"
+                if (
+                    config.iceServers[i].urls?.some(
+                        (url) => {
+                            try {
+                                const parsedURL = new URL(url)
+
+                                return !/^(stun:|turn:|turns:)$/.test(parsedURL.protocol)
+                            } catch (error) {
+                                return true
+                            }
+                        },
+                    )
+                )
+                    throw exceptions.SyntaxError('IceServers urls wrong format');
+
+                // If this is a turn server check for username and credential
+                if (config.iceServers[i].urls?.some((url) => url.startsWith('turn'))) {
+                    if (!config.iceServers[i].username)
+                        throw exceptions.InvalidAccessError('IceServers username cannot be null');
+                    if (!config.iceServers[i].credential)
+                        throw exceptions.InvalidAccessError('IceServers username cannot be undefined');
+                }
+
+                // length of urls can not be 0
+                if (config.iceServers[i].urls?.length === 0)
+                    throw exceptions.SyntaxError('IceServers urls cannot be empty');
+            }
+        }
+
+        if (
+            config &&
+            config.iceTransportPolicy &&
+            config.iceTransportPolicy !== 'all' &&
+            config.iceTransportPolicy !== 'relay'
+        )
+            throw new TypeError('IceTransportPolicy must be either "all" or "relay"');
+    }
+
+    setConfiguration(config) {
+        this._checkConfiguration(config);
+        this.#config = config;
+    }
+
+    constructor(config = { iceServers: [], iceTransportPolicy: 'all' }) {
         super();
 
-        this.#config = init;
+        this._checkConfiguration(config);
+        this.#config = config;
         this.#localOffer = createDeferredPromise();
         this.#localAnswer = createDeferredPromise();
         this.#dataChannels = new Set();
         this.#canTrickleIceCandidates = null;
 
-        this.#peerConnection = new NodeDataChannel.PeerConnection(init?.peerIdentity ?? `peer-${getRandomString(7)}`, {
-            ...init,
-            iceServers:
-                init?.iceServers
-                    ?.map((server) => {
-                        const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-
-                        return urls.map((url) => {
-                            if (server.username && server.credential) {
-                                const [protocol, rest] = url.split(/:(.*)/);
-                                return `${protocol}:${server.username}:${server.credential}@${rest}`;
-                            }
-                            return url;
-                        });
-                    })
-                    .flat() ?? [],
-        });
+        try {
+            this.#peerConnection = new NodeDataChannel.PeerConnection(
+                config?.peerIdentity ?? `peer-${getRandomString(7)}`,
+                {
+                    ...config,
+                    iceServers:
+                        config?.iceServers
+                            ?.map((server) => {
+                                const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+
+                                return urls.map((url) => {
+                                    if (server.username && server.credential) {
+                                        const [protocol, rest] = url.split(/:(.*)/);
+                                        return `${protocol}:${server.username}:${server.credential}@${rest}`;
+                                    }
+                                    return url;
+                                });
+                            })
+                            .flat() ?? [],
+                },
+            );
+        } catch (error) {
+            if (!error || !error.message) throw exceptions.NotFoundError('Unknown error');
+            throw exceptions.SyntaxError(error.message);
+        }
 
         // forward peerConnection events
         this.#peerConnection.onStateChange(() => {
@@ -77,9 +153,9 @@ export default class _RTCPeerConnection extends EventTarget {
         });
 
         this.#peerConnection.onDataChannel((channel) => {
-            const dataChannel = new RTCDataChannel(channel);
-            this.#dataChannels.add(dataChannel);
-            this.dispatchEvent(new RTCDataChannelEvent(dataChannel));
+            const dc = new RTCDataChannel(channel);
+            this.#dataChannels.add(dc);
+            this.dispatchEvent(new RTCDataChannelEvent('datachannel', { channel: dc }));
         });
 
         this.#peerConnection.onLocalDescription((sdp, type) => {
@@ -153,7 +229,11 @@ export default class _RTCPeerConnection extends EventTarget {
     }
 
     get iceConnectionState() {
-        return this.#peerConnection.iceState();
+        let state = this.#peerConnection.iceState();
+        // libdatachannel uses 'completed' instead of 'connected'
+        // see /webrtc/getstats.html
+        if (state == 'completed') state = 'connected';
+        return state;
     }
 
     get iceGatheringState() {
@@ -193,14 +273,45 @@ export default class _RTCPeerConnection extends EventTarget {
     }
 
     async addIceCandidate(candidate) {
-        if (candidate == null || candidate.candidate == null) {
-            throw new DOMException('Candidate invalid');
+        if (!candidate || !candidate.candidate) {
+            return;
+        }
+
+        if (candidate.sdpMid === null && candidate.sdpMLineIndex === null) {
+            throw new TypeError('sdpMid must be set');
         }
 
-        this.#remoteCandidates.push(
-            new RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
-        );
-        this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+        if (candidate.sdpMid === undefined && candidate.sdpMLineIndex == undefined) {
+            throw new TypeError('sdpMid must be set');
+        }
+
+        // Reject if sdpMid format is not valid
+        // ??
+        if (candidate.sdpMid && candidate.sdpMid.length > 3) {
+            // console.log(candidate.sdpMid);
+            throw exceptions.OperationError('Invalid sdpMid format');
+        }
+
+        // We don't care about sdpMLineIndex, just for test
+        if (!candidate.sdpMid && candidate.sdpMLineIndex > 1) {
+            throw exceptions.OperationError('This is only for test case.');
+        }
+
+        try {
+            this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+            this.#remoteCandidates.push(
+                new RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
+            );
+        } catch (error) {
+            if (!error || !error.message) throw exceptions.NotFoundError('Unknown error');
+
+            // Check error Message if contains specific message
+            if (error.message.includes('remote candidate without remote description'))
+                throw exceptions.InvalidStateError(error.message);
+            if (error.message.includes('Invalid candidate format')) throw exceptions.OperationError(error.message);
+
+            throw exceptions.NotFoundError(error.message);
+        }
     }
 
     addTrack(track, ...streams) {
@@ -215,6 +326,7 @@ export default class _RTCPeerConnection extends EventTarget {
         // close all channels before shutting down
         this.#dataChannels.forEach((channel) => {
             channel.close();
+            this.#dataChannelsClosed++;
         });
 
         this.#peerConnection.close();
@@ -232,6 +344,7 @@ export default class _RTCPeerConnection extends EventTarget {
         this.#dataChannels.add(dataChannel);
         dataChannel.addEventListener('close', () => {
             this.#dataChannels.delete(dataChannel);
+            this.#dataChannelsClosed++;
         });
 
         return dataChannel;
@@ -265,7 +378,7 @@ export default class _RTCPeerConnection extends EventTarget {
             let localId = 'RTCIceCandidate_' + localIdRs;
             report.set(localId, {
                 id: localId,
-                type: 'localcandidate',
+                type: 'local-candidate',
                 timestamp: Date.now(),
                 candidateType: cp.local.type,
                 ip: cp.local.address,
@@ -276,7 +389,7 @@ export default class _RTCPeerConnection extends EventTarget {
             let remoteId = 'RTCIceCandidate_' + remoteIdRs;
             report.set(remoteId, {
                 id: remoteId,
-                type: 'remotecandidate',
+                type: 'remote-candidate',
                 timestamp: Date.now(),
                 candidateType: cp.remote.type,
                 ip: cp.remote.address,
@@ -311,6 +424,15 @@ export default class _RTCPeerConnection extends EventTarget {
                 selectedCandidatePairChanges: 1,
             });
 
+            // peer-connection'
+            report.set('P', {
+                id: 'P',
+                type: 'peer-connection',
+                timestamp: Date.now(),
+                dataChannelsOpened: this.#dataChannels.size,
+                dataChannelsClosed: this.#dataChannelsClosed,
+            });
+
             return resolve(report);
         });
     }
@@ -327,20 +449,13 @@ export default class _RTCPeerConnection extends EventTarget {
         throw new DOMException('Not implemented');
     }
 
-    setConfiguration(config) {
-        this.#config = config;
-    }
-
     async setLocalDescription(description) {
-        if (description == null || description.type == null) {
-            throw new DOMException('Local description type must be set');
-        }
-
-        if (description.type !== 'offer') {
+        if (description?.type !== 'offer') {
             // any other type causes libdatachannel to throw
             return;
         }
-        this.#peerConnection.setLocalDescription(description.type);
+
+        this.#peerConnection.setLocalDescription(description?.type);
     }
 
     async setRemoteDescription(description) {