chore: align with libdatachannel

Author: achingbrain

src/cpp/rtc-wrapper.cpp

@@ -18,7 +18,7 @@ Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
     exports.Set("cleanup", Napi::Function::New(env, &RtcWrapper::cleanup));
     exports.Set("preload", Napi::Function::New(env, &RtcWrapper::preload));
     exports.Set("setSctpSettings", Napi::Function::New(env, &RtcWrapper::setSctpSettings));
-    exports.Set("onUnhandledStunRequest", Napi::Function::New(env, &RtcWrapper::onUnhandledStunRequest));
+    exports.Set("listenIceUdpMux", Napi::Function::New(env, &RtcWrapper::listenIceUdpMux));
 
     return exports;
 }
@@ -174,48 +174,46 @@ void RtcWrapper::setSctpSettings(const Napi::CallbackInfo &info)
     rtc::SetSctpSettings(settings);
 }
 
-void RtcWrapper::onUnhandledStunRequest(const Napi::CallbackInfo &info)
+void RtcWrapper::listenIceUdpMux(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "onUnhandledStunRequest() called";
+    PLOG_DEBUG << "listenIceUdpMux() called";
     Napi::Env env = info.Env();
     int length = info.Length();
 
-    if (length < 1 || !info[0].IsString())
+    if (length < 1 || !info[0].IsNumber())
     {
-        Napi::TypeError::New(env, "host (String) expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "port (Number) expected").ThrowAsJavaScriptException();
         return;
     }
-    Napi::String host = info[0].As<Napi::String>();
+    int port = info[0].As<Napi::Number>().ToNumber();
 
-    if (length < 2 || !info[1].IsNumber())
+    Napi::Function listener;
+    if (length > 1 && info[1].IsFunction())
     {
-        Napi::TypeError::New(env, "port (Number) expected").ThrowAsJavaScriptException();
-        return;
+       listener = info[1].As<Napi::Function>();
     }
-    Napi::Number port = info[1].As<Napi::Number>();
 
-    // unbind listener if cb is null, undefined, or was omitted
-    if (length == 2 || (info[2].IsNull() || info[2].IsUndefined())) {
-        unboundStunCallbacks.erase(port.ToNumber().Uint32Value());
-        rtc::OnUnhandledStunRequest(host.ToString(), port.ToNumber());
-        return;
+    std::string host;
+    if (length > 2 && info[2].IsString())
+    {
+       host = info[2].As<Napi::String>().ToString();
     }
 
-    if (length < 3 || !info[2].IsFunction())
+    // unbind listener if cb is null, undefined, or was omitted
+    if (!listener)
     {
-        Napi::TypeError::New(env, "cb (Function) expected").ThrowAsJavaScriptException();
+        std::lock_guard<std::mutex> guard(iceUdpMuxListenersMutex);
+        iceUdpMuxListeners.erase(port);
+        rtc::ListenIceUdpMux(port, nullptr, host);
         return;
     }
-    Napi::Function cb = info[2].As<Napi::Function>();
-
-    std::unique_ptr<ThreadSafeCallback> callback = std::make_unique<ThreadSafeCallback>(cb);
-    unboundStunCallbacks[port.ToNumber().Uint32Value()] = std::move(callback);
-    void * ptr = &unboundStunCallbacks[port.ToNumber().Uint32Value()];
 
-    rtc::OnUnhandledStunRequest(host.ToString(), port.ToNumber(), [&](rtc::UnhandledStunRequest request, void *userPtr) {
-        PLOG_DEBUG << "mOnUnhandledStunRequestCallback call(1)";
+    auto uniqueCallback = std::make_unique<ThreadSafeCallback>(listener);
+    auto callback = std::shared_ptr<ThreadSafeCallback>(std::move(uniqueCallback));
 
-        std::unique_ptr<ThreadSafeCallback> &callback = *(std::unique_ptr<ThreadSafeCallback> *)userPtr;
+    rtc::IceUdpMuxCallback iceUdpMuxCallback = [callback](rtc::IceUdpMuxRequest request)
+    {
+        PLOG_DEBUG << "listenIceUdpMux IceUdpMuxCallback call(1)";
 
         if (callback) {
             callback->call([request = std::move(request)](Napi::Env env, std::vector<napi_value> &args) {
@@ -228,6 +226,11 @@ void RtcWrapper::onUnhandledStunRequest(const Napi::CallbackInfo &info)
             });
         }
 
-        PLOG_DEBUG << "mOnUnhandledStunRequestCallback call(2)";
-    }, ptr);
+        PLOG_DEBUG << "listenIceUdpMux IceUdpMuxCallback call(2)";
+    };
+
+    std::lock_guard<std::mutex> guard(iceUdpMuxListenersMutex);
+    iceUdpMuxListeners[port] = std::move(iceUdpMuxCallback);
+
+    rtc::ListenIceUdpMux(port, &iceUdpMuxListeners[port], host);
 }

src/cpp/rtc-wrapper.h

@@ -18,10 +18,11 @@ class RtcWrapper
     static void initLogger(const Napi::CallbackInfo &info);
     static void cleanup(const Napi::CallbackInfo &info);
     static void setSctpSettings(const Napi::CallbackInfo &info);
-    static void onUnhandledStunRequest(const Napi::CallbackInfo &info);
+    static void listenIceUdpMux(const Napi::CallbackInfo &info);
 private:
     static inline std::unique_ptr<ThreadSafeCallback> logCallback = nullptr;
-    static inline std::map<u_int16_t, std::unique_ptr<ThreadSafeCallback>> unboundStunCallbacks;
+    static inline std::mutex iceUdpMuxListenersMutex;
+    static inline std::map<u_int16_t, rtc::IceUdpMuxCallback> iceUdpMuxListeners;
 };
 
 #endif // RTC_WRAPPER_H

src/lib/index.ts

@@ -8,7 +8,7 @@ export function preload(): void { nodeDataChannel.preload(); }
 export function initLogger(level: LogLevel): void { nodeDataChannel.initLogger(level); }
 export function cleanup(): void { nodeDataChannel.cleanup(); }
 export function setSctpSettings(settings: SctpSettings): void { nodeDataChannel.setSctpSettings(settings); }
-export function onUnhandledStunRequest(host: string, port: number, cb?: (req: { ufrag: string, host: string, port: number }) => void): void { nodeDataChannel.onUnhandledStunRequest(host, port, cb); }
+export function listenIceUdpMux(port: number, cb?: (req: { ufrag: string, host: string, port: number }) => void, host?: string): void { nodeDataChannel.listenIceUdpMux(port, cb, host); }
 
 export interface Audio {
     addAudioCodec(payloadType: number, codec: string, profile?: string): void;
@@ -160,7 +160,7 @@ export default {
     cleanup,
     preload,
     setSctpSettings,
-    onUnhandledStunRequest,
+    listenIceUdpMux,
     RtcpReceivingSession,
     Track,
     Video,

src/lib/node-datachannel.ts

@@ -1,2 +1,3 @@
+// @ts-expect-error no types
 import nodeDataChannel = require('../../build/Release/node_datachannel.node');
 export default nodeDataChannel;

src/lib/types.ts

@@ -47,11 +47,7 @@ export interface ProxyServer {
     password?: string;
 }
 
-export const enum RelayType {
-    TurnUdp = 'TurnUdp',
-    TurnTcp = 'TurnTcp',
-    TurnTls = 'TurnTls',
-}
+export type RelayType = 'TurnUdp' | 'TurnTcp' | 'TurnTls'
 
 export interface IceServer {
     hostname: string;
@@ -84,13 +80,7 @@ export interface RtcConfig {
 }
 
 // Lowercase to match the description type string from libdatachannel
-export enum DescriptionType {
-    Unspec = 'unspec',
-    Offer = 'offer',
-    Answer = 'answer',
-    Pranswer = 'pranswer',
-    Rollback = 'rollback',
-}
+export type DescriptionType = 'unspec' | 'offer' | 'answer' | 'pranswer' | 'rollback'
 
 export type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
 
@@ -137,10 +127,4 @@ export interface SelectedCandidateInfo {
 }
 
 // Must be same as rtc enum class Direction
-export const enum Direction {
-    SendOnly = 'SendOnly',
-    RecvOnly = 'RecvOnly',
-    SendRecv = 'SendRecv',
-    Inactive = 'Inactive',
-    Unknown = 'Unknown',
-}
+export type Direction = 'SendOnly' | 'RecvOnly' | 'SendRecv' | 'Inactive' | 'Unknown'

src/polyfill/RTCPeerConnection.ts

@@ -121,7 +121,8 @@ export default class RTCPeerConnection extends EventTarget implements globalThis
 
         try {
             const peerIdentity = (config as any)?.peerIdentity ?? `peer-${getRandomString(7)}`;
-            this.#peerConnection = new PeerConnection(peerIdentity,
+            // @ts-expect-error fixme
+            this.#peerConnection = config.peerConnection ?? new PeerConnection(peerIdentity,
                 {
                     ...config,
                     iceServers:
@@ -282,7 +283,7 @@ export default class RTCPeerConnection extends EventTarget implements globalThis
         return this.#peerConnection.signalingState();
     }
 
-    async addIceCandidate(candidate?: globalThis.RTCIceCandidateInit | RTCIceCandidate): Promise<void> {
+    async addIceCandidate(candidate?: globalThis.RTCIceCandidateInit | null): Promise<void> {
         if (!candidate || !candidate.candidate) {
             return;
         }