koffi 2.2.6-beta.1 → 2.2.6-beta.2

package/doc/callbacks.md

@@ -1,5 +1,7 @@
 # Callbacks
 
+## Callback types
+
 In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.
 
 ```js
@@ -24,7 +26,7 @@ Now, you must use them through a pointer: `void CallIt(CallbackType func)` in Ko
 Consult the [migration guide](migration.md) for more information.
 ```
 
-## Callback types
+## Transient and registered callbacks
 
 Koffi only uses predefined static trampolines, and does not need to generate code at runtime, which makes it compatible with platforms with hardened W^X migitations (such as PaX mprotect). However, this imposes some restrictions on the maximum number of callbacks, and their duration.
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.2.6-beta.1",
+    "version": "2.2.6-beta.2",
     "stable": "2.2.5",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/koffi/src/call.cc

@@ -511,8 +511,10 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
                     if (!PushNormalArray(array, len, member.type, dest, realign))
                         return false;
-                } else if (value.IsTypedArray() || value.IsArrayBuffer()) {
-                    if (!PushArrayBuffer(value, member.type->size, member.type, dest, realign))
+                } else if (IsRawBuffer(value)) {
+                    Span<const uint8_t> buffer = GetRawBuffer(value);
+
+                    if (!PushBuffer(buffer, member.type->size, member.type, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, member.type, dest))
@@ -748,8 +750,10 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
 
                     if (!PushNormalArray(array2, len2, ref, dest, realign))
                         return false;
-                } else if (value.IsTypedArray() || value.IsArrayBuffer()) {
-                    if (!PushArrayBuffer(value, ref->size, ref, dest, realign))
+                } else if (IsRawBuffer(value)) {
+                    Span<const uint8_t> buffer = GetRawBuffer(value);
+
+                    if (!PushBuffer(buffer, ref->size, ref, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, ref, dest))
@@ -815,16 +819,10 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
     return true;
 }
 
-bool CallData::PushArrayBuffer(Napi::Value value, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
-    RG_ASSERT(value.IsTypedArray() || value.IsArrayBuffer());
-
-    Napi::ArrayBuffer buffer = value.IsTypedArray() ? value.As<Napi::TypedArray>().ArrayBuffer()
-                                                    : value.As<Napi::ArrayBuffer>();
-    const uint8_t *ptr = (const uint8_t *)buffer.Data();
-
-    if (RG_UNLIKELY(buffer.ByteLength() != (size_t)size)) {
-        ThrowError<Napi::Error>(env, "Expected array or buffer of size %1, got %2", size, buffer.ByteLength());
+    if (RG_UNLIKELY(buffer.len != size)) {
+        ThrowError<Napi::Error>(env, "Expected array or buffer of size %1, got %2", size, buffer.len);
         return false;
     }
 
@@ -832,17 +830,17 @@ bool CallData::PushArrayBuffer(Napi::Value value, Size size, const TypeInfo *typ
         Size offset = 0;
         Size step = type->ref.type->size;
 
-        for (Size i = 0; i < size; i += step) {
+        for (Size i = 0; i < buffer.len; i += step) {
             offset = AlignLen(offset, realign);
 
             uint8_t *dest = origin + offset;
-            const uint8_t *src = ptr + i;
+            const uint8_t *src = buffer.ptr + i;
 
             memcpy(dest, src, step);
             offset += step;
         }
     } else {
-        memcpy_safe(origin, ptr, (size_t)buffer.ByteLength());
+        memcpy_safe(origin, buffer.ptr, (size_t)buffer.len);
     }
 
     return true;
@@ -922,21 +920,18 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     if (!PushNormalArray(array, len, type, ptr))
                         return false;
                 } else {
-                    memset(ptr, 0, size);
+                    memset_safe(ptr, 0, size);
                 }
-            } else if (value.IsTypedArray() || value.IsArrayBuffer()) {
-                Napi::ArrayBuffer buffer = value.IsTypedArray() ? value.As<Napi::TypedArray>().ArrayBuffer()
-                                                                : value.As<Napi::ArrayBuffer>();
-
-                Size size = (Size)buffer.ByteLength();
+            } else if (IsRawBuffer(value)) {
+                Span<const uint8_t> buffer = GetRawBuffer(value);
 
-                ptr = AllocHeap(size, 16);
+                ptr = AllocHeap(buffer.len, 16);
 
                 if (directions & 1) {
-                    if (!PushArrayBuffer(buffer, size, type, ptr))
+                    if (!PushBuffer(buffer, buffer.len, type, ptr))
                         return false;
                 } else {
-                    memset(ptr, 0, size);
+                    memset_safe(ptr, 0, (size_t)buffer.len);
                 }
             } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record)) {
                 Napi::Object obj = value.As<Napi::Object>();
@@ -948,7 +943,7 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     if (!PushObject(obj, type->ref.type, ptr))
                         return false;
                 } else {
-                    memset(ptr, 0, type->size);
+                    memset_safe(ptr, 0, type->size);
                 }
             } else {
                 goto unexpected;
@@ -995,8 +990,9 @@ void CallData::PopOutArguments()
         if (value.IsArray()) {
             Napi::Array array(env, value);
             DecodeNormalArray(array, out.ptr, out.type);
-        } else if (value.IsTypedArray() || value.IsArrayBuffer()) {
-            DecodeArrayBuffer(value, out.ptr, out.type);
+        } else if (IsRawBuffer(value)) {
+            Span<uint8_t> buffer = GetRawBuffer(value);
+            DecodeBuffer(buffer, out.ptr, out.type);
         } else {
             Napi::Object obj(env, value);
             DecodeObject(obj, out.ptr, out.type);

package/src/koffi/src/call.hh

@@ -103,7 +103,7 @@ private:
     Size PushString16Value(Napi::Value value, const char16_t **out_str16);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
     bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
-    bool PushArrayBuffer(Napi::Value value, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    bool PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
 

package/src/koffi/src/ffi.cc

@@ -1854,17 +1854,16 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     if (value.IsExternal()) {
         Napi::External<void> external = value.As<Napi::External<void>>();
         ptr = (const uint8_t *)external.Data();
-    } else if (value.IsTypedArray() || value.IsArrayBuffer()) {
-        Napi::ArrayBuffer buffer = value.IsTypedArray() ? value.As<Napi::TypedArray>().ArrayBuffer()
-                                                        : value.As<Napi::ArrayBuffer>();
+    } else if (IsRawBuffer(value)) {
+        Span<uint8_t> buffer = GetRawBuffer(value);
 
-        if (RG_UNLIKELY((Size)buffer.ByteLength() - offset < type->size)) {
+        if (RG_UNLIKELY(buffer.len - offset < type->size)) {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
             return env.Null();
         }
 
-        ptr = (const uint8_t *)buffer.Data();
+        ptr = (const uint8_t *)buffer.ptr;
     } else {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, info[0]));
         return env.Null();

package/src/koffi/src/util.cc

@@ -251,6 +251,8 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
         }
     } else if (value.IsArrayBuffer()) {
         return "ArrayBuffer";
+    } else if (value.IsBuffer()) {
+        return "Buffer";
     }
 
     switch (value.Type()) {
@@ -503,7 +505,9 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                DecodeArrayBuffer(array, origin, type->ref.type, realign); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
+                 \
+                DecodeBuffer(buffer, origin, type->ref.type, realign); \
                  \
                 return array; \
             } \
@@ -518,7 +522,9 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                DecodeArrayBuffer(array, origin, type->ref.type, realign); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
+                 \
+                DecodeBuffer(buffer, origin, type->ref.type, realign); \
                  \
                 return array; \
             } \
@@ -787,36 +793,29 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
 #undef POP_ARRAY
 }
 
-void DecodeArrayBuffer(Napi::Value value, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
 {
-    RG_ASSERT(value.IsTypedArray() || value.IsArrayBuffer());
-
-    Napi::ArrayBuffer buffer = value.IsTypedArray() ? value.As<Napi::TypedArray>().ArrayBuffer()
-                                                    : value.As<Napi::ArrayBuffer>();
-    uint8_t *ptr = (uint8_t *)buffer.Data();
-    Size size = (Size)buffer.ByteLength();
-
     if (realign) {
         Size offset = 0;
         Size step = ref->size;
 
-        for (Size i = 0; i < size; i += step) {
+        for (Size i = 0; i < buffer.len; i += step) {
             offset = AlignLen(offset, realign);
 
-            uint8_t *dest = ptr + i;
+            uint8_t *dest = buffer.ptr + i;
             const uint8_t *src = origin + offset;
 
             memcpy(dest, src, step);
             offset += step;
         }
     } else {
-        memcpy_safe(ptr, origin, (size_t)size);
+        memcpy_safe(buffer.ptr, origin, (size_t)buffer.len);
     }
 
 #define SWAP(CType) \
         do { \
-            CType *data = (CType *)ptr; \
-            Size len = size / RG_SIZE(CType); \
+            CType *data = (CType *)buffer.ptr; \
+            Size len = buffer.len / RG_SIZE(CType); \
              \
             for (Size i = 0; i < len; i++) { \
                 data[i] = ReverseBytes(data[i]); \

package/src/koffi/src/util.hh

@@ -77,6 +77,28 @@ static inline bool IsObject(Napi::Value value)
     return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
 }
 
+static inline bool IsRawBuffer(Napi::Value value)
+{
+    return value.IsTypedArray() || value.IsArrayBuffer();
+}
+
+static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
+{
+    if (value.IsTypedArray()) {
+        Napi::TypedArray array = value.As<Napi::TypedArray>();
+        Napi::ArrayBuffer buffer = array.ArrayBuffer();
+        Size offset = array.ByteOffset();
+
+        return MakeSpan((uint8_t *)buffer.Data() + offset, (Size)buffer.ByteLength() - offset);
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+
+        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+    }
+
+    RG_UNREACHABLE();
+}
+
 int GetTypedArrayType(const TypeInfo *type);
 
 template <typename T>
@@ -100,7 +122,7 @@ Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *
 void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
-void DecodeArrayBuffer(Napi::Value value, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
 
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {