node-datachannel 0.28.0 → 0.30.0

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

@@ -1,9 +1,7 @@
 #ifndef PEER_CONNECTION_WRAPPER_H
 #define PEER_CONNECTION_WRAPPER_H
 
-#include <iostream>
 #include <string>
-#include <variant>
 #include <memory>
 #include <unordered_set>
 
@@ -38,6 +36,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/cpp/rtc-wrapper.cpp

@@ -18,184 +18,188 @@
 
 Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
 {
-    Napi::HandleScope scope(env);
+  Napi::HandleScope scope(env);
 
-    exports.Set("initLogger", Napi::Function::New(env, &RtcWrapper::initLogger));
-    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("getLibraryVersion", Napi::Function::New(env, &RtcWrapper::getLibraryVersion));
+  exports.Set("initLogger", Napi::Function::New(env, &RtcWrapper::initLogger));
+  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("getLibraryVersion", Napi::Function::New(env, &RtcWrapper::getLibraryVersion));
 
-    return exports;
+  return exports;
 }
 
 void RtcWrapper::preload(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "preload() called";
-    Napi::Env env = info.Env();
-    try
-    {
-        rtc::Preload();
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-    }
+  PLOG_DEBUG << "preload() called";
+  Napi::Env env = info.Env();
+  try
+  {
+    rtc::Preload();
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+  }
 }
 
 void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    // We expect (String, Object, Function) as param
-    if (length < 1 || !info[0].IsString())
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  // We expect (String, Object, Function) as param
+  if (length < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "LogLevel(String) expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::string logLevelStr = info[0].As<Napi::String>().ToString();
+  rtc::LogLevel logLevel = rtc::LogLevel::None;
+
+  if (logLevelStr == "Verbose")
+    logLevel = rtc::LogLevel::Verbose;
+  if (logLevelStr == "Debug")
+    logLevel = rtc::LogLevel::Debug;
+  if (logLevelStr == "Info")
+    logLevel = rtc::LogLevel::Info;
+  if (logLevelStr == "Warning")
+    logLevel = rtc::LogLevel::Warning;
+  if (logLevelStr == "Error")
+    logLevel = rtc::LogLevel::Error;
+  if (logLevelStr == "Fatal")
+    logLevel = rtc::LogLevel::Fatal;
+
+  try
+  {
+    if (length < 2)
     {
-        Napi::TypeError::New(env, "LogLevel(String) expected").ThrowAsJavaScriptException();
-        return;
+      rtc::InitLogger(logLevel);
     }
-
-    std::string logLevelStr = info[0].As<Napi::String>().ToString();
-    rtc::LogLevel logLevel = rtc::LogLevel::None;
-
-    if (logLevelStr == "Verbose")
-        logLevel = rtc::LogLevel::Verbose;
-    if (logLevelStr == "Debug")
-        logLevel = rtc::LogLevel::Debug;
-    if (logLevelStr == "Info")
-        logLevel = rtc::LogLevel::Info;
-    if (logLevelStr == "Warning")
-        logLevel = rtc::LogLevel::Warning;
-    if (logLevelStr == "Error")
-        logLevel = rtc::LogLevel::Error;
-    if (logLevelStr == "Fatal")
-        logLevel = rtc::LogLevel::Fatal;
-
-    try
-    {
-        if (length < 2)
-        {
-            rtc::InitLogger(logLevel);
-        }
-        else
-        {
-            if (!info[1].IsFunction())
-            {
-                Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-                return;
-            }
-            logCallback = std::make_unique<ThreadSafeCallback>(info[1].As<Napi::Function>());
-            rtc::InitLogger(logLevel, [&](rtc::LogLevel level, std::string message)
-                            {
-                if (logCallback)
-                    logCallback->call([level, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
-                        // This will run in main thread and needs to construct the
-                        // arguments for the call
-
-                        std::string logLevel;
-                        if (level == rtc::LogLevel::Verbose)
-                            logLevel = "Verbose";
-                        if (level == rtc::LogLevel::Debug)
-                            logLevel = "Debug";
-                        if (level == rtc::LogLevel::Info)
-                            logLevel = "Info";
-                        if (level == rtc::LogLevel::Warning)
-                            logLevel = "Warning";
-                        if (level == rtc::LogLevel::Error)
-                            logLevel = "Error";
-                        if (level == rtc::LogLevel::Fatal)
-                            logLevel = "Fatal";
-                        args = {Napi::String::New(env, logLevel), Napi::String::New(env, message)};
-                    }); });
-        }
-    }
-    catch (std::exception &ex)
+    else
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+      if (!info[1].IsFunction())
+      {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
         return;
+      }
+      logCallback = std::make_unique<ThreadSafeCallback>(info[1].As<Napi::Function>());
+      rtc::InitLogger(logLevel,
+                      [&](rtc::LogLevel level, std::string message)
+                      {
+        if (logCallback)
+          logCallback->call(
+              [level, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args)
+              {
+            // This will run in main thread and needs to construct the
+            // arguments for the call
+
+            std::string logLevel;
+            if (level == rtc::LogLevel::Verbose)
+              logLevel = "Verbose";
+            if (level == rtc::LogLevel::Debug)
+              logLevel = "Debug";
+            if (level == rtc::LogLevel::Info)
+              logLevel = "Info";
+            if (level == rtc::LogLevel::Warning)
+              logLevel = "Warning";
+            if (level == rtc::LogLevel::Error)
+              logLevel = "Error";
+            if (level == rtc::LogLevel::Fatal)
+              logLevel = "Fatal";
+            args = {Napi::String::New(env, logLevel), Napi::String::New(env, message)};
+          });
+      });
     }
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+    return;
+  }
 }
 
 void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "cleanup() called";
-    Napi::Env env = info.Env();
-    try
-    {
-        PeerConnectionWrapper::CloseAll();
-        DataChannelWrapper::CloseAll();
+  PLOG_DEBUG << "cleanup() called";
+  Napi::Env env = info.Env();
+  try
+  {
+    PeerConnectionWrapper::CloseAll();
+    DataChannelWrapper::CloseAll();
 
 #if RTC_ENABLE_MEDIA == 1
-        TrackWrapper::CloseAll();
+    TrackWrapper::CloseAll();
 #endif
 
 #if RTC_ENABLE_WEBSOCKET == 1
-        WebSocketWrapper::CloseAll();
-        WebSocketServerWrapper::StopAll();
+    WebSocketWrapper::CloseAll();
+    WebSocketServerWrapper::StopAll();
 #endif
 
-        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)");
+    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)");
 
-        // Cleanup the instances
-        PeerConnectionWrapper::CleanupAll();
-        DataChannelWrapper::CleanupAll();
+    // Cleanup the instances
+    PeerConnectionWrapper::CleanupAll();
+    DataChannelWrapper::CleanupAll();
 
 #if RTC_ENABLE_MEDIA == 1
-        TrackWrapper::CleanupAll();
+    TrackWrapper::CleanupAll();
 #endif
 
 #if RTC_ENABLE_WEBSOCKET == 1
-        WebSocketWrapper::CleanupAll();
+    WebSocketWrapper::CleanupAll();
 #endif
 
-        if (logCallback)
-            logCallback.reset();
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-        return;
-    }
+    if (logCallback)
+      logCallback.reset();
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+    return;
+  }
 }
 
 void RtcWrapper::setSctpSettings(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "setSctpSettings() called";
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    // We expect (Object) as param
-    if (length < 1 || !info[0].IsObject())
-    {
-        Napi::TypeError::New(env, "Configuration (Object) expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    rtc::SctpSettings settings;
-    Napi::Object config = info[0].As<Napi::Object>();
-
-    if (config.Get("recvBufferSize").IsNumber())
-        settings.recvBufferSize = config.Get("recvBufferSize").As<Napi::Number>().Uint32Value();
-    if (config.Get("sendBufferSize").IsNumber())
-        settings.sendBufferSize = config.Get("sendBufferSize").As<Napi::Number>().Uint32Value();
-    if (config.Get("maxChunksOnQueue").IsNumber())
-        settings.maxChunksOnQueue = config.Get("maxChunksOnQueue").As<Napi::Number>().Uint32Value();
-    if (config.Get("initialCongestionWindow").IsNumber())
-        settings.initialCongestionWindow = config.Get("initialCongestionWindow").As<Napi::Number>().Uint32Value();
-    if (config.Get("congestionControlModule").IsNumber())
-        settings.congestionControlModule = config.Get("congestionControlModule").As<Napi::Number>().Uint32Value();
-    if (config.Get("delayedSackTime").IsNumber())
-        settings.delayedSackTime = std::chrono::milliseconds(config.Get("delayedSackTime").As<Napi::Number>().Uint32Value());
-
-    rtc::SetSctpSettings(settings);
+  PLOG_DEBUG << "setSctpSettings() called";
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  // We expect (Object) as param
+  if (length < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Configuration (Object) expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  rtc::SctpSettings settings;
+  Napi::Object config = info[0].As<Napi::Object>();
+
+  if (config.Get("recvBufferSize").IsNumber())
+    settings.recvBufferSize = config.Get("recvBufferSize").As<Napi::Number>().Uint32Value();
+  if (config.Get("sendBufferSize").IsNumber())
+    settings.sendBufferSize = config.Get("sendBufferSize").As<Napi::Number>().Uint32Value();
+  if (config.Get("maxChunksOnQueue").IsNumber())
+    settings.maxChunksOnQueue = config.Get("maxChunksOnQueue").As<Napi::Number>().Uint32Value();
+  if (config.Get("initialCongestionWindow").IsNumber())
+    settings.initialCongestionWindow = config.Get("initialCongestionWindow").As<Napi::Number>().Uint32Value();
+  if (config.Get("congestionControlModule").IsNumber())
+    settings.congestionControlModule = config.Get("congestionControlModule").As<Napi::Number>().Uint32Value();
+  if (config.Get("delayedSackTime").IsNumber())
+    settings.delayedSackTime =
+        std::chrono::milliseconds(config.Get("delayedSackTime").As<Napi::Number>().Uint32Value());
+
+  rtc::SetSctpSettings(settings);
 }
 
-
 Napi::Value RtcWrapper::getLibraryVersion(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "getLibraryVersion() called";
-    Napi::Env env = info.Env();
-    return Napi::String::New(info.Env(), RTC_VERSION);
+  PLOG_DEBUG << "getLibraryVersion() called";
+  Napi::Env env = info.Env();
+  return Napi::String::New(info.Env(), RTC_VERSION);
 }

package/src/cpp/rtc-wrapper.h

@@ -1,9 +1,6 @@
 #ifndef RTC_WRAPPER_H
 #define RTC_WRAPPER_H
 
-#include <iostream>
-#include <string>
-
 #include <napi.h>
 
 #include "rtc/rtc.hpp"
@@ -13,14 +10,15 @@
 class RtcWrapper
 {
 public:
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    static void preload(const Napi::CallbackInfo &info);
-    static void initLogger(const Napi::CallbackInfo &info);
-    static void cleanup(const Napi::CallbackInfo &info);
-    static void setSctpSettings(const Napi::CallbackInfo &info);
-    static Napi::Value getLibraryVersion(const Napi::CallbackInfo &info);
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static void preload(const Napi::CallbackInfo &info);
+  static void initLogger(const Napi::CallbackInfo &info);
+  static void cleanup(const Napi::CallbackInfo &info);
+  static void setSctpSettings(const Napi::CallbackInfo &info);
+  static Napi::Value getLibraryVersion(const Napi::CallbackInfo &info);
+
 private:
-    static inline std::unique_ptr<ThreadSafeCallback> logCallback = nullptr;
+  static inline std::unique_ptr<ThreadSafeCallback> logCallback = nullptr;
 };
 
 #endif // RTC_WRAPPER_H

package/src/cpp/thread-safe-callback.cpp

@@ -2,67 +2,56 @@
 
 #include <stdexcept>
 
-const char *ThreadSafeCallback::CancelException::what() const throw()
-{
-    return "ThreadSafeCallback cancelled";
-}
+const char *ThreadSafeCallback::CancelException::what() const throw() { return "ThreadSafeCallback cancelled"; }
 
 ThreadSafeCallback::ThreadSafeCallback(Napi::Function callback)
 {
-    Napi::Env env = callback.Env();
+  Napi::Env env = callback.Env();
 
-    if (!callback.IsFunction())
-        throw Napi::Error::New(env, "Callback must be a function");
+  if (!callback.IsFunction())
+    throw Napi::Error::New(env, "Callback must be a function");
 
-    tsfn = tsfn_t::New(env,
-                       std::move(callback),
-                       "ThreadSafeCallback callback",
-                       0, // unlimited queue
-                       1);
+  tsfn = tsfn_t::New(env, std::move(callback), "ThreadSafeCallback callback",
+                     0, // unlimited queue
+                     1);
 }
 
-ThreadSafeCallback::~ThreadSafeCallback()
-{
-    tsfn.Abort();
-}
+ThreadSafeCallback::~ThreadSafeCallback() { tsfn.Abort(); }
 
 void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 {
-    CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
-    if (tsfn.BlockingCall(data) != napi_ok)
-    {
-        delete data;
-        throw std::runtime_error("Failed to call JavaScript callback");
-    }
+  CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
+  if (tsfn.BlockingCall(data) != napi_ok)
+  {
+    delete data;
+    throw std::runtime_error("Failed to call JavaScript callback");
+  }
 }
 
-void ThreadSafeCallback::callbackFunc(Napi::Env env,
-                                      Napi::Function callback,
-                                      ContextType *context,
-                                      CallbackData *data)
+void ThreadSafeCallback::callbackFunc(Napi::Env env, Napi::Function callback, ContextType *context, CallbackData *data)
 {
-    // if env is gone, it could mean this cb was destroyed. See issue#176
-    if (!data || !env)
-        return;
-
-    arg_vector_t args;
-    arg_func_t argFunc(std::move(data->argFunc));
-    cleanup_func_t cleanup(std::move(data->cleanupFunc));
-    delete data;
-
-    try
-    {
-        argFunc(env, args);
-    }
-    catch (CancelException &)
-    {
-        return;
-    }
-
-    if (callback)
-    {
-        callback.Call(args);
-    }
-
-    cleanup();
+  // if env is gone, it could mean this cb was destroyed. See issue#176
+  if (!data || !env)
+    return;
+
+  arg_vector_t args;
+  arg_func_t argFunc(std::move(data->argFunc));
+  cleanup_func_t cleanup(std::move(data->cleanupFunc));
+  delete data;
+
+  try
+  {
+    argFunc(env, args);
+  }
+  catch (CancelException &)
+  {
+    return;
+  }
+
+  if (callback)
+  {
+    callback.Call(args);
+  }
+
+  cleanup();
 }

package/src/cpp/thread-safe-callback.h

@@ -9,41 +9,39 @@
 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()>;
+  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();
+  ThreadSafeCallback(Napi::Function callback);
+  ~ThreadSafeCallback();
 
-    ThreadSafeCallback(const ThreadSafeCallback &) = delete;
-    ThreadSafeCallback(ThreadSafeCallback &&) = delete;
+  ThreadSafeCallback(const ThreadSafeCallback &) = delete;
+  ThreadSafeCallback(ThreadSafeCallback &&) = delete;
 
-    ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
-    ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
+  ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
+  ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
 
-    void call(arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
+  void call(
+      arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
 
-    class CancelException : public std::exception
-    {
-        const char *what() const throw();
-    };
+  class CancelException : public std::exception
+  {
+    const char *what() const throw();
+  };
 
 private:
-    using ContextType = std::nullptr_t;
-    struct CallbackData
-    {
-        arg_func_t argFunc;
-        cleanup_func_t cleanupFunc;
-    };
-
-    static void callbackFunc(Napi::Env env,
-                             Napi::Function callback,
-                             ContextType *context,
-                             CallbackData *data);
-
-    using tsfn_t = Napi::TypedThreadSafeFunction<ContextType, CallbackData, callbackFunc>;
-    tsfn_t tsfn;
+  using ContextType = std::nullptr_t;
+  struct CallbackData
+  {
+    arg_func_t argFunc;
+    cleanup_func_t cleanupFunc;
+  };
+
+  static void callbackFunc(Napi::Env env, Napi::Function callback, ContextType *context, CallbackData *data);
+
+  using tsfn_t = Napi::TypedThreadSafeFunction<ContextType, CallbackData, callbackFunc>;
+  tsfn_t tsfn;
 };
 
 #endif // THREAD_SAFE_CALLBACK_H