@4players/odin-nodejs 0.10.3 → 0.11.1

package/binding.gyp

@@ -8,6 +8,7 @@
         "cppsrc/odinclient.cpp",
         "cppsrc/odinroom.cpp",
         "cppsrc/odinmedia.cpp",
+        "cppsrc/odincipher.cpp",
         "cppsrc/utilities.cpp"
       ],
       "include_dirs": [
@@ -20,27 +21,41 @@
       "conditions": [
         ["OS=='linux'", {
           "libraries": [
+            "-Wl,-rpath,$$ORIGIN",
             "-L<(module_root_dir)/libs/bin/linux/<(target_arch)",
-            "-lodin_static"
+            "-lodin",
+            "-lodin_crypto"
           ]
         }],
         ["OS=='mac'", {
-          "libraries": [
-            "-L<(module_root_dir)/libs/bin/macos/<(target_arch)",
-            "-lodin_static",
-          ]
+          "cflags+": [
+            "-fvisibility=hidden"
+          ],
+          "xcode_settings": {
+            "GCC_SYMBOLS_PRIVATE_EXTERN": "YES",
+            "OTHER_CFLAGS": [
+              "-arch x86_64",
+              "-arch arm64"
+            ],
+            "OTHER_LDFLAGS": [
+              "-Wl,-rpath,@loader_path/",
+              "-L<(module_root_dir)/libs/bin/macos/universal",
+              "-lodin",
+              "-lodin_crypto",
+              "-arch x86_64",
+              "-arch arm64"
+            ]
+          }
         }],
         ["OS=='win'", {
           "msvs_settings": {
             "VCCLCompilerTool": {
-              "AdditionalOptions": [ "/MD" ],
-            },
-            "VCLinkerTool": {
-
-            },
+              "AdditionalOptions": [ "/MD" ]
+            }
           },
           "libraries": [
-            "<(module_root_dir)/libs/bin/windows/<(target_arch)/odin_static.lib",
+            "<(module_root_dir)/libs/bin/windows/<(target_arch)/odin.lib",
+            "<(module_root_dir)/libs/bin/windows/<(target_arch)/odin_crypto.lib",
             "-lws2_32",
             "-lbcrypt",
             "-lucrt",
@@ -50,11 +65,12 @@
           ]
         }]
       ],
-      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
+      "defines": [ "NAPI_CPP_EXCEPTIONS" ],
       "cflags!": [ "-fno-exceptions" ],
       "cflags_cc!": [ "-fno-exceptions" ],
+      "cflags_cc": [ "-fexceptions" ],
       "xcode_settings": {
-        "GCC_ENABLE_CPP_EXCEPTIONS": "NO",
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
         "CLANG_CXX_LIBRARY": "libc++",
         "MACOSX_DEPLOYMENT_TARGET": "10.12",
       },

package/cppsrc/binding.cpp

@@ -1,15 +1,12 @@
 /* cppsrc/main.cpp */
 #include <napi.h>
 #include "odinbindings.h"
-#include "odinroom.h"
-#include "odinmedia.h"
 #include "odinclient.h"
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
-  OdinBindings::Init(env,exports);
-  OdinClient::Init(env, exports);
-  OdinMedia::Init(env, exports);
-  return OdinRoom::Init(env, exports);
+  OdinBindings::Init(env, exports); // Registers generateAccessToken, Room, Media, Cipher
+  OdinClient::Init(env, exports);   // Registers OdinClient
+  return exports;
 }
 
 NODE_API_MODULE(NODE_GYP_MODULE_NAME, InitAll)

package/cppsrc/odinbindings.cpp

@@ -1,58 +1,22 @@
-//
-// Created by Phillip Schuster on 08.03.23.
-//
 #include "odinbindings.h"
+#include "odincipher.h"
+#include "odinmedia.h"
+#include "odinroom.h"
 
-/**
- * Wrapper function to generate an access token with access key, room id and user id
- * @param info
- * @return
- */
 Napi::String OdinBindings::GenerateAccessToken(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-
-    if (info.Length() != 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-        Napi::TypeError::New(env, "Room and User Id expected").ThrowAsJavaScriptException();
-    }
-
-    std::string accessKey = info[0].ToString().Utf8Value();
-    std::string roomId = info[1].ToString().Utf8Value();
-    std::string userId = info[2].ToString().Utf8Value();
-
-    OdinTokenGenerator *generator = odin_token_generator_create(accessKey.c_str());
-    if (!generator)
-    {
-        Napi::TypeError::New(env, "Failed to initialize token generator, invalid access key").ThrowAsJavaScriptException();
-    }
-
-    /*
-     * Generate a new room token to access the ODIN network
-     */
-    char room_token[512];
-    OdinReturnCode error = odin_token_generator_create_token(generator, roomId.c_str(), userId.c_str(), room_token, sizeof(room_token));
-    if (odin_is_error(error))
-    {
-        Napi::TypeError::New(env, "Creating access token failed").ThrowAsJavaScriptException();
-    }
-
-    /*
-     * Destroy the token generator as we don't need it anymore
-     */
-    odin_token_generator_destroy(generator);
-
-    return Napi::String::New(env, room_token);
+    Napi::TypeError::New(env, "Native token generation is deprecated. Use a server-side implementation.").ThrowAsJavaScriptException();
+    return Napi::String::New(env, "");
 }
 
-/**
- * Initialize the bindings
- * @param env
- * @param exports
- * @return
- */
 Napi::Object OdinBindings::Init(Napi::Env env, Napi::Object exports)
 {
     exports.Set("generateAccessToken", Napi::Function::New(env, OdinBindings::GenerateAccessToken));
+    
+    OdinRoomWrapper::Init(env, exports);
+    OdinMediaWrapper::Init(env, exports);
+    OdinCipherWrapper::Init(env, exports);
 
     return exports;
 }

package/cppsrc/odincipher.cpp

@@ -0,0 +1,92 @@
+#include "odincipher.h"
+#include "utilities.h"
+
+Napi::FunctionReference *OdinCipherWrapper::constructor;
+
+OdinCipherWrapper::OdinCipherWrapper(const Napi::CallbackInfo& info) : Napi::ObjectWrap<OdinCipherWrapper>(info) {
+    _cipher = nullptr;
+}
+
+void OdinCipherWrapper::Finalize(Napi::Env env) {
+    if (_cipher) {
+        if (_cipher->free) {
+            _cipher->free(_cipher);
+        }
+        _cipher = nullptr;
+    }
+}
+
+Napi::Object OdinCipherWrapper::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "OdinCipher", {
+        InstanceMethod<&OdinCipherWrapper::SetPassword>("setPassword", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinCipherWrapper::GetPeerStatus>("getPeerStatus", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+    });
+    
+    constructor = new Napi::FunctionReference();
+    *constructor = Napi::Persistent(func);
+    exports.Set("OdinCipher", func);
+    return exports;
+}
+
+Napi::Value OdinCipherWrapper::CreateNewItem(const Napi::CallbackInfo& info) {
+    return constructor->New({});
+}
+
+void OdinCipherWrapper::SetPassword(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Password as Uint8Array required").ThrowAsJavaScriptException();
+        return;
+    }
+    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
+    
+    // Lazy initialization: create cipher only when setPassword is called
+    if (!_cipher) {
+        _cipher = odin_crypto_create(ODIN_CRYPTO_VERSION);
+        if (!_cipher) {
+            Napi::TypeError::New(env, "Failed to create OdinCipher").ThrowAsJavaScriptException();
+            return;
+        }
+    }
+    
+    odin_crypto_set_password(_cipher, data.Data(), (uint32_t)data.ByteLength());
+}
+
+/**
+ * Get the encryption status of a specific peer.
+ * 
+ * @param info[0] Peer ID (number) - The peer to check status for
+ * @returns {string} One of:
+ *   - 'unknown': Peer status not yet determined
+ *   - 'unencrypted': Peer is not using encryption
+ *   - 'encrypted': Peer is using encryption with matching password
+ *   - 'password_mismatch': Peer is encrypted but password doesn't match
+ */
+Napi::Value OdinCipherWrapper::GetPeerStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Peer ID (number) required").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    if (!_cipher) {
+        // Cipher not initialized yet
+        return Napi::String::New(env, "unknown");
+    }
+    
+    uint64_t peerId = static_cast<uint64_t>(info[0].As<Napi::Number>().DoubleValue());
+    OdinCryptoPeerStatus status = odin_crypto_get_peer_status(_cipher, peerId);
+    
+    switch (status) {
+        case ODIN_CRYPTO_PEER_STATUS_ENCRYPTED:
+            return Napi::String::New(env, "encrypted");
+        case ODIN_CRYPTO_PEER_STATUS_UNENCRYPTED:
+            return Napi::String::New(env, "unencrypted");
+        case ODIN_CRYPTO_PEER_STATUS_PASSWORD_MISSMATCH:
+            return Napi::String::New(env, "password_mismatch");
+        case ODIN_CRYPTO_PEER_STATUS_UNKNOWN:
+        default:
+            return Napi::String::New(env, "unknown");
+    }
+}

package/cppsrc/odincipher.h

@@ -0,0 +1,32 @@
+#ifndef ODIN_NODEJS_ODINCIPHER_H
+#define ODIN_NODEJS_ODINCIPHER_H
+
+#include <napi.h>
+#include <odin_crypto.h>
+
+class OdinCipherWrapper : public Napi::ObjectWrap<OdinCipherWrapper> {
+public:
+    OdinCipherWrapper(const Napi::CallbackInfo& info);
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Value CreateNewItem(const Napi::CallbackInfo& info);
+
+    struct OdinCipher* GetCipher() const { return _cipher; }
+    
+    /**
+     * Transfer ownership of the cipher to the room.
+     * After calling this, the wrapper will no longer try to free the cipher
+     * in its destructor (the room now owns it).
+     */
+    void TransferOwnership() { _cipher = nullptr; }
+    
+    void Finalize(Napi::Env env) override;
+
+private:
+    static Napi::FunctionReference *constructor;
+    struct OdinCipher* _cipher;
+
+    void SetPassword(const Napi::CallbackInfo& info);
+    Napi::Value GetPeerStatus(const Napi::CallbackInfo& info);
+};
+
+#endif //ODIN_NODEJS_ODINCIPHER_H

package/cppsrc/odinclient.cpp

@@ -1,198 +1,59 @@
 #include "odinclient.h"
-#include <inttypes.h>
 #include "odinroom.h"
+#include "utilities.h" // Added include
 
-/**
- * Initialize the OdinClient class
- * @param env
- * @param exports
- * @return
- */
 Napi::Object OdinClient::Init(Napi::Env env, Napi::Object exports) {
-    // This method is used to hook the accessor and method callbacks
     Napi::Function func = DefineClass(env, "OdinClient", {
             InstanceMethod<&OdinClient::GenerateAccessToken>("generateToken", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
             InstanceMethod<&OdinClient::CreateRoom>("createRoom", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
             InstanceMethod<&OdinClient::CreateRoomWithAccessToken>("createRoomWithToken", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-
-            // Deprecated functions
             InstanceMethod<&OdinClient::GenerateAccessToken>("generateAccessToken", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
             InstanceMethod<&OdinClient::CreateRoomWithAccessToken>("createRoomWithAccessToken", static_cast<napi_property_attributes>(napi_writable | napi_configurable))
     });
 
     Napi::FunctionReference* constructor = new Napi::FunctionReference();
-
-    // Create a persistent reference to the class constructor. This will allow
-    // a function called on a class prototype and a function
-    // called on instance of a class to be distinguished from each other.
     *constructor = Napi::Persistent(func);
     exports.Set("OdinClient", func);
-
-    // Store the constructor as the add-on instance data. This will allow this
-    // add-on to support multiple instances of itself running on multiple worker
-    // threads, as well as multiple instances of itself running in different
-    // contexts on the same thread.
-    //
-    // By default, the value set on the environment here will be destroyed when
-    // the add-on is unloaded using the `delete` operator, but it is also
-    // possible to supply a custom deleter.
-    env.SetInstanceData<Napi::FunctionReference>(constructor);
-
+    // env.SetInstanceData<Napi::FunctionReference>(constructor);
     return exports;
 }
 
-/**
- * OdinClient constructor, requires an access key as string as first parameter
- * @param info
- */
-OdinClient::OdinClient(const Napi::CallbackInfo& info) : Napi::ObjectWrap<OdinClient>(info)  {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-
-    _sampleRate = 48000;
-    _numChannels = 1;
-
-    if (info.Length() >= 1) {
-        if (info[0].IsNumber()) {
-            _sampleRate = info[0].ToNumber();
-        } else {
-            Napi::TypeError::New(env, "Sample rate must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-    }
-
-    if (info.Length() >= 2) {
-        if (info[1].IsNumber()) {
-            _numChannels = info[1].ToNumber();
-        } else {
-            Napi::TypeError::New(env, "Channels must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-    }
-
-#ifdef DEBUG
-    printf("Odin NodeJS Addon: Initializing Odin runtime (%s) with sample rate %f and %d channels\n", ODIN_VERSION, _sampleRate, _numChannels);
-#endif
-
-    // Create a OdinAudioStreamConfig struct to configure the audio stream
-    OdinAudioStreamConfig config;
-    config.sample_rate = _sampleRate;
-    config.channel_count = _numChannels;
+// Extern declaration of shared SDK initialization flag (defined in odinroom.cpp)
+extern bool g_odinSdkInitialized;
 
-    odin_startup_ex(ODIN_VERSION, config);
+OdinClient::OdinClient(const Napi::CallbackInfo& info) : Napi::ObjectWrap<OdinClient>(info)  {
+    // SDK lifecycle is now managed by OdinRoomWrapper via reference counting.
+    // The SDK is initialized when the first room is created and shut down
+    // when the last room is destroyed. This avoids issues with GC timing.
 }
 
-/**
- * OdinClient destructor
- */
 void OdinClient::Finalize(Napi::Env env) {
+    // Note: SDK lifecycle is managed by OdinRoomWrapper via reference counting.
+    // Do NOT call odin_shutdown() here as it would invalidate encoders/decoders
+    // that may still be in use by other rooms.
 }
 
-/**
- * Generate an access token for a room, requires a room id and user id as string as first and second parameter, returns the access token as string
- * @param info
- * @return
- */
-Napi::Value OdinClient::GenerateAccessToken(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
-
-    if (info.Length() != 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-        Napi::TypeError::New(env, "Access-Key, Room and User Id expected").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-
-    std::string accessKey = info[0].ToString().Utf8Value();
-    std::string roomId = info[1].ToString().Utf8Value();
-    std::string userId = info[2].ToString().Utf8Value();
-
-    OdinTokenGenerator *generator = odin_token_generator_create(accessKey.c_str());
-    if (!generator)
-    {
-        Napi::TypeError::New(env, "Failed to initialize token generator, invalid access key").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-
-    /*
-     * Generate a new room token to access the ODIN network
-     */
-    char room_token[512];
-    OdinReturnCode error = odin_token_generator_create_token(generator, roomId.c_str(), userId.c_str(), room_token, sizeof(room_token));
-    if (odin_is_error(error))
-    {
-        Napi::TypeError::New(env, "Creating access token failed").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-
-    /*
-     * Destroy the token generator as we don't need it anymore
-     */
-    odin_token_generator_destroy(generator);
-
-    return Napi::String::New(env, room_token);
+Napi::Value OdinClient::GenerateAccessToken(const Napi::CallbackInfo &info) {
+    Napi::TypeError::New(info.Env(), "Native token generation is removed in SDK 1.8.2. Use 'jsonwebtoken' or similar to generate JWTs.").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
 }
 
-/**
- * Create a new room, requires a room id and user id as string as first and second parameter, returns the room instance
- * @param info
- * @return
- */
 Napi::Value OdinClient::CreateRoom(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() != 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-        Napi::TypeError::New(env, "Access-Key, Room and User Id expected").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-
-    std::string accessKey = info[0].ToString().Utf8Value();
-    std::string roomId = info[1].ToString().Utf8Value();
-    std::string userId = info[2].ToString().Utf8Value();
-
-    OdinTokenGenerator *generator = odin_token_generator_create(accessKey.c_str());
-    if (!generator)
-    {
-        Napi::TypeError::New(env, "Failed to initialize token generator, invalid access key").ThrowAsJavaScriptException();
-        odin_token_generator_destroy(generator);
-        return env.Undefined();
-    }
-
-    /*
-     * Generate a new room token to access the ODIN network
-     */
-    char room_token[512];
-    OdinReturnCode error = odin_token_generator_create_token(generator, roomId.c_str(), userId.c_str(), room_token, sizeof(room_token));
-    if (odin_is_error(error))
-    {
-        Napi::TypeError::New(env, "Creating access token failed").ThrowAsJavaScriptException();
-        odin_token_generator_destroy(generator);
+    if (info.Length() < 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Token expected").ThrowAsJavaScriptException();
         return env.Undefined();
     }
-
-    /*
-     * Destroy the token generator as we don't need it anymore
-     */
-    odin_token_generator_destroy(generator);
-
-    return OdinRoom::NewInstance(Napi::String::New(env, room_token));
+    std::string token = info[0].ToString().Utf8Value();
+    return OdinRoomWrapper::NewInstance(Napi::String::New(env, token));
 }
 
-
-/**
- * Create a new room with a given access token
- * @param info
- * @return
- */
 Napi::Value OdinClient::CreateRoomWithAccessToken(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
-    // Check for existence of access token
     if (info.Length() < 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Access token expected").ThrowAsJavaScriptException();
         return env.Undefined();
     }
-
     std::string token = info[0].ToString().Utf8Value();
-
-    return OdinRoom::NewInstance(Napi::String::New(env, token));
+    return OdinRoomWrapper::NewInstance(Napi::String::New(env, token));
 }

package/cppsrc/odinclient.h

@@ -3,14 +3,11 @@
 
 class OdinClient : public Napi::ObjectWrap<OdinClient> {
  public:
-    static Napi::Object Init(Napi::Env env, Napi::Object exports); //Init function for setting the export key to JS
-    OdinClient(const Napi::CallbackInfo& info); //Constructor to initialise
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    OdinClient(const Napi::CallbackInfo& info);
     void Finalize(Napi::Env env) override;
  private:
     Napi::Value GenerateAccessToken(const Napi::CallbackInfo& info);
     Napi::Value CreateRoom(const Napi::CallbackInfo& info);
     Napi::Value CreateRoomWithAccessToken(const Napi::CallbackInfo& info);
-
-    float _sampleRate;
-    uint32_t _numChannels;
 };