edhoc 1.2.2 → 1.3.0

package/src/EdhocCredentialManager.cpp

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <stdexcept>
 
-#include "UserContext.h"
+#include "RunningContext.h"
 #include "Utils.h"
 
 static constexpr const char* kFormat = "format";
@@ -26,9 +26,6 @@ static constexpr const char* kInvalidInputDataErrorKid = "Invalid input data for
 static constexpr const char* kInvalidInputDataErrorX509Chain = "Invalid input data for X.509 chain";
 static constexpr const char* kInvalidInputDataErrorX509Hash = "Invalid input data for X.509 hash";
 static constexpr const char* kErrorObjectExpected = "Object expected";
-static constexpr const char* kErrorFunctionExpected = "Function expected";
-static constexpr const char* kFetch = "fetch";
-static constexpr const char* kVerify = "verify";
 
 /*
  * Convert a JavaScript object to an edhoc_auth_cred_key_id
@@ -155,71 +152,68 @@ Napi::Object convert_edhoc_x5t_to_js(const Napi::Env& env, const struct edhoc_au
   return obj;
 }
 
-EdhocCredentialManager::EdhocCredentialManager(Napi::Object& jsCredentialManager) {
-  if (!jsCredentialManager.IsObject()) {
+/*
+ * EdhocCredentialManager constructor
+ */
+EdhocCredentialManager::EdhocCredentialManager(Napi::Object& jsCredentialManager, Napi::Object& jsEdhoc) {
+  if (!jsCredentialManager.IsObject() || !jsEdhoc.IsObject()) {
     Napi::Error::New(jsCredentialManager.Env(), kErrorObjectExpected).ThrowAsJavaScriptException();
   }
-  credentialManagerRef = Napi::Persistent(jsCredentialManager);
+  credentialManagerRef_ = Napi::Persistent(jsCredentialManager);
+  edhocRef_ = Napi::Weak(jsEdhoc);
 
   credentials.fetch = FetchCredentials;
   credentials.verify = VerifyCredentials;
 }
 
+/*
+ * EdhocCredentialManager destructor
+ */
 EdhocCredentialManager::~EdhocCredentialManager() {
-  credentialManagerRef.Reset();
-  for (auto& ref : credentialReferences) {
+  credentialManagerRef_.Reset();
+  edhocRef_.Reset();
+  for (auto& ref : credentialReferences_) {
     ref.Reset();
   }
-  credentialReferences.clear();
-}
-
-void EdhocCredentialManager::SetupAsyncFunctions() {
-  SetFunction(kFetch, fetchTsfn);
-  SetFunction(kVerify, verifyTsfn);
-}
-
-void EdhocCredentialManager::CleanupAsyncFunctions() {
-  fetchTsfn.Release();
-  verifyTsfn.Release();
-}
-
-void EdhocCredentialManager::SetFunction(const char* name, Napi::ThreadSafeFunction& tsfn) {
-  Napi::Env env = credentialManagerRef.Env();
-  Napi::HandleScope scope(env);
-  Napi::Function jsFunction = credentialManagerRef.Value().Get(name).As<Napi::Function>();
-  if (!jsFunction.IsFunction()) {
-    Napi::Error::New(env, kErrorFunctionExpected).ThrowAsJavaScriptException();
-  }
-  tsfn = Napi::ThreadSafeFunction::New(env, jsFunction, name, 0, 1);
+  credentialReferences_.clear();
 }
 
+/*
+ * Static method to fetch credentials
+ */
 int EdhocCredentialManager::FetchCredentials(void* user_context, struct edhoc_auth_creds* credentials) {
-  UserContext* context = static_cast<UserContext*>(user_context);
+  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
   EdhocCredentialManager* manager = context->GetCredentialManager();
   return manager->callFetchCredentials(context, credentials);
 }
 
+/*
+ * Static method to verify credentials
+ */
 int EdhocCredentialManager::VerifyCredentials(void* user_context,
                                               struct edhoc_auth_creds* credentials,
                                               const uint8_t** public_key_reference,
                                               size_t* public_key_length) {
-  UserContext* context = static_cast<UserContext*>(user_context);
+  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
   EdhocCredentialManager* manager = context->GetCredentialManager();
   return manager->callVerifyCredentials(context, credentials, public_key_reference, public_key_length);
 }
 
-int EdhocCredentialManager::callFetchCredentials(const void* user_context, struct edhoc_auth_creds* credentials) {
-  std::promise<int> promise;
-  std::future<int> future = promise.get_future();
+/*
+ * Method to fetch credentials
+ */
+int EdhocCredentialManager::callFetchCredentials(RunningContext* runningContext, struct edhoc_auth_creds* credentials) {
 
-  auto successHandler = [this, &promise, &credentials](Napi::Env env, Napi::Value result) {
+  auto successHandler = [this, &credentials](Napi::Env env, Napi::Value result) {
     Napi::HandleScope scope(env);
     auto credsObj = result.As<Napi::Object>();
-    credentialReferences.push_back(Napi::Persistent(credsObj));
 
     if (credsObj.IsObject() == false || credsObj.Has(kFormat) == false) {
       throw std::runtime_error(kInvalidInputCredentialTypeError);
     }
+
+    credentialReferences_.push_back(Napi::Persistent(credsObj));
+
     int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
 
     switch (label) {
@@ -234,7 +228,7 @@ int EdhocCredentialManager::callFetchCredentials(const void* user_context, struc
         break;
       case EDHOC_COSE_ANY:
       default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
+        throw Napi::Error::New(env, kUnsupportedCredentialTypeError);
     }
 
     if (credsObj.Has(kPrivateKeyId) && !credsObj.Get(kPrivateKeyId).IsNull()) {
@@ -242,36 +236,29 @@ int EdhocCredentialManager::callFetchCredentials(const void* user_context, struc
       memcpy(credentials->priv_key_id, privKeyIdBuffer.Data(), privKeyIdBuffer.Length());
     }
 
-    promise.set_value(EDHOC_SUCCESS);
+    return EDHOC_SUCCESS;
   };
 
-  auto blockingCallHandler = [this, &user_context, &successHandler, &promise](Napi::Env env,
-                                                                              Napi::Function jsCallback) {
-    Napi::HandleScope scope(env);
-    std::vector<napi_value> arguments = {static_cast<const UserContext*>(user_context)->parent.Value()};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR);
-    Utils::InvokeJSFunctionWithPromiseHandling(env, credentialManagerRef.Value(), jsCallback, arguments, successHandler,
-                                               errorHandler);
+  auto argumentsHandler = [this](Napi::Env env) {
+    return std::vector<napi_value> { this->edhocRef_.Value() };
   };
 
-  fetchTsfn.BlockingCall(blockingCallHandler);
-
-  future.wait();
-  return future.get();
+  return runningContext->ThreadSafeBlockingCall(credentialManagerRef_, "fetch", argumentsHandler, successHandler);
 }
 
-int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
+/*
+ * Method to verify credentials
+ */
+int EdhocCredentialManager::callVerifyCredentials(RunningContext* runningContext,
                                                   struct edhoc_auth_creds* credentials,
                                                   const uint8_t** public_key_reference,
                                                   size_t* public_key_length) {
-  std::promise<int> promise;
-  std::future<int> future = promise.get_future();
 
-  auto successHandler = [this, &promise, &credentials, &public_key_reference, &public_key_length](Napi::Env env,
-                                                                                                  Napi::Value result) {
+  auto successHandler = [this, &credentials, &public_key_reference, &public_key_length](Napi::Env env, Napi::Value result) {
     Napi::HandleScope scope(env);
     Napi::Object credsObj = result.As<Napi::Object>();
-    credentialReferences.push_back(Napi::Persistent(credsObj));
+    credentialReferences_.push_back(Napi::Persistent(credsObj));
+
     if (credsObj.IsObject() == false) {
       throw std::runtime_error(kInvalidInputCredentialTypeError);
     }
@@ -297,12 +284,10 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
       *public_key_length = publicKeyBuffer.Length();
     }
 
-    promise.set_value(EDHOC_SUCCESS);
+    return EDHOC_SUCCESS;
   };
 
-  auto blockingCallHandler = [this, &user_context, &credentials, &successHandler, &promise](Napi::Env env,
-                                                                                            Napi::Function jsCallback) {
-    Napi::HandleScope scope(env);
+  auto argumentsHandler = [this, &credentials](Napi::Env env) {
     Napi::Object resultObject = Napi::Object::New(env);
     resultObject.Set(kFormat, Napi::Number::New(env, credentials->label));
 
@@ -319,15 +304,11 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
       default:
         throw std::runtime_error(kUnsupportedCredentialTypeError);
     }
-
-    std::vector<napi_value> arguments = {static_cast<const UserContext*>(user_context)->parent.Value(), resultObject};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR);
-    Utils::InvokeJSFunctionWithPromiseHandling(env, credentialManagerRef.Value(), jsCallback, arguments, successHandler,
-                                               errorHandler);
+    return std::vector<napi_value> { 
+      this->edhocRef_.Value(), 
+      resultObject
+    };
   };
 
-  verifyTsfn.BlockingCall(blockingCallHandler);
-
-  future.wait();
-  return future.get();
+  return runningContext->ThreadSafeBlockingCall(credentialManagerRef_, "verify", argumentsHandler, successHandler);
 }