node-datachannel 0.27.0 → 0.29.0

package/src/cpp/ice-udp-mux-listener-wrapper.cpp

@@ -0,0 +1,150 @@
+#include "ice-udp-mux-listener-wrapper.h"
+
+#include "plog/Log.h"
+
+#include <cctype>
+#include <sstream>
+
+Napi::FunctionReference IceUdpMuxListenerWrapper::constructor = Napi::FunctionReference();
+std::unordered_set<IceUdpMuxListenerWrapper *> IceUdpMuxListenerWrapper::instances;
+
+void IceUdpMuxListenerWrapper::StopAll()
+{
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper StopAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
+Napi::Object IceUdpMuxListenerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = DefineClass(
+        env,
+        "IceUdpMuxListener",
+        {
+            InstanceMethod("stop", &IceUdpMuxListenerWrapper::stop),
+            InstanceMethod("onUnhandledStunRequest", &IceUdpMuxListenerWrapper::onUnhandledStunRequest),
+            InstanceMethod("port", &IceUdpMuxListenerWrapper::port),
+            InstanceMethod("address", &IceUdpMuxListenerWrapper::address)
+        });
+
+    // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+    if(constructor.IsEmpty())
+    {
+        constructor = Napi::Persistent(func);
+        constructor.SuppressDestruct();
+    }
+
+    exports.Set("IceUdpMuxListener", func);
+    return exports;
+}
+
+IceUdpMuxListenerWrapper::IceUdpMuxListenerWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<IceUdpMuxListenerWrapper>(info)
+{
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper Constructor called";
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    // We expect (Number, String?) as param
+    if (length > 0 && info[0].IsNumber()) {
+      // Port
+      mPort = info[0].As<Napi::Number>().ToNumber().Uint32Value();
+    } else {
+      Napi::TypeError::New(env, "Port (Number) and optional Address (String) expected").ThrowAsJavaScriptException();
+      return;
+    }
+
+    if (length > 1 && info[1].IsString()) {
+      // Address
+      mAddress = info[1].As<Napi::String>().ToString();
+    }
+
+    iceUdpMuxListenerPtr = std::make_unique<rtc::IceUdpMuxListener>(mPort, mAddress);
+    instances.insert(this);
+}
+
+IceUdpMuxListenerWrapper::~IceUdpMuxListenerWrapper()
+{
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper Destructor called";
+    doCleanup();
+}
+
+void IceUdpMuxListenerWrapper::doCleanup()
+{
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper::doCleanup() called";
+
+    if (iceUdpMuxListenerPtr)
+    {
+      iceUdpMuxListenerPtr->stop();
+      iceUdpMuxListenerPtr.reset();
+    }
+
+    mOnUnhandledStunRequestCallback.reset();
+    instances.erase(this);
+}
+
+Napi::Value IceUdpMuxListenerWrapper::port(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    return Napi::Number::New(env, mPort);
+}
+
+Napi::Value IceUdpMuxListenerWrapper::address(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (!mAddress.has_value()) {
+      return env.Undefined();
+    }
+
+    return Napi::String::New(env, mAddress.value());
+}
+
+void IceUdpMuxListenerWrapper::stop(const Napi::CallbackInfo &info)
+{
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper::stop() called";
+  doCleanup();
+}
+
+void IceUdpMuxListenerWrapper::onUnhandledStunRequest(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called";
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (!iceUdpMuxListenerPtr)
+    {
+        Napi::Error::New(env, "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called on destroyed IceUdpMuxListener").ThrowAsJavaScriptException();
+        return;
+    }
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnUnhandledStunRequestCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    iceUdpMuxListenerPtr->OnUnhandledStunRequest([&](rtc::IceUdpMuxRequest request)
+    {
+        PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(1)";
+
+        if (mOnUnhandledStunRequestCallback) {
+            mOnUnhandledStunRequestCallback->call([request = std::move(request)](Napi::Env env, std::vector<napi_value> &args) {
+                Napi::Object reqObj = Napi::Object::New(env);
+                reqObj.Set("ufrag", request.remoteUfrag.c_str());
+                reqObj.Set("host", request.remoteAddress.c_str());
+                reqObj.Set("port", request.remotePort);
+
+                args = {reqObj};
+            });
+        }
+
+        PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(2)";
+    });
+}

package/src/cpp/ice-udp-mux-listener-wrapper.h

@@ -0,0 +1,43 @@
+#ifndef ICE_UDP_MUX_LISTENER_WRAPPER_H
+#define ICE_UDP_MUX_LISTENER_WRAPPER_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+#include <unordered_set>
+
+#include "thread-safe-callback.h"
+
+class IceUdpMuxListenerWrapper : public Napi::ObjectWrap<IceUdpMuxListenerWrapper>
+{
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  IceUdpMuxListenerWrapper(const Napi::CallbackInfo &info);
+  ~IceUdpMuxListenerWrapper();
+
+  // Functions
+  void stop(const Napi::CallbackInfo &info);
+  void onUnhandledStunRequest(const Napi::CallbackInfo &info);
+
+  // Stop listening on all ports
+  static void StopAll();
+
+  // Properties
+  Napi::Value port(const Napi::CallbackInfo &info);
+  Napi::Value address(const Napi::CallbackInfo &info);
+  Napi::Value unhandledStunRequestCallback(const Napi::CallbackInfo &info);
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnUnhandledStunRequestCallback = nullptr;
+
+private:
+  static Napi::FunctionReference constructor;
+  static std::unordered_set<IceUdpMuxListenerWrapper *> instances;
+
+  void doCleanup();
+
+  std::optional<std::string> mAddress;
+  uint16_t mPort;
+  std::unique_ptr<rtc::IceUdpMuxListener> iceUdpMuxListenerPtr = nullptr;
+};
+
+#endif // ICE_UDP_MUX_LISTENER_WRAPPER_H

package/src/cpp/main.cpp

@@ -2,6 +2,7 @@
 #include "rtc-wrapper.h"
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
+#include "ice-udp-mux-listener-wrapper.h"
 
 #if RTC_ENABLE_MEDIA == 1
 #include "media-rtcpreceivingsession-wrapper.h"
@@ -27,6 +28,7 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports)
 #endif
 
     DataChannelWrapper::Init(env, exports);
+    IceUdpMuxListenerWrapper::Init(env, exports);
     PeerConnectionWrapper::Init(env, exports);
 
 #if RTC_ENABLE_WEBSOCKET == 1

package/src/cpp/peer-connection-wrapper.cpp

@@ -44,6 +44,7 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
             InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
             InstanceMethod("remoteDescription", &PeerConnectionWrapper::remoteDescription),
+            InstanceMethod("remoteFingerprint", &PeerConnectionWrapper::remoteFingerprint),
             InstanceMethod("addRemoteCandidate", &PeerConnectionWrapper::addRemoteCandidate),
             InstanceMethod("createDataChannel", &PeerConnectionWrapper::createDataChannel),
 
@@ -220,6 +221,10 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     if (config.Get("disableAutoNegotiation").IsBoolean())
         rtcConfig.disableAutoNegotiation = config.Get("disableAutoNegotiation").As<Napi::Boolean>();
 
+    // disableAutoGathering option
+    if (config.Get("disableAutoGathering").IsBoolean())
+        rtcConfig.disableAutoGathering = config.Get("disableAutoGathering").As<Napi::Boolean>();
+
     // forceMediaTransport option
     if (config.Get("forceMediaTransport").IsBoolean())
         rtcConfig.forceMediaTransport = config.Get("forceMediaTransport").As<Napi::Boolean>();
@@ -257,6 +262,17 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
         rtcConfig.disableFingerprintVerification = config.Get("disableFingerprintVerification").As<Napi::Boolean>();
     }
 
+    // Specify certificate to use if set
+    if (config.Get("certificatePemFile").IsString()) {
+        rtcConfig.certificatePemFile = config.Get("certificatePemFile").As<Napi::String>().ToString();
+    }
+    if (config.Get("keyPemFile").IsString()) {
+        rtcConfig.keyPemFile = config.Get("keyPemFile").As<Napi::String>().ToString();
+    }
+    if (config.Get("keyPemPass").IsString()) {
+        rtcConfig.keyPemPass = config.Get("keyPemPass").As<Napi::String>().ToString();
+    }
+
     // Create peer-connection
     try
     {
@@ -337,6 +353,7 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
     }
 
     rtc::Description::Type type = rtc::Description::Type::Unspec;
+    rtc::LocalDescriptionInit init;
 
     // optional
     if (length > 0)
@@ -362,7 +379,29 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
             type = rtc::Description::Type::Rollback;
     }
 
-    mRtcPeerConnPtr->setLocalDescription(type);
+    // optional
+    if (length > 1)
+    {
+        PLOG_DEBUG << "setLocalDescription() called with LocalDescriptionInit";
+
+        if (info[1].IsObject())
+        {
+            PLOG_DEBUG << "setLocalDescription() called with LocalDescriptionInit as object";
+            Napi::Object obj = info[1].As<Napi::Object>();
+
+            if (obj.Get("iceUfrag").IsString()) {
+                PLOG_DEBUG << "setLocalDescription() has ufrag";
+                init.iceUfrag = obj.Get("iceUfrag").As<Napi::String>();
+            }
+
+            if (obj.Get("icePwd").IsString()) {
+                PLOG_DEBUG << "setLocalDescription() has password";
+                init.icePwd = obj.Get("icePwd").As<Napi::String>();
+            }
+        }
+    }
+
+    mRtcPeerConnPtr->setLocalDescription(type, init);
 }
 
 void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
@@ -1008,7 +1047,34 @@ Napi::Value PeerConnectionWrapper::maxMessageSize(const Napi::CallbackInfo &info
 
     try
     {
-        return Napi::Number::New(env, mRtcPeerConnPtr->remoteMaxMessageSize());
+        return Napi::Array::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);
+    }
+}
+
+Napi::Value PeerConnectionWrapper::remoteFingerprint(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "remoteFingerprints() called";
+    Napi::Env env = info.Env();
+
+    if (!mRtcPeerConnPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        auto fingerprint = mRtcPeerConnPtr->remoteFingerprint();
+
+        Napi::Object fingerprintObject = Napi::Object::New(env);
+        fingerprintObject.Set("value", fingerprint.value);
+        fingerprintObject.Set("algorithm", rtc::CertificateFingerprint::AlgorithmIdentifier(fingerprint.algorithm));
+
+        return fingerprintObject;
     }
     catch (std::exception &ex)
     {

package/src/cpp/peer-connection-wrapper.h

@@ -38,6 +38,7 @@ public:
   Napi::Value iceState(const Napi::CallbackInfo &info);
   Napi::Value signalingState(const Napi::CallbackInfo &info);
   Napi::Value gatheringState(const Napi::CallbackInfo &info);
+  Napi::Value remoteFingerprint(const Napi::CallbackInfo &info);
 
   // Callbacks
   void onLocalDescription(const Napi::CallbackInfo &info);

package/src/index.ts

@@ -5,6 +5,5 @@
 import n from './lib/index';
 import p from './polyfill/index';
 
-
 export const nodeDataChannel = n;
 export const polyfill = p;

package/src/lib/datachannel-stream.ts

@@ -10,92 +10,91 @@ import * as stream from 'stream';
  * the protocol level, and is preserved here throughout.
  */
 export default class DataChannelStream extends stream.Duplex {
-    private _rawChannel: any;
-    private _readActive: boolean;
-
-
-    constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
-        super({
-            allowHalfOpen: false, // Default to autoclose on end().
-            ...streamOptions,
-            objectMode: true, // Preserve the string/buffer distinction (WebRTC treats them differently)
-        });
-
-        this._rawChannel = rawChannel;
-        this._readActive = true;
-
-        rawChannel.onMessage((msg: any) => {
-            if (!this._readActive) return; // If the buffer is full, drop messages.
-
-            // If the push is rejected, we pause reading until the next call to _read().
-            this._readActive = this.push(msg);
-        });
-
-        // When the DataChannel closes, the readable & writable ends close
-        rawChannel.onClosed(() => {
-            this.push(null);
-            this.destroy();
-        });
-
-        rawChannel.onError((errMsg: string) => {
-            this.destroy(new Error(`DataChannel error: ${errMsg}`));
-        });
-
-        // Buffer all writes until the DataChannel opens
-        if (!rawChannel.isOpen()) {
-            this.cork();
-            rawChannel.onOpen(() => this.uncork());
-        }
+  private _rawChannel: any;
+  private _readActive: boolean;
+
+  constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
+    super({
+      allowHalfOpen: false, // Default to autoclose on end().
+      ...streamOptions,
+      objectMode: true, // Preserve the string/buffer distinction (WebRTC treats them differently)
+    });
+
+    this._rawChannel = rawChannel;
+    this._readActive = true;
+
+    rawChannel.onMessage((msg: any) => {
+      if (!this._readActive) return; // If the buffer is full, drop messages.
+
+      // If the push is rejected, we pause reading until the next call to _read().
+      this._readActive = this.push(msg);
+    });
+
+    // When the DataChannel closes, the readable & writable ends close
+    rawChannel.onClosed(() => {
+      this.push(null);
+      this.destroy();
+    });
+
+    rawChannel.onError((errMsg: string) => {
+      this.destroy(new Error(`DataChannel error: ${errMsg}`));
+    });
+
+    // Buffer all writes until the DataChannel opens
+    if (!rawChannel.isOpen()) {
+      this.cork();
+      rawChannel.onOpen(() => this.uncork());
     }
-
-    _read(): void {
-        // Stop dropping messages, if the buffer filling up meant we were doing so before.
-        this._readActive = true;
-    }
-
-    _write(chunk, _encoding, callback): void {
-        let sentOk;
-
-        try {
-            if (Buffer.isBuffer(chunk)) {
-                sentOk = this._rawChannel.sendMessageBinary(chunk);
-            } else if (typeof chunk === 'string') {
-                sentOk = this._rawChannel.sendMessage(chunk);
-            } else {
-                const typeName = chunk.constructor.name || typeof chunk;
-                throw new Error(`Cannot write ${typeName} to DataChannel stream`);
-            }
-        } catch (err) {
-            return callback(err);
-        }
-
-        if (sentOk) {
-            callback(null);
-        } else {
-            callback(new Error('Failed to write to DataChannel'));
-        }
-    }
-
-    _final(callback): void {
-        if (!this.allowHalfOpen) this.destroy();
-        callback(null);
-    }
-
-    _destroy(maybeErr, callback): void {
-        // When the stream is destroyed, we close the DataChannel.
-        this._rawChannel.close();
-        callback(maybeErr);
-    }
-
-    get label(): string {
-        return this._rawChannel.getLabel();
-    }
-
-    get id(): number {
-        return this._rawChannel.getId();
+  }
+
+  _read(): void {
+    // Stop dropping messages, if the buffer filling up meant we were doing so before.
+    this._readActive = true;
+  }
+
+  _write(chunk, _encoding, callback): void {
+    let sentOk;
+
+    try {
+      if (Buffer.isBuffer(chunk)) {
+        sentOk = this._rawChannel.sendMessageBinary(chunk);
+      } else if (typeof chunk === 'string') {
+        sentOk = this._rawChannel.sendMessage(chunk);
+      } else {
+        const typeName = chunk.constructor.name || typeof chunk;
+        throw new Error(`Cannot write ${typeName} to DataChannel stream`);
+      }
+    } catch (err) {
+      return callback(err);
     }
 
-    get protocol(): string {
-        return this._rawChannel.getProtocol();
+    if (sentOk) {
+      callback(null);
+    } else {
+      callback(new Error('Failed to write to DataChannel'));
     }
+  }
+
+  _final(callback): void {
+    if (!this.allowHalfOpen) this.destroy();
+    callback(null);
+  }
+
+  _destroy(maybeErr, callback): void {
+    // When the stream is destroyed, we close the DataChannel.
+    this._rawChannel.close();
+    callback(maybeErr);
+  }
+
+  get label(): string {
+    return this._rawChannel.getLabel();
+  }
+
+  get id(): number {
+    return this._rawChannel.getId();
+  }
+
+  get protocol(): string {
+    return this._rawChannel.getProtocol();
+  }
 }