koffi 2.2.2-beta.3 → 2.2.2-beta.5

package/package.json

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

package/src/koffi/src/ffi.cc

@@ -1891,7 +1891,9 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
     if (RG_LIKELY(exec_call)) {
         exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
     } else {
-        Napi::Env env = shared.trampolines[idx].func.Env();
+        TrampolineInfo *trampoline = &shared.trampolines[idx];
+
+        Napi::Env env = trampoline->func.Env();
         InstanceData *instance = env.GetInstanceData<InstanceData>();
 
         InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
@@ -1900,6 +1902,10 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
             return;
         }
 
+        // Avoid triggering the "use callback beyond FFI" check
+        RG_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
+        trampoline->generation = -1;
+
         CallData call(env, instance, mem);
         call.RelaySafe(idx, own_sp, caller_sp, out_reg);
     }

package/src/koffi/src/index.js

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -15,6 +13,9 @@
 
 'use strict';
 
+if (process.versions.napi == null || process.versions.napi < 8)
+    throw new Error('This platform does not support N-API 8');
+
 const util = require('util');
 
 let filename = __dirname + '/../build/koffi.node';

package/src/koffi/test/callbacks.js

@@ -73,9 +73,10 @@ async function test() {
     const ApplyStd = lib.func('int ApplyStd(int a, int b, int c, ApplyCallback *func)');
     const ApplyMany = lib.func('int ApplyMany(int x, IntCallback **funcs, int length)');
     const ApplyStruct = lib.func('int ApplyStruct(int x, StructCallbacks callbacks)');
-    const SetCallback = lib.func('void SetCallback(IntCallback *func)');
-    const CallCallback = lib.func('int CallCallback(int x)');
-    const CallFromThread = lib.func('int CallFromThread(int x)');
+    const SetIndirect = lib.func('void SetIndirect(IntCallback *func)');
+    const CallIndirect = lib.func('int CallIndirect(int x)');
+    const CallIndirectThreaded = lib.func('int CallIndirectThreaded(int x)');
+    const CallDirectThreaded = lib.func('int CallDirectThreaded(IntCallback *func, int x)');
     const MakeVectors = lib.func('int MakeVectors(int len, VectorCallback *func)');
     const CallQSort = lib.func('void CallQSort(_Inout_ void *base, size_t nmemb, size_t size, SortCallback *cb)');
     const CallMeChar = lib.func('int CallMeChar(CharCallback *func)');
@@ -164,12 +165,12 @@ async function test() {
 
     // Persistent callback
     {
-        SetCallback(x => -x);
-        assert.throws(() => CallCallback(27), { message: /non-registered callback/ });
+        SetIndirect(x => -x);
+        assert.throws(() => CallIndirect(27), { message: /non-registered callback/ });
 
         let cb = koffi.register(x => -x, koffi.pointer(IntCallback));
-        SetCallback(cb);
-        assert.equal(CallCallback(27), -27);
+        SetIndirect(cb);
+        assert.equal(CallIndirect(27), -27);
 
         assert.equal(koffi.unregister(cb), null);
         assert.throws(() => koffi.unregister(cb));
@@ -185,8 +186,8 @@ async function test() {
         let mult = new Multiplier(5);
         let cb = koffi.register(mult, mult.multiply, 'IntCallback *');
 
-        SetCallback(cb);
-        assert.equal(CallCallback(42), 5 * 42);
+        SetIndirect(cb);
+        assert.equal(CallIndirect(42), 5 * 42);
 
         assert.equal(koffi.unregister(cb), null);
         assert.throws(() => koffi.unregister(cb));
@@ -262,12 +263,16 @@ async function test() {
         assert.equal(ret, 97 + 2 * 98);
     }
 
-    // Use callback from secondary thread
+    // Use temporary callback from secondary thread
+    for (let i = 0; i < 128; i++)
+        assert.equal(await util.promisify(CallDirectThreaded.async)(x => -x - 2, 27), -29);
+
+    // Use registered callback from secondary thread
     for (let i = 0; i < 128; i++) {
         let cb = koffi.register(x => -x - 2, koffi.pointer(IntCallback));
 
-        SetCallback(cb);
-        assert.equal(await util.promisify(CallFromThread.async)(27), -29);
+        SetIndirect(cb);
+        assert.equal(await util.promisify(CallIndirectThreaded.async)(27), -29);
 
         koffi.unregister(cb);
     }

package/src/koffi/test/misc.c

@@ -669,19 +669,19 @@ EXPORT int ApplyStruct(int x, StructCallbacks callbacks)
 
 static IntCallback *callback;
 
-EXPORT void SetCallback(IntCallback *cb)
+EXPORT void SetIndirect(IntCallback *cb)
 {
     callback = cb;
 }
 
-EXPORT int CallCallback(int x)
+EXPORT int CallIndirect(int x)
 {
     return callback(x);
 }
 
 #ifdef _WIN32
 
-static DWORD WINAPI CallFromThreadFunc(void *udata)
+static DWORD WINAPI CallIndirectThreadedFunc(void *udata)
 {
     int *ptr = (int *)udata;
     *ptr = callback(*ptr);
@@ -689,22 +689,23 @@ static DWORD WINAPI CallFromThreadFunc(void *udata)
     return 0;
 }
 
-EXPORT int CallFromThread(int x)
+EXPORT int CallIndirectThreaded(int x)
 {
-    HANDLE h = CreateThread(NULL, 0, CallFromThreadFunc, &x, 0, NULL);
+    HANDLE h = CreateThread(NULL, 0, CallIndirectThreadedFunc, &x, 0, NULL);
     if (!h) {
         perror("CreateThread");
         exit(1);
     }
 
     WaitForSingleObject(h, INFINITE);
+    CloseHandle(h);
 
     return x;
 }
 
 #else
 
-static void *CallFromThreadFunc(void *udata)
+static void *CallIndirectThreadedFunc(void *udata)
 {
     int *ptr = (int *)udata;
     *ptr = callback(*ptr);
@@ -712,11 +713,11 @@ static void *CallFromThreadFunc(void *udata)
     return NULL;
 }
 
-EXPORT int CallFromThread(int x)
+EXPORT int CallIndirectThreaded(int x)
 {
     pthread_t thread;
 
-    if (pthread_create(&thread, NULL, CallFromThreadFunc, &x)) {
+    if (pthread_create(&thread, NULL, CallIndirectThreadedFunc, &x)) {
         perror("pthread_create");
         exit(1);
     }
@@ -728,6 +729,12 @@ EXPORT int CallFromThread(int x)
 
 #endif
 
+EXPORT int CallDirectThreaded(IntCallback *func, int x)
+{
+    callback = func;
+    return CallIndirectThreaded(x);
+}
+
 EXPORT void ReverseBytes(void *p, int len)
 {
     uint8_t *bytes = (uint8_t *)p;