koffi 2.6.9 → 2.6.11

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ### Koffi 2.6
 
+#### Koffi 2.6.11 (2023-12-05)
+
+- Speed up resolving simple and often used type names
+- Fix use of optional length argument with [koffi.encode()](variables.md#encode-to-c-memory)
+
+#### Koffi 2.6.10 (2023-11-29)
+
+- Protect GetLastError() value from Node.js and V8 on Windows
+
 #### Koffi 2.6.9 (2023-11-25)
 
 - Search in DLL directory for additional dependencies on Windows

package/doc/variables.md

@@ -54,7 +54,7 @@ There is also an optional ending `length` argument that you can use in two cases
 - Use it to give the number of bytes to decode in non-NUL terminated strings: `koffi.decode(value, 'char *', 5)`
 - Decode consecutive values into an array. For example, here is how you can decode an array with 3 float values: `koffi.decode(value, 'float', 3)`. This is equivalent to `koffi.decode(value, koffi.array('float', 3))`.
 
-Thge example below will decode the symbol `my_string` defined above but only the first three bytes.
+The example below will decode the symbol `my_string` defined above but only the first three bytes.
 
 ```js
 // Only decode 3 bytes from the C string my_string
@@ -69,7 +69,7 @@ In Koffi 2.2 and earlier versions, the length argument is only used to decode st
 
 *New in Koffi 2.6*
 
-Use `koffi.encode()` to encode C pointers, wrapped as external objects or as simple numbers.
+Use `koffi.encode()` to encode JS values into C symbols or pointers, wrapped as external objects or as simple numbers.
 
 Some arguments are optional and this function can be called in several ways:
 
@@ -98,3 +98,9 @@ console.log(koffi.decode(my_string, 'const char *')) // Prints "Hello World!"
 ```
 
 When encoding strings (either directly or embedded in arrays or structs), the memory will be bound to the raw pointer value and managed by Koffi. You can assign to the same string again and again without any leak or risk of use-after-free.
+
+There is also an optional ending `length` argument that you can use to encode an array. For example, here is how you can encode an array with 3 float values: `koffi.encode(symbol, 'float', [1, 2, 3], 3)`. This is equivalent to `koffi.encode(symbol, koffi.array('float', 3), [1, 2, 3])`.
+
+```{note}
+The length argument did not work correctly before Koffi 2.6.11.
+```

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.9",
-      stable: "2.6.9",
+      version: "2.6.11",
+      stable: "2.6.11",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

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.9",
-      stable: "2.6.9",
+      version: "2.6.11",
+      stable: "2.6.11",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -931,6 +931,35 @@ static Span<char> FormatUnsignedToDecimal(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
+static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
+{
+    Size msb = 64 - (Size)CountLeadingZeros(value);
+    if (!msb) {
+        msb = 1;
+    }
+
+    for (Size i = 0; i < msb; i++) {
+        bool bit = (value >> (msb - i - 1)) & 0x1;
+        out_buf[i] = bit ? '1' : '0';
+    }
+
+    return MakeSpan(out_buf, msb);
+}
+
+static Span<char> FormatUnsignedToOctal(uint64_t value, char out_buf[64])
+{
+    static const char literals[] = "012345678";
+
+    Size offset = 64;
+    do {
+        uint64_t digit = value & 0x7;
+        value >>= 3;
+        out_buf[--offset] = literals[digit];
+    } while (value);
+
+    return MakeSpan(out_buf + offset, 64 - offset);
+}
+
 static Span<char> FormatUnsignedToBigHex(uint64_t value, char out_buf[32])
 {
     static const char literals[] = "0123456789ABCDEF";
@@ -959,21 +988,6 @@ static Span<char> FormatUnsignedToSmallHex(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
-static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
-{
-    Size msb = 64 - (Size)CountLeadingZeros(value);
-    if (!msb) {
-        msb = 1;
-    }
-
-    for (Size i = 0; i < msb; i++) {
-        bool bit = (value >> (msb - i - 1)) & 0x1;
-        out_buf[i] = bit ? '1' : '0';
-    }
-
-    return MakeSpan(out_buf, msb);
-}
-
 #ifdef JKJ_HEADER_DRAGONBOX
 static Size FakeFloatPrecision(Span<char> buf, int K, int min_prec, int max_prec, int *out_K)
 {
@@ -1250,6 +1264,9 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             case FmtType::Binary: {
                 out = FormatUnsignedToBinary(arg.u.u, num_buf);
             } break;
+            case FmtType::Octal: {
+                out = FormatUnsignedToOctal(arg.u.u, num_buf);
+            } break;
             case FmtType::BigHex: {
                 out = FormatUnsignedToBigHex(arg.u.u, num_buf);
             } break;
@@ -1480,6 +1497,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                         case FmtType::Integer:
                         case FmtType::Unsigned:
                         case FmtType::Binary:
+                        case FmtType::Octal:
                         case FmtType::BigHex:
                         case FmtType::SmallHex: {
                             switch (arg.u.span.type_len) {
@@ -2155,7 +2173,7 @@ fail:
     return str_buf;
 }
 
-static FileType FileAttributesToType(uint32_t attr)
+static inline FileType FileAttributesToType(uint32_t attr)
 {
     if (attr & FILE_ATTRIBUTE_DIRECTORY) {
         return FileType::Directory;

package/src/core/libcc/libcc.hh

@@ -2862,6 +2862,7 @@ enum class FmtType {
     Float,
     Double,
     Binary,
+    Octal,
     BigHex,
     SmallHex,
     MemorySize,
@@ -2960,6 +2961,13 @@ static inline FmtArg FmtBin(uint64_t u)
     arg.u.u = u;
     return arg;
 }
+static inline FmtArg FmtOctal(uint64_t u)
+{
+    FmtArg arg;
+    arg.type = FmtType::Octal;
+    arg.u.u = u;
+    return arg;
+}
 static inline FmtArg FmtHex(uint64_t u, FmtType type = FmtType::BigHex)
 {
     RG_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);

package/src/koffi/src/abi_arm64.cc

@@ -577,6 +577,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         teb->StackLimit = limit;
         teb->DeallocationStack = dealloc;
         teb->GuaranteedStackBytes = guaranteed;
+
+        instance->last_error = teb->LastErrorValue;
     };
 
     // Adjust stack limits so SEH works correctly
@@ -585,6 +587,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
     teb->StackLimit = mem->stack0.ptr;
     teb->DeallocationStack = mem->stack0.ptr;
     teb->GuaranteedStackBytes = 0;
+
+    teb->LastErrorValue = instance->last_error;
 #endif
 
 #define PERFORM_CALL(Suffix) \

package/src/koffi/src/abi_x64_win.cc

@@ -239,6 +239,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         teb->StackLimit = limit;
         teb->DeallocationStack = dealloc;
         teb->GuaranteedStackBytes = guaranteed;
+
+        instance->last_error = teb->LastErrorValue;
     };
 
     // Adjust stack limits so SEH works correctly
@@ -248,6 +250,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
     teb->DeallocationStack = mem->stack0.ptr;
     teb->GuaranteedStackBytes = 0;
 
+    teb->LastErrorValue = instance->last_error;
+
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \

package/src/koffi/src/abi_x86.cc

@@ -336,6 +336,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         teb->StackLimit = limit;
         teb->DeallocationStack = dealloc;
         teb->GuaranteedStackBytes = guaranteed;
+
+        instance->last_error = teb->LastErrorValue;
     };
 
     // Adjust stack limits so SEH works correctly
@@ -344,6 +346,8 @@ void CallData::Execute(const FunctionInfo *func, void *native)
     teb->StackLimit = mem->stack0.ptr;
     teb->DeallocationStack = mem->stack0.ptr;
     teb->GuaranteedStackBytes = 0;
+
+    teb->LastErrorValue = instance->last_error;
 #endif
 
 #define PERFORM_CALL(Suffix) \

package/src/koffi/src/ffi.cc

@@ -1639,51 +1639,6 @@ static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
-#ifdef _WIN32
-static HANDLE LoadWindowsLibrary(Napi::Env env, Span<const char> path)
-{
-    BlockAllocator temp_alloc;
-
-    Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, path.len + 1);
-
-    if (ConvertUtf8ToWin32Wide(path, filename_w) < 0)
-        return nullptr;
-
-    HMODULE module = LoadLibraryW(filename_w.ptr);
-
-    if (!module) {
-        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;
-
-        module = LoadLibraryExW(filename_w.ptr, nullptr, flags);
-    }
-
-    if (!module) {
-        if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
-            int process = GetSelfMachine();
-            int dll = GetDllMachine(filename_w.ptr);
-
-            if (process >= 0 && dll >= 0 && dll != process) {
-                ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
-                                        WindowsMachineNames.FindValue(dll, "Unknown"),
-                                        WindowsMachineNames.FindValue(process, "Unknown"));
-                return nullptr;
-            }
-        }
-
-        ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
-        return nullptr;
-    }
-
-    return module;
-}
-#endif
-
 static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -2011,7 +1966,7 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
-    bool has_len = (info.Length() >= 4u + has_offset && info[2u + has_offset].IsNumber());
+    bool has_len = (info.Length() >= 4u + has_offset && info[3u + has_offset].IsNumber());
 
     if (info.Length() < 3u + has_offset) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 to 5 arguments, got %2", 3 + has_offset, info.Length());
@@ -2024,10 +1979,10 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value ref = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-    Napi::Value value = info[2u + has_offset + has_len];
+    Napi::Value value = info[2u + has_offset];
 
     if (has_len) {
-        Size len = info[2u + has_offset].As<Napi::Number>();
+        Size len = info[3u + has_offset].As<Napi::Number>();
 
         if (!Encode(ref, offset, value, type, &len))
             return env.Null();

package/src/koffi/src/ffi.hh

@@ -286,6 +286,8 @@ struct InstanceData {
 #ifdef _WIN32
     void *main_stack_max;
     void *main_stack_min;
+
+    uint32_t last_error = 0;
 #endif
 
     BucketArray<BlockAllocator> encode_allocators;

package/src/koffi/src/util.cc

@@ -117,13 +117,28 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
     if (value.IsString()) {
         std::string str = value.As<Napi::String>();
-        const TypeInfo *type = ResolveType(env, str.c_str(), out_directions);
 
-        if (!type) {
-            if (!env.IsExceptionPending()) {
-                ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+        // Quick path for known types (int, float *, etc.)
+        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+
+        if (!type || (type->flags & (int)TypeFlag::IsIncomplete)) {
+            type = ResolveType(env, str.c_str(), out_directions);
+
+            if (!type) {
+                if (!env.IsExceptionPending()) {
+                    ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+                }
+                return nullptr;
+            }
+
+            // Cache for quick future access
+            bool inserted;
+            auto bucket = instance->types_map.TrySetDefault(str.c_str(), &inserted);
+
+            if (inserted) {
+                bucket->key = DuplicateString(str.c_str(), &instance->str_alloc).ptr;
+                bucket->value = type;
             }
-            return nullptr;
         }
 
         return type;
@@ -200,48 +215,54 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         }
     }
 
-    // Skip initial const qualifiers
-    str = TrimStr(str);
-    while (SplitIdentifier(str) == "const") {
-        str = str.Take(6, str.len - 6);
-        str = TrimStr(str);
-    }
-    str = TrimStr(str);
-
-    Span<const char> remain = str;
+    Span<const char> name;
+    Span<const char> after;
+    {
+        Span<const char> remain = str;
 
-    // Consume one or more identifiers (e.g. unsigned int)
-    for (;;) {
+        // Skip initial const qualifiers
+        remain = TrimStr(remain);
+        while (SplitIdentifier(remain) == "const") {
+            remain = remain.Take(6, remain.len - 6);
+            remain = TrimStr(remain);
+        }
         remain = TrimStr(remain);
 
-        Span<const char> token = SplitIdentifier(remain);
-        if (!token.len)
-            break;
-        remain = remain.Take(token.len, remain.len - token.len);
-    }
+        after = remain;
 
-    Span<const char> name = TrimStr(MakeSpan(str.ptr, remain.ptr - str.ptr));
+        // Consume one or more identifiers (e.g. unsigned int)
+        for (;;) {
+            after = TrimStr(after);
+
+            Span<const char> token = SplitIdentifier(after);
+            if (!token.len)
+                break;
+            after = after.Take(token.len, after.len - token.len);
+        }
+
+        name = TrimStr(MakeSpan(remain.ptr, after.ptr - remain.ptr));
+    }
 
     // Consume pointer indirections
-    while (remain.len) {
-        if (remain[0] == '*') {
-            remain = remain.Take(1, remain.len - 1);
+    while (after.len) {
+        if (after[0] == '*') {
+            after = after.Take(1, after.len - 1);
             indirect++;
 
             if (indirect >= RG_SIZE(disposables) * 8) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Too many pointer indirections");
                 return nullptr;
             }
-        } else if (remain[0] == '!') {
-            remain = remain.Take(1, remain.len - 1);
+        } else if (after[0] == '!') {
+            after = after.Take(1, after.len - 1);
             disposables |= (1u << indirect);
-        } else if (SplitIdentifier(remain) == "const") {
-            remain = remain.Take(6, remain.len - 6);
+        } else if (SplitIdentifier(after) == "const") {
+            after = after.Take(6, after.len - 6);
         } else {
             break;
         }
 
-        remain = TrimStr(remain);
+        after = TrimStr(after);
     }
 
     const TypeInfo *type = instance->types_map.FindValue(name, nullptr);

package/src/koffi/src/win32.cc

@@ -67,6 +67,49 @@ const HashMap<int, const char *> WindowsMachineNames = {
     { 0x169, "MIPS little-endian WCE v2" }
 };
 
+HANDLE LoadWindowsLibrary(Napi::Env env, Span<const char> path)
+{
+    BlockAllocator temp_alloc;
+
+    Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, path.len + 1);
+
+    if (ConvertUtf8ToWin32Wide(path, filename_w) < 0)
+        return nullptr;
+
+    HMODULE module = LoadLibraryW(filename_w.ptr);
+
+    if (!module) {
+        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;
+
+        module = LoadLibraryExW(filename_w.ptr, nullptr, flags);
+    }
+
+    if (!module) {
+        if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
+            int process = GetSelfMachine();
+            int dll = GetDllMachine(filename_w.ptr);
+
+            if (process >= 0 && dll >= 0 && dll != process) {
+                ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
+                                        WindowsMachineNames.FindValue(dll, "Unknown"),
+                                        WindowsMachineNames.FindValue(process, "Unknown"));
+                return nullptr;
+            }
+        }
+
+        ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
+        return nullptr;
+    }
+
+    return module;
+}
+
 // Fails silently on purpose
 static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
 {

package/src/koffi/src/win32.hh

@@ -72,9 +72,11 @@ struct TEB {
     void *ExceptionList;
     void *StackBase;
     void *StackLimit;
-    char _pad1[5216];
+    char _pad1[80];
+    unsigned long LastErrorValue;
+    char _pad2[5132];
     void *DeallocationStack;
-    char _pad2[712];
+    char _pad3[712];
     uint32_t GuaranteedStackBytes;
 };
 static_assert(RG_OFFSET_OF(TEB, DeallocationStack) == 0x1478);
@@ -86,9 +88,11 @@ struct TEB {
     void *ExceptionList;
     void *StackBase;
     void *StackLimit;
-    char _pad1[3584];
+    char _pad1[40];
+    unsigned long LastErrorValue;
+    char _pad2[3540];
     void *DeallocationStack;
-    char _pad2[360];
+    char _pad3[360];
     uint32_t GuaranteedStackBytes;
 };
 static_assert(RG_OFFSET_OF(TEB, DeallocationStack) == 0xE0C);
@@ -111,6 +115,8 @@ static inline TEB *GetTEB()
 
 extern const HashMap<int, const char *> WindowsMachineNames;
 
+void *LoadWindowsLibrary(Napi::Env env, Span<const char> path); // Returns HANDLE
+
 int GetSelfMachine();
 int GetDllMachine(const wchar_t *filename);