node-datachannel 0.5.5 → 0.7.0

package/src/data-channel-wrapper.cpp

@@ -13,6 +13,14 @@ void DataChannelWrapper::CloseAll()
         inst->doClose();
 }
 
+void DataChannelWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -78,11 +86,15 @@ void DataChannelWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnBufferedAmountLowCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void DataChannelWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -350,6 +362,8 @@ void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 

package/src/data-channel-wrapper.h

@@ -42,10 +42,14 @@ public:
   // Close all existing DataChannels
   static void CloseAll();
 
+  // Reset all Callbacks for existing DataChannels
+  static void CleanupAll();
+
 private:
-  static std::unordered_set<DataChannelWrapper*> instances;
+  static std::unordered_set<DataChannelWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::string mLabel;
   std::shared_ptr<rtc::DataChannel> mDataChannelPtr = nullptr;

package/src/main.cpp

@@ -6,6 +6,8 @@
 #include "media-track-wrapper.h"
 #include "media-video-wrapper.h"
 #include "media-audio-wrapper.h"
+#include "web-socket-wrapper.h"
+#include "web-socket-server-wrapper.h"
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports)
 {
@@ -16,6 +18,8 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports)
     AudioWrapper::Init(env, exports);
     DataChannelWrapper::Init(env, exports);
     PeerConnectionWrapper::Init(env, exports);
+    WebSocketWrapper::Init(env, exports);
+    WebSocketServerWrapper::Init(env, exports);
     return exports;
 }
 

package/src/media-track-wrapper.cpp

@@ -2,6 +2,8 @@
 #include "media-direction.h"
 #include "media-rtcpreceivingsession-wrapper.h"
 
+#include "plog/Log.h"
+
 Napi::FunctionReference TrackWrapper::constructor;
 std::unordered_set<TrackWrapper *> TrackWrapper::instances;
 
@@ -12,6 +14,14 @@ void TrackWrapper::CloseAll()
         inst->doClose();
 }
 
+void TrackWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -73,10 +83,14 @@ void TrackWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void TrackWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -276,7 +290,8 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onOpen([&]() {
+    mTrackPtr->onOpen([&]()
+                      {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -309,7 +324,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onClosed([&]() {
+    mTrackPtr->onClosed([&]()
+                        {
         if (mOnClosedCallback)
             mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Do not check if the data channel has been closed here
@@ -317,6 +333,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 
@@ -340,7 +358,8 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onError([&](const std::string &error) {
+    mTrackPtr->onError([&](const std::string &error)
+                       {
         if (mOnErrorCallback)
             mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -373,7 +392,8 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
+    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message)
+                         {
         if (mOnMessageCallback)
             mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed

package/src/media-track-wrapper.h

@@ -39,21 +39,25 @@ public:
   void onError(const Napi::CallbackInfo &info);
   void onMessage(const Napi::CallbackInfo &info);
 
-  // Close all existing track
+  // Close all existing tracks
   static void CloseAll();
 
+  // Reset all Callbacks for existing tracks
+  static void CleanupAll();
+
 private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;
 
-    // Callback Ptrs
+  // Callback Ptrs
   std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
 };
 
-#endif // MEDIA_TRACK_WRAPPER_H
+#endif // MEDIA_TRACK_WRAPPER_H

package/src/peer-connection-wrapper.cpp

@@ -20,12 +20,12 @@ void PeerConnectionWrapper::CloseAll()
         inst->doClose();
 }
 
-void PeerConnectionWrapper::ResetCallbacksAll()
+void PeerConnectionWrapper::CleanupAll()
 {
-    PLOG_DEBUG << "ResetCallbacksAll() called";
+    PLOG_DEBUG << "CleanupAll() called";
     auto copy(instances);
     for (auto inst : copy)
-        inst->doResetCallbacks();
+        inst->doCleanup();
 }
 
 Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
@@ -37,7 +37,6 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
         "PeerConnection",
         {
             InstanceMethod("close", &PeerConnectionWrapper::close),
-            InstanceMethod("destroy", &PeerConnectionWrapper::destroy),
             InstanceMethod("setLocalDescription", &PeerConnectionWrapper::setLocalDescription),
             InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
             InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
@@ -253,7 +252,8 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
 PeerConnectionWrapper::~PeerConnectionWrapper()
 {
     PLOG_DEBUG << "Destructor called";
-    doDestroy();
+    doCleanup();
+    doClose();
 }
 
 void PeerConnectionWrapper::doClose()
@@ -273,40 +273,27 @@ void PeerConnectionWrapper::doClose()
             return;
         }
     }
-}
-
-void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
-{
-    PLOG_DEBUG << "close() called";
-    doClose();
-}
-
-void PeerConnectionWrapper::doDestroy()
-{
-    PLOG_DEBUG << "doDestroy() called";
-    doClose();
-    doResetCallbacks();
-}
 
-void PeerConnectionWrapper::doResetCallbacks()
-{
-    PLOG_DEBUG << "doResetCallbacks() called";
     mOnLocalDescriptionCallback.reset();
     mOnLocalCandidateCallback.reset();
-    mOnStateChangeCallback.reset();
     mOnIceStateChangeCallback.reset();
     mOnSignalingStateChangeCallback.reset();
     mOnGatheringStateChangeCallback.reset();
     mOnDataChannelCallback.reset();
     mOnTrackCallback.reset();
+}
 
-    instances.erase(this);
+void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "close() called";
+    doClose();
 }
 
-void PeerConnectionWrapper::destroy(const Napi::CallbackInfo &info)
+void PeerConnectionWrapper::doCleanup()
 {
-    PLOG_DEBUG << "destroy() called";
-    doDestroy();
+    PLOG_DEBUG << "doCleanup() called";
+    mOnStateChangeCallback.reset();
+    instances.erase(this);
 }
 
 void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
@@ -738,6 +725,13 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
                 PLOG_DEBUG << "mOnStateChangeCallback call(2)";
+            },[this,state](){
+                PLOG_DEBUG << "mOnStateChangeCallback cleanup";
+                // Special case for closed state, we need to reset all callbacks
+                if(state == rtc::PeerConnection::State::Closed)
+                {
+                    doCleanup();
+                }
             }); });
 }
 

package/src/peer-connection-wrapper.h

@@ -19,8 +19,6 @@ public:
   PeerConnectionWrapper(const Napi::CallbackInfo &info);
   ~PeerConnectionWrapper();
 
-  void destroy(const Napi::CallbackInfo &info);
-
   // Functions
   void close(const Napi::CallbackInfo &info);
   void setLocalDescription(const Napi::CallbackInfo &info);
@@ -58,15 +56,14 @@ public:
   static void CloseAll();
 
   // Reset all Callbacks for existing Peer Connections
-  static void ResetCallbacksAll();
+  static void CleanupAll();
 
 private:
   static Napi::FunctionReference constructor;
   static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
-  void doDestroy();
-  void doResetCallbacks();
+  void doCleanup();
 
   std::string mPeerName;
   std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;

package/src/rtc-wrapper.cpp

@@ -2,6 +2,8 @@
 #include "peer-connection-wrapper.h"
 #include "data-channel-wrapper.h"
 #include "media-track-wrapper.h"
+#include "web-socket-wrapper.h"
+#include "web-socket-server-wrapper.h"
 
 #include "plog/Log.h"
 
@@ -116,13 +118,18 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
         PeerConnectionWrapper::CloseAll();
         DataChannelWrapper::CloseAll();
         TrackWrapper::CloseAll();
+        WebSocketWrapper::CloseAll();
+        WebSocketServerWrapper::StopAll();
 
         const auto timeout = std::chrono::seconds(10);
         if (rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
             throw std::runtime_error("cleanup timeout (possible deadlock)");
 
-        // Clear Callbacks
-        PeerConnectionWrapper::ResetCallbacksAll();
+        // Cleanup the instances
+        PeerConnectionWrapper::CleanupAll();
+        DataChannelWrapper::CleanupAll();
+        TrackWrapper::CleanupAll();
+        WebSocketWrapper::CleanupAll();
 
         if (logCallback)
             logCallback.reset();

package/src/thread-safe-callback.cpp

@@ -26,9 +26,9 @@ ThreadSafeCallback::~ThreadSafeCallback()
     tsfn.Abort();
 }
 
-void ThreadSafeCallback::call(arg_func_t argFunc)
+void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 {
-    CallbackData *data = new CallbackData{std::move(argFunc)};
+    CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
     if (tsfn.BlockingCall(data) != napi_ok)
     {
         delete data;
@@ -47,6 +47,7 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
 
     arg_vector_t args;
     arg_func_t argFunc(std::move(data->argFunc));
+    cleanup_func_t cleanup(std::move(data->cleanupFunc));
     delete data;
 
     try
@@ -59,5 +60,8 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
     }
 
     if (env && callback)
+    {
         callback.Call(context->Value(), args);
+        cleanup();
+    }
 }

package/src/thread-safe-callback.h

@@ -11,6 +11,7 @@ class ThreadSafeCallback
 public:
     using arg_vector_t = std::vector<napi_value>;
     using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
+    using cleanup_func_t = std::function<void()>;
 
     ThreadSafeCallback(Napi::Function callback);
     ~ThreadSafeCallback();
@@ -21,7 +22,7 @@ public:
     ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
     ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
 
-    void call(arg_func_t argFunc);
+    void call(arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
 
     class CancelException : public std::exception
     {
@@ -32,6 +33,7 @@ private:
     struct CallbackData
     {
         arg_func_t argFunc;
+        cleanup_func_t cleanupFunc;
     };
 
     static void callbackFunc(Napi::Env env,

package/src/web-socket-server-wrapper.cpp

@@ -0,0 +1,265 @@
+#include "web-socket-server-wrapper.h"
+
+#include "plog/Log.h"
+
+void WebSocketServerWrapper::StopAll()
+{
+    PLOG_DEBUG << "StopAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doStop();
+}
+
+Napi::FunctionReference WebSocketServerWrapper::constructor;
+std::unordered_set<WebSocketServerWrapper *> WebSocketServerWrapper::instances;
+
+Napi::Object WebSocketServerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = DefineClass(
+        env,
+        "WebSocketServer",
+        {
+            InstanceMethod("stop", &WebSocketServerWrapper::stop),
+            InstanceMethod("port", &WebSocketServerWrapper::port),
+            InstanceMethod("onClient", &WebSocketServerWrapper::onClient)
+        });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("WebSocketServer", func);
+    return exports;
+}
+
+WebSocketServerWrapper::WebSocketServerWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<WebSocketServerWrapper>(info)
+{
+    PLOG_DEBUG << "Constructor called";
+    
+    Napi::Env env = info.Env();
+
+    // Create WebSocketServer without config
+    if (info.Length() == 0)
+    {
+        try
+        {
+            PLOG_DEBUG << "Creating a new WebSocketServer without config";
+            mWebSocketServerPtr = std::make_unique<rtc::WebSocketServer>();
+        }
+        catch (std::exception &ex)
+        {
+            Napi::Error::New(env, std::string("libdatachannel error while creating WebSocketServer without config: ") + ex.what()).ThrowAsJavaScriptException();
+            return;
+        }
+ 
+        PLOG_DEBUG << "WebSocketServer created without config";
+
+        instances.insert(this);
+        return;
+    }
+
+    // Create WebSocketServer with config
+    
+    Napi::Object config = info[0].As<Napi::Object>();    
+    rtc::WebSocketServerConfiguration webSocketServerConfig;
+
+    // Port
+    if (config.Has("port"))
+    {
+        if (!config.Get("port").IsNumber()) 
+        {
+            Napi::TypeError::New(info.Env(), "port must be a number").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.port = config.Get("port").ToNumber().Uint32Value();
+    }
+
+    // Enable TLS
+    if (config.Has("enableTls"))
+    {
+        if (!config.Get("enableTls").IsBoolean()) 
+        {
+            Napi::TypeError::New(info.Env(), "enableTls must be boolean").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.enableTls = config.Get("enableTls").ToBoolean();
+    }
+
+    // Certificate PEM File
+    if (config.Has("certificatePemFile"))
+    {
+        if (!config.Get("certificatePemFile").IsString()) 
+        {
+            Napi::TypeError::New(info.Env(), "certificatePemFile must be a string").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.certificatePemFile = config.Get("certificatePemFile").ToString();
+    }
+
+    // Key PEM File
+    if (config.Has("keyPemFile"))
+    {
+        if (!config.Get("keyPemFile").IsString()) 
+        {
+            Napi::TypeError::New(info.Env(), "keyPemFile must be a string").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.keyPemFile = config.Get("keyPemFile").ToString();
+    }
+
+    // Key PEM Pass
+    if (config.Has("keyPemPass"))
+    {
+        if (!config.Get("keyPemPass").IsString()) 
+        {
+            Napi::TypeError::New(info.Env(), "keyPemPass must be a string").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.keyPemPass = config.Get("keyPemPass").ToString();
+    }
+
+    // Bind Address
+    if (config.Has("bindAddress"))
+    {
+        if (!config.Get("bindAddress").IsString()) 
+        {
+            Napi::TypeError::New(info.Env(), "bindAddress must be a string").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.bindAddress = config.Get("bindAddress").ToString();
+    }
+
+    // Connection Timeout
+    if (config.Has("connectionTimeout"))
+    {
+        if (!config.Get("connectionTimeout").IsNumber()) 
+        {
+            Napi::TypeError::New(info.Env(), "connectionTimeout must be a number").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.connectionTimeout = std::chrono::milliseconds(config.Get("connectionTimeout").ToNumber().Int64Value());
+    }
+
+    // Max Message Size
+    if (config.Has("maxMessageSize"))
+    {
+        if (!config.Get("maxMessageSize").IsNumber()) 
+        {
+            Napi::TypeError::New(info.Env(), "maxMessageSize must be a number").ThrowAsJavaScriptException();
+            return;
+        }
+        webSocketServerConfig.maxMessageSize = config.Get("maxMessageSize").ToNumber().Int32Value();
+    }
+
+    // Create WebSocketServer with config
+    try
+    {
+        PLOG_DEBUG << "Creating a new WebSocketServer";
+        mWebSocketServerPtr = std::make_unique<rtc::WebSocketServer>(webSocketServerConfig);
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error while creating WebSocketServer: ") + ex.what()).ThrowAsJavaScriptException();
+        return;
+    }
+ 
+    PLOG_DEBUG << "WebSocketServer created";
+    instances.insert(this);
+}
+
+WebSocketServerWrapper::~WebSocketServerWrapper()
+{
+    PLOG_DEBUG << "Destructor called";
+    doStop();
+}
+
+void WebSocketServerWrapper::doStop()
+{
+    PLOG_DEBUG << "doStop() called";
+    if (mWebSocketServerPtr)
+    {
+        PLOG_DEBUG << "Closing...";
+        try
+        {
+            mWebSocketServerPtr->stop();
+            mWebSocketServerPtr.reset();
+        }
+        catch (std::exception &ex)
+        {
+            std::cerr << std::string("libWebRtc error while closing WebSocketServer: ") + ex.what() << std::endl;
+            return;
+        }
+    }
+
+    mOnClientCallback.reset();
+
+    instances.erase(this);
+}
+
+void WebSocketServerWrapper::stop(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "stop() called";
+    doStop();
+}
+
+Napi::Value WebSocketServerWrapper::port(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "port() called";
+    Napi::Env env = info.Env();
+
+    if (!mWebSocketServerPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(info.Env(), mWebSocketServerPtr->port());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("WebSocketServer error: ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
+void WebSocketServerWrapper::onClient(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "onClient() called";
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (!mWebSocketServerPtr)
+    {
+        Napi::Error::New(env, "onClient() called on destroyed WebSocketServer").ThrowAsJavaScriptException();
+        return;
+    }
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected as onClient calback").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnClientCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mWebSocketServerPtr->onClient([&](std::shared_ptr<rtc::WebSocket> ws)
+                                   {
+        PLOG_DEBUG << "onClient ws received from WebSocketServer";
+        if (mOnClientCallback)
+            mOnClientCallback->call([this, ws](Napi::Env env, std::vector<napi_value> &args) {
+                PLOG_DEBUG << "mOnClientCallback call(1)";
+                // Check the WebSocketServer is not stopped
+                if(instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                std::shared_ptr<rtc::WebSocket> webSocket = ws;
+                auto instance = WebSocketWrapper::constructor.New({Napi::External<std::shared_ptr<rtc::WebSocket>>::New(env, nullptr), Napi::External<std::shared_ptr<rtc::WebSocket>>::New(env, &webSocket)});
+                args = {instance};
+                PLOG_DEBUG << "mOnClientCallback call(2)";
+            }); });
+}