koffi 2.3.14 → 2.3.15

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.15
+
+**Main changes:**
+
+- Improve manual decoding of 0-terminated strings
+- Add checks around array conversion hints
+
 #### Koffi 2.3.14
 
 **Main changes:**

package/doc/calls.md

@@ -68,6 +68,60 @@ The same can be done when declaring a function with a C-like prototype string, w
 - `_Out_` for output parameters
 - `_Inout_` for dual input/output parameters
 
+### Primitive value
+
+This Windows example enumerate all Chrome windows along with their PID and their title. The `GetWindowThreadProcessId()` function illustrates how to get a primitive value from an output argument.
+
+```js
+const koffi = require('koffi');
+const user32 = koffi.load('user32.dll');
+
+const DWORD = koffi.alias('DWORD', 'uint32_t');
+const HANDLE = koffi.pointer(koffi.opaque('HANDLE'));
+const HWND = koffi.alias('HWND', HANDLE);
+
+const FindWindowEx = user32.func('HWND __stdcall FindWindowExW(HWND hWndParent, HWND hWndChildAfter, const char16_t *lpszClass, const char16_t *lpszWindow)');
+const GetWindowThreadProcessId = user32.func('DWORD __stdcall GetWindowThreadProcessId(HWND hWnd, _Out_ DWORD *lpdwProcessId)');
+const GetWindowText = user32.func('int __stdcall GetWindowTextA(HWND hWnd, _Out_ uint8_t *lpString, int nMaxCount)');
+
+for (let hwnd = null;;) {
+    hwnd = FindWindowEx(0, hwnd, 'Chrome_WidgetWin_1', null);
+
+    if (!hwnd)
+        break;
+
+    // Get PID
+    let pid;
+    {
+        let ptr = [null];
+        let tid = GetWindowThreadProcessId(hwnd, ptr);
+
+        if (!tid) {
+            // Maybe the process ended in-between?
+            continue;
+        }
+
+        pid = ptr[0];
+    }
+
+    // Get window title
+    let title;
+    {
+        let buf = Buffer.allocUnsafe(1024);
+        let length = GetWindowText(hwnd, buf, buf.length);
+
+        if (!length) {
+            // Maybe the process ended in-between?
+            continue;
+        }
+
+        title = koffi.decode(buf, 'char', length);
+    }
+
+    console.log({ PID: pid, Title: title });
+}
+```
+
 ### Struct example
 
 This example calls the POSIX function `gettimeofday()`, and uses the prototype-like syntax.

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -5891,6 +5891,8 @@ bool StreamReader::Open(Span<const uint8_t> buf, const char *filename,
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<memory>";
 
@@ -5912,6 +5914,8 @@ bool StreamReader::Open(FILE *fp, const char *filename, CompressionType compress
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     RG_ASSERT(fp);
     RG_ASSERT(filename);
@@ -5935,6 +5939,8 @@ OpenResult StreamReader::Open(const char *filename, CompressionType compression_
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     RG_ASSERT(filename);
     this->filename = DuplicateString(filename, &str_alloc).ptr;
@@ -5962,6 +5968,8 @@ bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const ch
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<closure>";
 
@@ -6081,6 +6089,13 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
         eof = source.eof;
     }
 
+    if (RG_UNLIKELY(!error && read_max >= 0 && read_len > read_max - read_total)) {
+        LogError("Exceeded max stream size of %1", FmtDiskSize(read_max));
+        error = true;
+        return -1;
+    }
+    read_total += read_len;
+
     return read_len;
 }
 

package/src/core/libcc/libcc.hh

@@ -4229,6 +4229,9 @@ class StreamReader {
     const char *filename = nullptr;
     bool error = true;
 
+    int64_t read_total = 0;
+    int64_t read_max = -1;
+
     struct {
         SourceType type = SourceType::Memory;
         union U {
@@ -4289,15 +4292,18 @@ public:
 
     const char *GetFileName() const { return filename; }
     CompressionType GetCompressionType() const { return compression_type; }
+    int64_t GetReadLimit() { return read_max; }
     bool IsValid() const { return filename && !error; }
     bool IsEOF() const { return eof; }
 
     FILE *GetFile() const;
     int GetDescriptor() const;
 
+    void SetReadLimit(int64_t limit) { read_max = limit; }
+
     Size Read(Span<uint8_t> out_buf);
     Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
-    Size Read(Size max_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, max_len)); }
+    Size Read(Size buf_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, buf_len)); }
 
     Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
     Size ReadAll(Size max_len, HeapArray<char> *out_buf)

package/src/koffi/src/ffi.cc

@@ -816,6 +816,11 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         ArrayHint hint = {};
 
         if (to == "Typed" || to == "typed") {
+            if (!(ref->flags & (int)TypeFlag::HasTypedArray)) {
+                ThrowError<Napi::Error>(env, "Array hint 'Typed' cannot be used with type %1", ref->name);
+                return env.Null();
+            }
+
             hint = ArrayHint::Typed;
         } else if (to == "Array" || to == "array") {
             hint = ArrayHint::Array;
@@ -1733,7 +1738,6 @@ void LibraryHolder::Unref() const
     }
 }
 
-
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
@@ -1750,6 +1754,13 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     type->size = size;
     type->align = align;
 
+    if (IsInteger(type) || IsFloat(type)) {
+        type->flags |= (int)TypeFlag::HasTypedArray;
+    }
+    if (TestStr(type->name, "char") || TestStr(type->name, "char16") || TestStr(type->name, "char16_t")) {
+        type->flags |= (int)TypeFlag::IsCharLike;
+    }
+
     if (ref) {
         const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
         RG_ASSERT(marker);
@@ -1999,10 +2010,16 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value value = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-    int64_t len = has_len ? info[2u + has_offset].As<Napi::Number>().Int64Value() : -1;
 
-    Napi::Value ret = Decode(value, offset, type, len);
-    return ret;
+    if (has_len) {
+        Size len = info[2u + has_offset].As<Napi::Number>();
+
+        Napi::Value ret = Decode(value, offset, type, &len);
+        return ret;
+    } else {
+        Napi::Value ret = Decode(value, offset, type);
+        return ret;
+    }
 }
 
 static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)

package/src/koffi/src/ffi.hh

@@ -103,6 +103,11 @@ struct FunctionInfo;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
+enum class TypeFlag {
+    HasTypedArray = 1 << 0,
+    IsCharLike = 1 << 1
+};
+
 enum class ArrayHint {
     Array,
     Typed,
@@ -120,6 +125,7 @@ struct TypeInfo {
     PrimitiveKind primitive;
     int32_t size;
     int16_t align;
+    uint16_t flags;
 
     DisposeFunc *dispose;
     Napi::FunctionReference dispose_ref;

package/src/koffi/src/util.cc

@@ -329,11 +329,12 @@ const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
 {
     ArrayHint hint = {};
 
-    if (TestStr(ref->name, "char") || TestStr(ref->name, "char16") ||
-                                             TestStr(ref->name, "char16_t")) {
+    if (ref->flags & (int)TypeFlag::IsCharLike) {
         hint = ArrayHint::String;
-    } else {
+    } else if (ref->flags & (int)TypeFlag::HasTypedArray) {
         hint = ArrayHint::Typed;
+    } else {
+        hint = ArrayHint::Array;
     }
 
     return MakeArrayType(instance, ref, len, hint, true);
@@ -1002,7 +1003,7 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 #undef SWAP
 }
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len)
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len)
 {
     Napi::Env env = value.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1035,13 +1036,35 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size le
     return ret;
 }
 
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len)
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (len >= 0 && type->primitive != PrimitiveKind::String &&
-                    type->primitive != PrimitiveKind::String16) {
-        type = MakeArrayType(instance, type, len);
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16) {
+        if (*len >= 0) {
+            type = MakeArrayType(instance, type, *len);
+        } else {
+            if (RG_UNLIKELY(!(type->flags & (int)TypeFlag::IsCharLike))) {
+                ThrowError<Napi::TypeError>(env, "Only char-like types can find their length automatically", type->name);
+                return env.Null();
+            }
+
+            switch (type->primitive) {
+                case PrimitiveKind::Int8: {
+                    Size count = strlen((const char *)ptr);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+                case PrimitiveKind::Int16: {
+                    Size count = WideStringLength((const char16_t *)ptr, RG_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                default: { RG_UNREACHABLE(); } break;
+            }
+
+        }
+
     }
 
 #define RETURN_INT(Type, NewCall) \
@@ -1080,18 +1103,18 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size
         case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewBigInt); } break;
         case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewBigInt); } break;
         case PrimitiveKind::String: {
-            if (len >= 0) {
+            if (len) {
                 const char *str = *(const char **)ptr;
-                return str ? Napi::String::New(env, str, len) : env.Null();
+                return str ? Napi::String::New(env, str, *len) : env.Null();
             } else {
                 const char *str = *(const char **)ptr;
                 return str ? Napi::String::New(env, str) : env.Null();
             }
         } break;
         case PrimitiveKind::String16: {
-            if (len >= 0) {
+            if (len) {
                 const char16_t *str16 = *(const char16_t **)ptr;
-                return str16 ? Napi::String::New(env, str16, len) : env.Null();
+                return str16 ? Napi::String::New(env, str16, *len) : env.Null();
             } else {
                 const char16_t *str16 = *(const char16_t **)ptr;
                 return str16 ? Napi::String::New(env, str16) : env.Null();

package/src/koffi/src/util.hh

@@ -160,8 +160,8 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
 void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len = -1);
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len = -1);
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
 
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {