node-datachannel 0.5.0-dev → 0.5.1

package/examples/electron-demo/package.json

@@ -28,13 +28,13 @@
         "@electron/rebuild": "^3.3.0",
         "@vercel/webpack-asset-relocator-loader": "^1.7.3",
         "css-loader": "^6.8.1",
-        "electron": "26.2.0",
+        "electron": "26.2.4",
         "node-loader": "^2.0.0",
         "style-loader": "^3.3.3"
     },
     "dependencies": {
         "electron-squirrel-startup": "^1.0.0",
-        "node-datachannel": "0.5.0"
+        "node-datachannel": "0.5.0-dev"
     },
     "cmake-js": {
         "runtime": "electron",

package/lib/index.d.ts

@@ -98,6 +98,9 @@ export interface SelectedCandidateInfo {
     port: number;
     type: string;
     transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
 }
 
 // Must be same as rtc enum class Direction
@@ -232,6 +235,8 @@ export class PeerConnection {
     bytesReceived(): number;
     rtt(): number;
     getSelectedCandidatePair(): { local: SelectedCandidateInfo; remote: SelectedCandidateInfo } | null;
+    maxDataChannelId(): number;
+    maxMessageSize(): number;
 }
 
 export class DataChannelStream extends stream.Duplex {

package/lib/index.js

@@ -3,6 +3,37 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 const nodeDataChannel = require('../build/Release/node_datachannel.node');
+import DataChannelStream from './datachannel-stream.js';
 
-export default nodeDataChannel;
-export { default as DataChannelStream } from './datachannel-stream.js';
+const {
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+} = nodeDataChannel;
+
+export {
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+    // Extra exports
+    DataChannelStream,
+};
+
+export default {
+    ...nodeDataChannel,
+    DataChannelStream,
+};

package/package.json

@@ -1,15 +1,11 @@
 {
     "name": "node-datachannel",
-    "version": "0.5.0-dev",
+    "version": "0.5.1",
     "description": "libdatachannel node bindings",
     "type": "module",
     "exports": {
-        ".": {
-            "import": "./lib/index.js"
-        },
-        "./polyfill": {
-            "import": "./polyfill/index.js"
-        }
+        ".": "./lib/index.js",
+        "./polyfill": "./polyfill/index.js"
     },
     "typings": "lib/index.d.ts",
     "engines": {
@@ -60,7 +56,6 @@
         }
     ],
     "license": "MPL 2.0",
-    "gypfile": true,
     "bugs": {
         "url": "https://github.com/murat-dogan/node-datachannel/issues"
     },
@@ -79,9 +74,6 @@
         "prettier": "^2.8.8",
         "typescript": "^4.6.3"
     },
-    "bundledDependencies": [
-        "prebuild-install"
-    ],
     "dependencies": {
         "node-domexception": "^2.0.1",
         "prebuild-install": "^7.0.1"

package/polyfill/RTCDtlsTransport.js

@@ -1,12 +1,29 @@
+import RTCIceTransport from './RTCIceTransport.js';
+
 export default class _RTCDtlsTransport extends EventTarget {
+    #pc = null;
+    #extraFunctions = null;
     #iceTransport = null;
-    #state = null;
 
-    onerror = createEmptyFunction();
-    onstatechange = createEmptyFunction();
+    onerror = null;
+    onstatechange = null;
 
-    constructor() {
+    constructor({ pc, extraFunctions }) {
         super();
+        this.#pc = pc;
+        this.#extraFunctions = extraFunctions;
+
+        this.#iceTransport = new RTCIceTransport({ pc, extraFunctions });
+
+        // forward peerConnection events
+        this.#pc.addEventListener('connectionstatechange', () => {
+            this.dispatchEvent(new Event('statechange'));
+        });
+
+        // forward events to properties
+        this.addEventListener('statechange', (e) => {
+            if (this.onstatechange) this.onstatechange(e);
+        });
     }
 
     get iceTransport() {
@@ -14,16 +31,17 @@ export default class _RTCDtlsTransport extends EventTarget {
     }
 
     get state() {
-        return this.#state;
+        // reduce state from new, connecting, connected, disconnected, failed, closed, unknown
+        // to RTCDtlsTRansport states new, connecting, connected, closed, failed
+        let state = this.#pc ? this.#pc.connectionState : 'new';
+        if (state === 'disconnected' || state === 'unknown') {
+            state = 'closed';
+        }
+        return state;
     }
 
     getRemoteCertificates() {
-        /** */
+        // TODO: implement
+        return new ArrayBuffer(0);
     }
 }
-
-function createEmptyFunction() {
-    return () => {
-        /** */
-    };
-}

package/polyfill/RTCIceCandidate.js

@@ -34,7 +34,7 @@ export default class _RTCIceCandidate {
         if (candidate) {
             const fields = candidate.split(' ');
             this.#foundation = fields[0];
-            this.#component = fields[1];
+            this.#component = fields[1] == '1' ? 'rtp' : 'rtcp';
             this.#protocol = fields[2];
             this.#priority = parseInt(fields[3], 10);
             this.#ip = fields[4];

package/polyfill/RTCIceTransport.js

@@ -1,34 +1,55 @@
+import RTCIceCandidate from './RTCIceCandidate.js';
+
 export default class _RTCIceTransport extends EventTarget {
-    #component = null;
-    #gatheringState = null;
-    #role = null;
-    #state = null;
+    #pc = null;
+    #extraFunctions = null;
 
-    ongatheringstatechange = createEmptyFunction();
-    onselectedcandidatepairchange = createEmptyFunction();
-    onstatechange = createEmptyFunction();
+    ongatheringstatechange = null;
+    onselectedcandidatepairchange = null;
+    onstatechange = null;
 
-    constructor() {
+    constructor({ pc, extraFunctions }) {
         super();
+        this.#pc = pc;
+        this.#extraFunctions = extraFunctions;
+
+        // forward peerConnection events
+        this.#pc.addEventListener('icegatheringstatechange', () => {
+            this.dispatchEvent(new Event('gatheringstatechange'));
+        });
+        this.#pc.addEventListener('iceconnectionstatechange', () => {
+            this.dispatchEvent(new Event('statechange'));
+        });
+
+        // forward events to properties
+        this.addEventListener('gatheringstatechange', (e) => {
+            if (this.ongatheringstatechange) this.ongatheringstatechange(e);
+        });
+        this.addEventListener('statechange', (e) => {
+            if (this.onstatechange) this.onstatechange(e);
+        });
     }
 
     get component() {
-        return this.#component;
+        let cp = this.getSelectedCandidatePair();
+        if (!cp) return null;
+        return cp.local.component;
     }
 
     get gatheringState() {
-        return this.#gatheringState;
+        return this.#pc ? this.#pc.iceGatheringState : 'new';
     }
 
     get role() {
-        return this.#role;
+        return this.#pc.localDescription.type == 'offer' ? 'controlling' : 'controlled';
     }
 
     get state() {
-        return this.#state;
+        return this.#pc ? this.#pc.iceConnectionState : 'new';
     }
+
     getLocalCandidates() {
-        /** */
+        return this.#pc ? this.#extraFunctions.localCandidates() : [];
     }
 
     getLocalParameters() {
@@ -36,7 +57,7 @@ export default class _RTCIceTransport extends EventTarget {
     }
 
     getRemoteCandidates() {
-        /** */
+        return this.#pc ? this.#extraFunctions.remoteCandidates() : [];
     }
 
     getRemoteParameters() {
@@ -44,12 +65,17 @@ export default class _RTCIceTransport extends EventTarget {
     }
 
     getSelectedCandidatePair() {
-        /** */
+        let cp = this.#extraFunctions.selectedCandidatePair();
+        if (!cp) return null;
+        return {
+            local: new RTCIceCandidate({
+                candidate: cp.local.candidate,
+                sdpMid: cp.local.mid,
+            }),
+            remote: new RTCIceCandidate({
+                candidate: cp.remote.candidate,
+                sdpMid: cp.remote.mid,
+            }),
+        };
     }
 }
-
-function createEmptyFunction() {
-    return () => {
-        /** */
-    };
-}

package/polyfill/RTCPeerConnection.js

@@ -3,6 +3,7 @@ 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 DOMException from 'node-domexception';
 
 export default class _RTCPeerConnection extends EventTarget {
@@ -14,6 +15,9 @@ export default class _RTCPeerConnection extends EventTarget {
     #canTrickleIceCandidates;
     #sctp;
 
+    #localCandidates = [];
+    #remoteCandidates = [];
+
     onconnectionstatechange;
     ondatachannel;
     onicecandidate;
@@ -32,29 +36,23 @@ export default class _RTCPeerConnection extends EventTarget {
         this.#localAnswer = createDeferredPromise();
         this.#dataChannels = new Set();
         this.#canTrickleIceCandidates = null;
-        this.#sctp = null;
-
-        const iceServers = init ? init.iceServers : [];
-
-        this.#peerConnection = new NodeDataChannel.PeerConnection(
-            init && init.peerIdentity ? init.peerIdentity : `peer-${getRandomString(7)}`,
-            {
-                iceServers: 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(),
-                iceTransportPolicy: init ? init.iceTransportPolicy : undefined,
-            },
-        );
+
+        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(),
+        });
 
         // forward peerConnection events
         this.#peerConnection.onStateChange(() => {
@@ -95,6 +93,7 @@ export default class _RTCPeerConnection extends EventTarget {
                 return;
             }
 
+            this.#localCandidates.push(new RTCIceCandidate({ candidate, sdpMid }));
             this.dispatchEvent(new RTCPeerConnectionIceEvent(new RTCIceCandidate({ candidate, sdpMid })));
         });
 
@@ -117,6 +116,27 @@ export default class _RTCPeerConnection extends EventTarget {
         this.addEventListener('icecandidate', (e) => {
             if (this.onicecandidate) this.onicecandidate(e);
         });
+
+        this.#sctp = new RTCSctpTransport({
+            pc: this,
+            extraFunctions: {
+                maxDataChannelId: () => {
+                    return this.#peerConnection.maxDataChannelId();
+                },
+                maxMessageSize: () => {
+                    return this.#peerConnection.maxMessageSize();
+                },
+                localCandidates: () => {
+                    return this.#localCandidates;
+                },
+                remoteCandidates: () => {
+                    return this.#remoteCandidates;
+                },
+                selectedCandidatePair: () => {
+                    return this.#peerConnection.getSelectedCandidatePair();
+                },
+            },
+        });
     }
 
     get canTrickleIceCandidates() {
@@ -176,6 +196,9 @@ export default class _RTCPeerConnection extends EventTarget {
             throw new DOMException('Candidate invalid');
         }
 
+        this.#remoteCandidates.push(
+            new RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
+        );
         this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
     }
 

package/polyfill/RTCSctpTransport.js

@@ -1,34 +1,53 @@
+import RTCDtlsTransport from './RTCDtlsTransport.js';
+
 export default class _RTCSctpTransport extends EventTarget {
-    #maxChannels = null;
-    #maxMessageSize = null;
-    #state = null;
+    #pc = null;
+    #extraFunctions = null;
     #transport = null;
 
-    onstatechange = createEmptyFunction();
+    onstatechange = null;
 
-    constructor(init = {}) {
+    constructor({ pc, extraFunctions }) {
         super();
+        this.#pc = pc;
+        this.#extraFunctions = extraFunctions;
+
+        this.#transport = new RTCDtlsTransport({ pc, extraFunctions });
+
+        // forward peerConnection events
+        this.#pc.addEventListener('connectionstatechange', () => {
+            this.dispatchEvent(new Event('statechange'));
+        });
+
+        // forward events to properties
+        this.addEventListener('statechange', (e) => {
+            if (this.onstatechange) this.onstatechange(e);
+        });
     }
 
     get maxChannels() {
-        return this.#maxChannels;
+        if (this.state !== 'connected') return null;
+        return this.#pc ? this.#extraFunctions.maxDataChannelId() : 0;
     }
 
     get maxMessageSize() {
-        return this.#maxMessageSize;
+        if (this.state !== 'connected') return null;
+        return this.#pc ? this.#extraFunctions.maxMessageSize() : 0;
     }
 
     get state() {
-        return this.#state;
+        // reduce state from new, connecting, connected, disconnected, failed, closed, unknown
+        // to RTCSctpTransport states connecting, connected, closed
+        let state = this.#pc.connectionState;
+        if (state === 'new' || state === 'connecting') {
+            state = 'connecting';
+        } else if (state === 'disconnected' || state === 'failed' || state === 'closed' || state === 'unknown') {
+            state = 'closed';
+        }
+        return state;
     }
 
     get transport() {
         return this.#transport;
     }
 }
-
-function createEmptyFunction() {
-    return () => {
-        /** */
-    };
-}

package/src/peer-connection-wrapper.cpp

@@ -62,6 +62,8 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("bytesReceived", &PeerConnectionWrapper::bytesReceived),
             InstanceMethod("rtt", &PeerConnectionWrapper::rtt),
             InstanceMethod("getSelectedCandidatePair", &PeerConnectionWrapper::getSelectedCandidatePair),
+            InstanceMethod("maxDataChannelId", &PeerConnectionWrapper::maxDataChannelId),
+            InstanceMethod("maxMessageSize", &PeerConnectionWrapper::maxMessageSize),
         });
 
     constructor = Napi::Persistent(func);
@@ -984,11 +986,17 @@ Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::Callback
         localObj.Set("port", local.port().value_or(0));
         localObj.Set("type", candidateTypeToString(local.type()));
         localObj.Set("transportType", candidateTransportTypeToString(local.transportType()));
+        localObj.Set("candidate", local.candidate());
+        localObj.Set("mid", local.mid());
+        localObj.Set("priority", local.priority());
 
         remoteObj.Set("address", remote.address().value_or("?"));
         remoteObj.Set("port", remote.port().value_or(0));
         remoteObj.Set("type", candidateTypeToString(remote.type()));
         remoteObj.Set("transportType", candidateTransportTypeToString(remote.transportType()));
+        remoteObj.Set("candidate", remote.candidate());
+        remoteObj.Set("mid", remote.mid());
+        remoteObj.Set("priority", remote.priority());
 
         retvalue.Set("local", localObj);
         retvalue.Set("remote", remoteObj);
@@ -1002,6 +1010,48 @@ Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::Callback
     }
 }
 
+Napi::Value PeerConnectionWrapper::maxDataChannelId(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "maxDataChannelId() called";
+    Napi::Env env = info.Env();
+
+    if (!mRtcPeerConnPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(env, mRtcPeerConnPtr->maxDataChannelId());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
+Napi::Value PeerConnectionWrapper::maxMessageSize(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "maxMessageSize() called";
+    Napi::Env env = info.Env();
+
+    if (!mRtcPeerConnPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(env, mRtcPeerConnPtr->remoteMaxMessageSize());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
 std::string PeerConnectionWrapper::candidateTypeToString(const rtc::Candidate::Type &type)
 {
     PLOG_DEBUG << "candidateTypeToString() called";

package/src/peer-connection-wrapper.h

@@ -51,6 +51,8 @@ public:
   Napi::Value bytesReceived(const Napi::CallbackInfo &info);
   Napi::Value rtt(const Napi::CallbackInfo &info);
   Napi::Value getSelectedCandidatePair(const Napi::CallbackInfo &info);
+  Napi::Value maxDataChannelId(const Napi::CallbackInfo &info);
+  Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
 
   // Close all existing Peer Connections
   static void CloseAll();

package/test/polyfill-connectivity.js

@@ -71,6 +71,7 @@ dc1.onclose = () => {
 peer1
     .createOffer({})
     .then((desc) => {
+        // console.log(122222, desc);
         peer2.setRemoteDescription(desc);
     })
     .catch((err) => console.error(err));

package/test/test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import nodeDataChannel, { DataChannelStream } from '../lib/index.js';
+import * as nodeDataChannel from '../lib';
 
 describe('Module Definition', () => {
     test('Module Defined', () => {
@@ -154,7 +154,7 @@ describe('DataChannel streams', () => {
         let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
         let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
 
-        const echoStream = new DataChannelStream(echoPeer.createDataChannel('echo-channel'));
+        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
         echoStream.pipe(echoStream); // Echo all received data back to the client
 
         await waitForGathering(echoPeer);

package/examples/build/Dockerfile

@@ -1,30 +0,0 @@
-ARG UBUNTU_VERSION=20.04
-
-FROM ubuntu:${UBUNTU_VERSION}
-
-RUN apt-get update -y && apt-get upgrade -y
-
-# Node
-# https://github.com/nodesource/distributions#nodejs
-ARG NODE_MAJOR=18
-RUN apt-get install -y ca-certificates curl gnupg
-RUN mkdir -p /etc/apt/keyrings
-RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
-RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
-RUN apt-get update -y
-RUN apt-get install -y nodejs
-
-# C++
-RUN apt-get install -y cmake g++
-
-# libnice library as an alternative to default one
-# RUN apt-get install -y libnice-dev
-
-# libssl-dev
-# https://www.claudiokuenzler.com/blog/1216/could-not-find-openssl-error-compiling-cmake-source
-RUN apt-get install -y libssl-dev
-
-# Git
-RUN apt-get install -y git
-
-WORKDIR /home/node-datachannel

package/examples/build/README.md

@@ -1,24 +0,0 @@
-# Examples
-
-## Building with Docker
-
-`cd` into `node-datachannel` root directory
-
-```sh
-# Build Docker image from Dockerfile
-# You can choose Ubuntu and Node major versions by changing UBUNTU_VERSION and NODE_MAJOR
-> docker build \
-    -f ./examples/build/Dockerfile \
-    -t node-datachannel-dev \
-    --build-arg UBUNTU_VERSION=20.04 \
-    --build-arg NODE_MAJOR=18 \
-    .
-
-# Run Docker container and mount node-datachannel root directory as a volume to the container
-> docker run -it --rm --name node-datachannel-dev-container -v ${PWD}:/home/node-datachannel node-datachannel-dev /bin/bash
-
-# Run inside Docker container:
-> npm install --build-from-source
-```
-
-The build will be written to `prebuilds/`

package/node_modules/base64-js/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Jameson Little
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.