koffi 2.6.6 → 2.6.8

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.6
 
+#### Koffi 2.6.8 (2023-11-24)
+
+- Search in DLL directory for additional dependencies on Windows
+- Ignore prototype properties when making structs or unions
+- Show detected version of Node when not adequate
+- Minor documentation fixes
+
 #### Koffi 2.6.6 (2023-10-28)
 
 - Better handle errors while making struct or union types

package/doc/pointers.md

@@ -19,7 +19,7 @@ The following Win32 example uses `GetCursorPos()` (with an output parameter) to
 // ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
-const lib = koffi.load('kernel32.dll');
+const lib = koffi.load('user32.dll');
 
 // Type declarations
 const POINT = koffi.struct('POINT', {

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.6",
-      stable: "2.6.6",
+      version: "2.6.8",
+      stable: "2.6.8",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -438,9 +438,9 @@ if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
   let major = parseInt(process.versions.node, 10);
   let required = get_napi_version(pkg.cnoke.napi, major);
   if (required != null) {
-    throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
   } else {
-    throw new Error(`Project ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
   }
 }
 var arch = determine_arch();

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.6",
-      stable: "2.6.6",
+      version: "2.6.8",
+      stable: "2.6.8",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -438,9 +438,9 @@ if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
   let major = parseInt(process.versions.node, 10);
   let required = get_napi_version(pkg.cnoke.napi, major);
   if (required != null) {
-    throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
   } else {
-    throw new Error(`Project ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
   }
 }
 var arch = determine_arch();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.6.6",
-    "stable": "2.6.6",
+    "version": "2.6.8",
+    "stable": "2.6.8",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/cnoke/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cnoke",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Build native Node addons based on CMake, without extra dependency",
   "keywords": [
     "native",

package/src/core/libcc/libcc.cc

@@ -2067,11 +2067,17 @@ bool IsWin32Utf8()
 
 Size ConvertUtf8ToWin32Wide(Span<const char> str, Span<wchar_t> out_str_w)
 {
-    RG_ASSERT(out_str_w.len >= 2);
+    if (!out_str_w.len) {
+        LogError("Output buffer is too small");
+        return -1;
+    }
 
-    if (!str.len) [[unlikely]] {
+    if (!str.len) {
         out_str_w[0] = 0;
         return 0;
+    } else if (out_str_w.len == 1) {
+        LogError("Output buffer is too small");
+        return -1;
     }
 
     int len = MultiByteToWideChar(CP_UTF8, 0, str.ptr, (int)str.len, out_str_w.ptr, (int)out_str_w.len - 1);
@@ -2092,7 +2098,10 @@ Size ConvertUtf8ToWin32Wide(Span<const char> str, Span<wchar_t> out_str_w)
 
 Size ConvertWin32WideToUtf8(LPCWSTR str_w, Span<char> out_str)
 {
-    RG_ASSERT(out_str.len >= 1);
+    if (!out_str.len) {
+        LogError("Output buffer is too small");
+        return -1;
+    }
 
     int len = WideCharToMultiByte(CP_UTF8, 0, str_w, -1, out_str.ptr, (int)out_str.len - 1, nullptr, nullptr);
     if (!len) {
@@ -5218,7 +5227,7 @@ restart:
             int ret = syscall(SYS_getrandom, &buf, RG_SIZE(buf), 0);
             RG_CRITICAL(ret >= 0, "getentropy() failed: %1", strerror(errno));
 
-            if (ret < RG_SIZE(buf))
+            if (ret < RG_SIZE(buf)) [[unlikely]]
                 goto restart;
         }
 #else

package/src/core/libcc/libcc.hh

@@ -4595,6 +4595,10 @@ public:
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
         : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
+    StreamWriter(HeapArray<char> *mem, const char *filename = nullptr,
+                 CompressionType compression_type = CompressionType::None,
+                 CompressionSpeed compression_speed = CompressionSpeed::Default)
+        : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
     StreamWriter(FILE *fp, const char *filename,
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
@@ -4612,6 +4616,10 @@ public:
     bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
+    bool Open(HeapArray<char> *mem, const char *filename = nullptr,
+              CompressionType compression_type = CompressionType::None,
+              CompressionSpeed compression_speed = CompressionSpeed::Default)
+        { return Open((HeapArray<uint8_t> *)mem, filename, compression_type, compression_speed); }
     bool Open(FILE *fp, const char *filename,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);

package/src/koffi/src/call.cc

@@ -383,7 +383,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 return false;
             }
         } else {
-            Napi::Array properties = obj.GetPropertyNames();
+            Napi::Array properties = GetOwnPropertyNames(obj);
 
             if (properties.Length() != 1 || !properties.Get(0u).IsString()) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Expected object with single property name for union");

package/src/koffi/src/ffi.cc

@@ -131,7 +131,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
         int max_async_calls = new_config.resident_async_pools + new_config.max_temporaries;
 
         Napi::Object obj = info[0].As<Napi::Object>();
-        Napi::Array keys = obj.GetPropertyNames();
+        Napi::Array keys = GetOwnPropertyNames(obj);
 
         for (uint32_t i = 0; i < keys.Length(); i++) {
             std::string key = keys.Get(i).As<Napi::String>();
@@ -227,7 +227,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
-    Napi::Array keys = obj.GetPropertyNames();
+    Napi::Array keys = GetOwnPropertyNames(obj);
 
     RG_DEFER_NC(err_guard, len = instance->types.len) {
         Size start = len + !named;
@@ -373,7 +373,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
-    Napi::Array keys = obj.GetPropertyNames();
+    Napi::Array keys = GetOwnPropertyNames(obj);
 
     RG_DEFER_NC(err_guard, len = instance->types.len) {
         Size start = len + !named;
@@ -1640,14 +1640,24 @@ static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
 }
 
 #ifdef _WIN32
-static HANDLE LoadWindowsLibrary(Napi::Env env, const char16_t *filename)
+static HANDLE LoadWindowsLibrary(Napi::Env env, const char *path)
 {
-    HANDLE module = LoadLibraryW((LPCWSTR)filename);
+    BlockAllocator temp_alloc;
+
+    DWORD flags = LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR;
+
+    Span<const char> filename = NormalizePath(path, GetWorkingDirectory(), &temp_alloc);
+    Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, filename.len + 1);
+
+    if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
+        return nullptr;
+
+    HMODULE module = LoadLibraryExW(filename_w.ptr, nullptr, flags);
 
     if (!module) {
         if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
             int process = GetSelfMachine();
-            int dll = GetDllMachine(filename);
+            int dll = GetDllMachine(filename_w.ptr);
 
             if (process >= 0 && dll >= 0 && dll != process) {
                 ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
@@ -1700,7 +1710,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     void *module = nullptr;
 #ifdef _WIN32
     if (info[0].IsString()) {
-        std::u16string filename = info[0].As<Napi::String>();
+        std::string filename = info[0].As<Napi::String>();
         module = LoadWindowsLibrary(env, filename.c_str());
 
         if (!module)

package/src/koffi/src/util.hh

@@ -193,6 +193,19 @@ static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
     }
 }
 
+static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
+{
+    Napi::Env env = obj.Env();
+
+    napi_value result;
+    napi_status status = napi_get_all_property_names(env, obj, napi_key_own_only,
+                                                     (napi_key_filter)(napi_key_enumerable | napi_key_skip_symbols),
+                                                     napi_key_numbers_to_strings, &result);
+    RG_ASSERT(status == napi_ok);
+
+    return Napi::Array(env, result);
+}
+
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);

package/src/koffi/src/win32.cc

@@ -136,7 +136,7 @@ int GetSelfMachine()
     return GetFileMachine(h, false);
 }
 
-int GetDllMachine(const char16_t *filename)
+int GetDllMachine(const wchar_t *filename)
 {
     HANDLE h = CreateFileW((LPCWSTR)filename, GENERIC_READ,
                            FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,

package/src/koffi/src/win32.hh

@@ -112,6 +112,6 @@ static inline TEB *GetTEB()
 extern const HashMap<int, const char *> WindowsMachineNames;
 
 int GetSelfMachine();
-int GetDllMachine(const char16_t *filename);
+int GetDllMachine(const wchar_t *filename);
 
 }