edhoc 1.2.3 → 1.3.1

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
@@ -36,7 +33,7 @@ static constexpr const char* kVerify = "verify";
 void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object kidObj = jsObject.Get(kKid).As<Napi::Object>();
   if (!kidObj.Has(kIsCBOR) || !kidObj.Has(kKid) || !kidObj.Has(kCredentials)) {
-    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorKid).ThrowAsJavaScriptException();
+    throw std::runtime_error(kInvalidInputDataErrorKid);
   }
 
   credentials->label = EDHOC_COSE_HEADER_KID;
@@ -58,7 +55,7 @@ void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_cre
     credentials->key_id.key_id_bstr_length = buffer.Length();
     memcpy(credentials->key_id.key_id_bstr, buffer.Data(), buffer.Length());
   } else {
-    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorKid).ThrowAsJavaScriptException();
+    throw std::runtime_error(kInvalidInputDataErrorKid);
   }
 
   Napi::Buffer<uint8_t> credBuffer = kidObj.Get(kCredentials).As<Napi::Buffer<uint8_t>>();
@@ -73,7 +70,7 @@ void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_cre
 void convert_js_to_edhoc_x5chain(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object x5chainObj = jsObject.Get(kX5chain).As<Napi::Object>();
   if (!x5chainObj.Has(kCertificates)) {
-    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorX509Chain).ThrowAsJavaScriptException();
+    throw std::runtime_error(kInvalidInputDataErrorX509Chain);
   }
 
   credentials->label = EDHOC_COSE_HEADER_X509_CHAIN;
@@ -95,7 +92,7 @@ void convert_js_to_edhoc_x5chain(const Napi::Object& jsObject, struct edhoc_auth
 void convert_js_to_edhoc_x5t(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object x5tObj = jsObject.Get(kX5t).As<Napi::Object>();
   if (!x5tObj.Has(kCertificate) || !x5tObj.Has(kHash) || !x5tObj.Has(kHashAlgorithm)) {
-    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorX509Hash).ThrowAsJavaScriptException();
+    throw std::runtime_error(kInvalidInputDataErrorX509Hash);
   }
 
   credentials->label = EDHOC_COSE_HEADER_X509_HASH;
@@ -155,73 +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) {
 
-  UserContext* context = static_cast<UserContext*>(const_cast<void*>(user_context));
-  auto successHandler = [this, &promise, &credentials, &context](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) {
-      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
-      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+      throw std::runtime_error(kInvalidInputCredentialTypeError);
     }
+
+    credentialReferences_.push_back(Napi::Persistent(credsObj));
+
     int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
 
     switch (label) {
@@ -236,54 +228,39 @@ int EdhocCredentialManager::callFetchCredentials(const void* user_context, struc
         break;
       case EDHOC_COSE_ANY:
       default:
-        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
-        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+        throw Napi::Error::New(env, kUnsupportedCredentialTypeError);
     }
 
     if (credsObj.Has(kPrivateKeyId) && !credsObj.Get(kPrivateKeyId).IsNull()) {
       Napi::Buffer<uint8_t> privKeyIdBuffer = credsObj.Get(kPrivateKeyId).As<Napi::Buffer<uint8_t>>();
       memcpy(credentials->priv_key_id, privKeyIdBuffer.Data(), privKeyIdBuffer.Length());
     }
-    else {
-      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
-      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
-    }
 
-    promise.set_value(EDHOC_SUCCESS);
+    return EDHOC_SUCCESS;
   };
 
-  auto blockingCallHandler = [this, &context, &successHandler, &promise](Napi::Env env,
-                                                                              Napi::Function jsCallback) {
-    Napi::HandleScope scope(env);
-    std::vector<napi_value> arguments = {context->parent.Value()};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR, context->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();
-
-  UserContext* context = static_cast<UserContext*>(const_cast<void*>(user_context));
 
-  auto successHandler = [this, &promise, &credentials, &public_key_reference, &public_key_length, &context](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) {
-      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
-      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+      throw std::runtime_error(kInvalidInputCredentialTypeError);
     }
 
     int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
@@ -298,8 +275,7 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
         convert_js_to_edhoc_x5t(credsObj, credentials);
         break;
       default:
-        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
-        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+        throw std::runtime_error(kUnsupportedCredentialTypeError);
     }
 
     if (credsObj.Has(kPublicKey) && !credsObj.Get(kPublicKey).IsNull()) {
@@ -307,17 +283,11 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
       *public_key_reference = publicKeyBuffer.Data();
       *public_key_length = publicKeyBuffer.Length();
     }
-    else {
-      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
-      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
-    }
 
-    promise.set_value(EDHOC_SUCCESS);
+    return EDHOC_SUCCESS;
   };
 
-  auto blockingCallHandler = [this, &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));
 
@@ -332,18 +302,13 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
         resultObject.Set(kX5t, convert_edhoc_x5t_to_js(env, credentials->x509_hash));
         break;
       default:
-        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
-        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+        throw std::runtime_error(kUnsupportedCredentialTypeError);
     }
-
-    std::vector<napi_value> arguments = {context->parent.Value(), resultObject};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR, context->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);
 }