node-datachannel 0.1.8

package/README.md

@@ -0,0 +1,180 @@
+# node-datachannel - libdatachannel node bindings
+
+![Build CI](https://github.com/murat-dogan/node-datachannel/workflows/Build%20CI/badge.svg)
+
+> "libdatachannel is a standalone implementation of WebRTC Data Channels, WebRTC Media Transport, and WebSockets in C++17 with C bindings for POSIX platforms (including GNU/Linux, Android, and Apple macOS) and Microsoft Windows. It enables direct connectivity between native applications and web browsers without the pain of importing the entire WebRTC stack. "
+
+NodeJS bindings for [libdatachannel](https://github.com/paullouisageneau/libdatachannel) library.
+
+Please check [libdatachannel](https://github.com/paullouisageneau/libdatachannel) for Compatibility & WebRTC details.
+
+## Examples
+```js
+const nodeDataChannel = require('node-datachannel');
+
+// Log Level
+nodeDataChannel.initLogger("Debug");
+
+// SCTP Settings ( use of nodeDataChannel.setSctpSettings() )
+// export interface SctpSettings {
+//     recvBufferSize?: number;
+//     sendBufferSize?: number;
+//     maxChunksOnQueue?: number;
+//     initialCongestionWindow?: number;
+//     congestionControlModule?: number;
+//     delayedSackTime?: number;
+// }
+
+let dc1 = null;
+let dc2 = null;
+
+// Config options
+// export interface RtcConfig {
+//     iceServers: string[];
+//     proxyServer?: ProxyServer;
+//     enableIceTcp?: boolean;
+//     portRangeBegin?: number;
+//     portRangeEnd?: number;
+//     maxMessageSize?: number;
+//     iceTransportPolicy?: TransportPolicy;
+// }
+
+// "iceServers" option is an array of stun/turn server urls
+// Examples;
+// STUN Server Example          : stun:stun.l.google.com:19302
+// TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
+// TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
+// TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
+
+let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+
+// Set Callbacks
+peer1.onStateChange((state) => {
+    console.log("Peer1 State:", state);
+});
+peer1.onGatheringStateChange((state) => {
+    console.log("Peer1 GatheringState:", state);
+});
+peer1.onLocalDescription((sdp, type) => {
+    console.log("Peer1 SDP:", sdp, " Type:", type);
+    peer2.setRemoteDescription(sdp, type);
+});
+peer1.onLocalCandidate((candidate, mid) => {
+    console.log("Peer1 Candidate:", candidate);
+    peer2.addRemoteCandidate(candidate, mid);
+});
+
+let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+
+// Set Callbacks
+peer2.onStateChange((state) => {
+    console.log("Peer2 State:", state);
+});
+peer2.onGatheringStateChange((state) => {
+    console.log("Peer2 GatheringState:", state);
+});
+peer2.onLocalDescription((sdp, type) => {
+    console.log("Peer2 SDP:", sdp, " Type:", type);
+    peer1.setRemoteDescription(sdp, type);
+});
+peer2.onLocalCandidate((candidate, mid) => {
+    console.log("Peer2 Candidate:", candidate);
+    peer1.addRemoteCandidate(candidate, mid);
+});
+peer2.onDataChannel((dc) => {
+    console.log("Peer2 Got DataChannel: ", dc.getLabel());
+    dc2 = dc;
+    dc2.onMessage((msg) => {
+        console.log('Peer2 Received Msg:', msg);
+    });
+    dc2.sendMessage("Hello From Peer2");
+});
+
+// DataChannel Options
+// export interface DataChannelInitConfig {
+//     protocol?: string;
+//     negotiated?: boolean;
+//     id?: number;
+//     ordered?: boolean;
+//     maxPacketLifeTime?: number;
+//     maxRetransmits?: number;
+//
+//     // Deprecated, use ordered, maxPacketLifeTime, and maxRetransmits
+//     reliability?: {
+//         type?: ReliabilityType;
+//         unordered?: boolean;
+//         rexmit?: number;
+//     }
+// }
+dc1 = peer1.createDataChannel("test");
+dc1.onOpen(() => {
+    dc1.sendMessage("Hello from Peer1");
+    // Binary message: Use sendMessageBinary(Buffer)
+});
+dc1.onMessage((msg) => {
+    console.log('Peer1 Received Msg:', msg);
+});
+
+setTimeout(() => {
+    dc1.close();
+    dc2.close();
+    peer1.close();
+    peer2.close();
+    dc1 = null;
+    dc2 = null;
+    peer1 = null;
+    peer2 = null;
+    nodeDataChannel.cleanup();
+}, 10 * 1000);
+```
+## Install
+
+Prebuilt binaries are available (Node Version >= 10);
+* Windows (x86, x64)
+* Linux (x64, armv7, arm64)
+* Mac
+
+```sh
+> npm install node-datachannel --save
+```
+
+## Build
+
+### Requirements
+* cmake >= V3.14
+* [libdatachannel dependencies](https://github.com/paullouisageneau/libdatachannel/blob/master/README.md#dependencies)
+
+### Building from source
+
+```sh
+> git clone https://github.com/murat-dogan/node-datachannel.git
+> cd node-datachannel
+> npm i
+```
+
+Build with libnice support
+```sh
+> npm run install-nice
+```
+
+Other Options
+```sh
+> npm run install -- -DUSE_GNUTLS=1   # Use GNU TLS instead of OpenSSL (Default False)
+> npm run install -- -DUSE_SRTP=1   # Enable SRTP for media support ( Default False)
+```
+
+### Test
+```sh
+> npm run test                  # Unit tests
+> node test/connectivity.js     # Connectivity
+```
+
+### More Examples
+
+Check `examples` folder
+
+## Thanks
+
+
+Thanks to [Streamr](https://streamr.network/) for supporting this project by being a Sponsor!
+

package/cmake/toolchain/arm64.cmake

@@ -0,0 +1,17 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(TOOLCHAIN_PREFIX aarch64-linux-gnu)
+
+# cross compilers to use for C and C++
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+
+# Needed sysroot
+# https://github.com/webrtc-uwp/chromium-build/blob/master/linux/sysroot_scripts/sysroots.json
+set(CMAKE_SYSROOT "$ENV{ARM64_SYSROOT}")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_C_FLAGS "-march=armv8-a -fPIC -Wno-error=format-truncation" CACHE STRING "Compiler Flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "Compiler Flags")

package/cmake/toolchain/armv7.cmake

@@ -0,0 +1,17 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(TOOLCHAIN_PREFIX arm-linux-gnueabihf)
+
+# cross compilers to use for C and C++
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+
+# Needed sysroot
+# https://github.com/webrtc-uwp/chromium-build/blob/master/linux/sysroot_scripts/sysroots.json
+set(CMAKE_SYSROOT "$ENV{ARM_SYSROOT}")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_C_FLAGS "-march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard -fPIC -Wno-error=format-truncation" CACHE STRING "Compiler Flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "Compiler Flags")

package/examples/README.md

@@ -0,0 +1,21 @@
+# Examples
+
+## client-server
+ * You can use client-server example project to test WebRTC Data Channels with WebSocket signaling.
+ * It uses same logic of [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project.
+ * Contains an equivalent implementation for a node.js signaling server
+
+## How to Use?
+* Prepare Project
+  * cd examples/client-server
+  * npm i
+* Start ws signaling server;
+  * node signaling-server.js
+* Start answerer (On a new Console);
+  * node client.js
+  * Note local ID
+* Start Offerer (On a new Console);
+  * node client.js
+  * Enter answerer ID
+
+  > You can also use [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project's client & signaling server

package/examples/client-server/client-benchmark.js

@@ -0,0 +1,216 @@
+const yargs = require('yargs/yargs')
+const { hideBin } = require('yargs/helpers')
+const nodeDataChannel = require('../../lib/index');
+const WebSocket = require('ws');
+const readline = require("readline");
+
+// Init Logger
+nodeDataChannel.initLogger('Debug');
+
+// PeerConnection Map
+const pcMap = {};
+
+const dcArr = [];
+
+// Local ID
+const id = randomId(4);
+
+// Message Size
+const MESSAGE_SIZE = 65535;
+
+// Buffer Size
+const BUFFER_SIZE = MESSAGE_SIZE * 0;
+
+// Args
+const argv = yargs(hideBin(process.argv))
+    .option('disableSend', {
+        type: 'boolean',
+        description: 'Disable Send',
+        default: false
+    })
+    .option('wsUrl', {
+        type: 'string',
+        description: 'Web Socket URL',
+        default: 'ws://localhost:8000'
+    })
+    .option('dataChannelCount', {
+        type: 'number',
+        description: 'Data Channel Count To Create',
+        default: 1
+    })
+    .argv;
+
+// Disable Send
+const disableSend = argv.disableSend
+if (disableSend) console.log('Send Disabled!');
+
+// Signaling Server
+const wsUrl = process.env.WS_URL || argv.wsUrl;
+console.log(wsUrl)
+const dataChannelCount = argv.dataChannelCount;
+
+// Read Line Interface
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+
+const ws = new WebSocket(wsUrl + '/' + id, {
+    perMessageDeflate: false
+});
+
+console.log(`The local ID is: ${id}`);
+console.log(`Waiting for signaling to be connected...`);
+
+ws.on('open', () => {
+    console.log('WebSocket connected, signaling ready');
+    readUserInput();
+});
+
+ws.on('error', (err) => {
+    console.log('WebSocket Error: ', err);
+});
+
+ws.on('message', (msgStr) => {
+    msg = JSON.parse(msgStr);
+    switch (msg.type) {
+        case 'offer':
+            createPeerConnection(msg.id);
+            pcMap[msg.id].setRemoteDescription(msg.description, msg.type);
+            break;
+        case 'answer':
+            pcMap[msg.id].setRemoteDescription(msg.description, msg.type);
+            break;
+        case 'candidate':
+            pcMap[msg.id].addRemoteCandidate(msg.candidate, msg.mid);
+            break;
+
+        default:
+            break;
+    }
+});
+
+function readUserInput() {
+    rl.question('Enter a remote ID to send an offer: ', (peerId) => {
+        if (peerId && peerId.length > 2) {
+            rl.close();
+            console.log('Offering to ', peerId);
+            createPeerConnection(peerId);
+
+            let msgToSend = randomId(MESSAGE_SIZE);
+
+            for (let i = 1; i <= dataChannelCount; i++) {
+                let dcArrItem = {
+                    dc: null,
+                    bytesSent: 0,
+                    bytesReceived: 0
+                };
+                console.log('Creating DataChannel with label "test-' + i + '"');
+                dcArrItem.dc = pcMap[peerId].createDataChannel('test-' + i);
+
+                dcArrItem.dc.setBufferedAmountLowThreshold(BUFFER_SIZE);
+                dcArrItem.dc.onOpen(() => {
+                    while (!disableSend && dcArrItem.dc.bufferedAmount() <= BUFFER_SIZE) {
+                        dcArrItem.dc.sendMessage(msgToSend)
+                        dcArrItem.bytesSent += msgToSend.length;;
+                    };
+                });
+
+                dcArrItem.dc.onBufferedAmountLow(() => {
+                    while (!disableSend && dcArrItem.dc.bufferedAmount() <= BUFFER_SIZE) {
+                        dcArrItem.dc.sendMessage(msgToSend)
+                        dcArrItem.bytesSent += msgToSend.length;;
+                    };
+                });
+
+                dcArrItem.dc.onMessage((msg) => {
+                    dcArrItem.bytesReceived += msg.length;
+                });
+
+                dcArr.push(dcArrItem);
+            }
+
+
+            // Report
+            let i = 0;
+            setInterval(() => {
+                let totalBytesSent = 0;
+                let totalBytesReceived = 0;
+                for (let j = 0; j < dcArr.length; j++) {
+                    console.log(`${j == 0 ? i + '#' : ''} DC-${j + 1} Sent: ${byte2KB(dcArr[j].bytesSent)} KB/s / Received: ${byte2KB(dcArr[j].bytesReceived)} KB/s / SendBufferAmount: ${dcArr[j].dc.bufferedAmount()} / DataChannelOpen: ${dcArr[j].dc.isOpen()}`);
+                    totalBytesSent += dcArr[j].bytesSent;
+                    totalBytesReceived += dcArr[j].bytesReceived;
+                    dcArr[j].bytesSent = 0;
+                    dcArr[j].bytesReceived = 0;
+                }
+                console.log(`Total Sent: ${byte2KB(totalBytesSent)}  KB/s / Total Received: ${byte2KB(totalBytesReceived)}  KB/s`);
+
+                if (i % 5 == 0) {
+                    console.log(`Stats# Sent: ${byte2MB(pcMap[peerId].bytesSent())} MB / Received: ${byte2MB(pcMap[peerId].bytesReceived())} MB / rtt: ${pcMap[peerId].rtt()} ms`);
+                    console.log(`Selected Candidates# ${JSON.stringify(pcMap[peerId].getSelectedCandidatePair())}`);
+                    console.log(``);
+                }
+                i++;
+            }, 1000);
+        }
+    });
+}
+
+function createPeerConnection(peerId) {
+    // Create PeerConnection
+    let peerConnection = new nodeDataChannel.PeerConnection('pc', { iceServers: ['stun:stun.l.google.com:19302'] });
+    peerConnection.onStateChange((state) => {
+        console.log('State: ', state);
+    });
+    peerConnection.onGatheringStateChange((state) => {
+        console.log('GatheringState: ', state);
+    });
+    peerConnection.onLocalDescription((description, type) => {
+        ws.send(JSON.stringify({ id: peerId, type, description }));
+    });
+    peerConnection.onLocalCandidate((candidate, mid) => {
+        ws.send(JSON.stringify({ id: peerId, type: 'candidate', candidate, mid }));
+    });
+    peerConnection.onDataChannel((dc) => {
+        rl.close();
+        console.log('DataChannel from ' + peerId + ' received with label "', dc.getLabel() + '"');
+
+        let msgToSend = randomId(MESSAGE_SIZE);
+
+        while (!disableSend && dc.bufferedAmount() <= BUFFER_SIZE) {
+            dc.sendMessage(msgToSend)
+        };
+
+        dc.onBufferedAmountLow(() => {
+            while (!disableSend && dc.bufferedAmount() <= BUFFER_SIZE) {
+                dc.sendMessage(msgToSend)
+            };
+        });
+
+
+        dc.onMessage((msg) => {
+            // bytesReceived += msg.length;
+        });
+    });
+
+    pcMap[peerId] = peerConnection;
+}
+
+function randomId(length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+
+function byte2KB(bytes) {
+    return `${Math.round(bytes / 1000)}`
+}
+
+function byte2MB(bytes) {
+    return `${Math.round(bytes / (1000 * 1000))}`
+}