koffi 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -4,12 +4,20 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.1
+
+**Main changes:**
+
+- Error out when trying to use ambiguous `void *` arguments (input and/or output)
+- Adjust TypeScript definitions ([@insraq](https://github.com/insraq))
+- Fix possible crash when parsing invalid prototype
+
 #### Koffi 2.3.0
 
 **Main changes:**
 
 - Allow buffers (TypedArray or ArrayBuffer) values for input and/or output pointer arguments (for polymorphic arguments)
-- Support opaque buffers (TypedArray or ArrayBuffer) values in `koffi.decode()` to [decode output buffers](calls.md#output-parameters)
+- Support opaque buffers (TypedArray or ArrayBuffer) values in `koffi.decode()` to [decode output buffers](calls.md#output-buffers)
 - Decode non-string types as arrays when an [explicit length is passed to koffi.decode()](callbacks.md#pointer-arguments)
 
 **Other changes:**

package/doc/calls.md

@@ -159,7 +159,7 @@ console.log(out[0]);
 
 ## Polymorphic parameters
 
-### Input parameters
+### Input polymorphism
 
 *New in Koffi 2.1*
 
@@ -221,7 +221,7 @@ let hdr = {};
 console.log('PNG header:', hdr);
 ```
 
-### Output parameters
+### Output buffers
 
 *New in Koffi 2.3*
 
@@ -287,7 +287,6 @@ The following example illustrates the use of a disposable type derived from *str
 const koffi = require('koffi');
 const lib = koffi.load('libc.so.6');
 
-// You can also use: const strdup = lib.func('const char *! strdup(const char *str)')
 const HeapStr = koffi.disposable('str');
 const strdup = lib.cdecl('strdup', HeapStr, ['str']);
 

package/package.json

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

package/src/koffi/src/call.cc

@@ -909,6 +909,12 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
             uint8_t *ptr = nullptr;
 
             if (value.IsArray()) {
+                if (RG_UNLIKELY(!type->ref.type->size)) {
+                    ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to void *, use koffi.as()",
+                                                type->ref.type != instance->void_type ? "opaque" : "ambiguous");
+                    return false;
+                }
+
                 Napi::Array array = value.As<Napi::Array>();
 
                 Size len = (Size)array.Length();
@@ -936,6 +942,12 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     directions = 1;
                 }
             } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record)) {
+                if (RG_UNLIKELY(!type->ref.type->size)) {
+                    ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to void *, use koffi.as()",
+                                                type->ref.type != instance->void_type ? "opaque" : "ambiguous");
+                    return false;
+                }
+
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 

package/src/koffi/src/index.d.ts

@@ -21,15 +21,15 @@ declare module 'koffi' {
     type TypeSpec = string | IKoffiCType;
     type TypeSpecWithAlignment = TypeSpec | [number, TypeSpec];
     type TypeInfo = {
-        name: string,
-        primitive: string,
-        size: number,
-        alignment: number,
-        length: number,
-        ref: IKoffiCType,
-        members: Record<string, { name: string, type: {}, offset: number }>
+        name: string;
+        primitive: string;
+        size: number;
+        alignment: number;
+        length: number;
+        ref: IKoffiCType;
+        members: Record<string, { name: string, type: IKoffiCType, offset: number }>;
     };
-    type KoffiFunction = Function | { async: Function };
+    type KoffiFunction = Function & { async: Function };
 
     export interface IKoffiLib {
         func(definition: string): KoffiFunction;
@@ -64,7 +64,7 @@ declare module 'koffi' {
     export function out(value: TypeSpec): IKoffiCType;
     export function inout(value: TypeSpec): IKoffiCType;
 
-    export function as(value: {}, type: TypeSpec): IKoffiPointerCast;
+    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
 
     export function disposable(type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec): IKoffiCType;
@@ -73,15 +73,14 @@ declare module 'koffi' {
     export function callback(definition: string): IKoffiCType;
     export function callback(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
 
-    interface IKoffiRegisteredCallback { __brand: 'IKoffiRegisteredCallback' }
     export function register(callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function unregister(callback: IKoffiRegisteredCallback): void;
 
-    export function decode(value: {}, type: TypeSpec): {};
-    export function decode(value: {}, type: TypeSpec, len: number): {};
-    export function decode(value: {}, offset: number, type: TypeSpec): {};
-    export function decode(value: {}, offset: number, type: TypeSpec, len: number): {};
+    export function decode(value: any, type: TypeSpec): any;
+    export function decode(value: any, type: TypeSpec, len: number): any;
+    export function decode(value: any, offset: number, type: TypeSpec): any;
+    export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
 
     export function sizeof(type: TypeSpec): number;
     export function alignof(type: TypeSpec): number;
@@ -91,6 +90,6 @@ declare module 'koffi' {
 
     export function alias(name: string, type: TypeSpec): IKoffiCType;
 
-    export function config(): {}
-    export function config({}): {}
+    export function config(): Record<string, unknown>;
+    export function config(cfg: Record<string, unknown>): Record<string, unknown>;
 }

package/src/koffi/src/parser.cc

@@ -152,6 +152,7 @@ const TypeInfo *PrototypeParser::ParseType()
         offset++;
     }
     offset += (offset < tokens.len && tokens[offset] == "!");
+    offset = std::min(tokens.len - 1, offset);
 
     while (offset >= start) {
         Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);