fixup! src,lib: initial ffi implementation

Author: bengl

doc/api/cli.md

@@ -589,6 +589,7 @@ following permissions are restricted:
   \[`--allow-fs-read`]\[],\[`allow-fs-write`]\[] flags
 * Child Process - manageable through \[`--allow-child-process`]\[] flag
 * Worker Threads - manageable through \[`--allow-worker`]\[] flag
+* FFI - manageable through \[`--allow-ffo`]\[] flag
 
 ### `--experimental-policy`
 
@@ -2088,6 +2089,7 @@ Node.js options that are allowed are:
 <!-- node-options-node start -->
 
 * `--allow-child-process`
+* `--allow-ffi`
 * `--allow-fs-read`
 * `--allow-fs-write`
 * `--allow-worker`

lib/ffi.js

@@ -28,7 +28,7 @@ const {
   ERR_FFI_SYMBOL_NOT_FOUND,
   ERR_FFI_UNSUPPORTED_TYPE,
   ERR_INVALID_ARG_TYPE,
-} = require('internal/errors');
+} = require('internal/errors').codes;
 
 // [ sigPtr | fnPtr | rvalue | avaluesPointers ]
 const callBuffer = new ArrayBuffer(4096);

src/node_ffi.cc

@@ -78,7 +78,7 @@ void GetBufferPointer(const FunctionCallbackInfo<Value>& args) {
   THROW_IF_INSUFFICIENT_PERMISSIONS(
       env, permission::PermissionScope::kFfi, "");
 
-  CHECK(args[0]->IsArrayBuffer());
+  CHECK(args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer());
   void* data = args[0].As<ArrayBuffer>()->Data();
 
   ReturnBigInt(args.GetIsolate(), data);

test/ffi/types/test.js

@@ -71,13 +71,15 @@ for (const type of basicTypes) {
 
   const ptrFnName = `test_add_ptr_${type.replace(/ /g, '_')}`;
   const ptrType = type + '*';
-  const ptrFn = ffi.getNativeFunction(shared, ptrFnName, 'void', [ptrType, ptrType, ptrType]);
+  assert.strictEqual(ffi.sizeof(ptrType), ffi.sizeof('void *'));
+  const ptrFn = ffi.getNativeFunction(shared, ptrFnName, ptrType, [ptrType, ptrType, ptrType]);
   const size = ffi.sizeof(type);
   const buf = Buffer.alloc(size * 3);
   const retPtr = ffi.getBufferPointer(buf);
   const rwName = getRWName(type, size);
   buf[`write${rwName}`](three, size);
   buf[`write${rwName}`](four, 2 * size);
-  ptrFn(retPtr, retPtr + BigInt(size), retPtr + BigInt(2 * size));
+  const ret = ptrFn(retPtr, retPtr + BigInt(size), retPtr + BigInt(2 * size));
   assert.strictEqual(buf[`read${rwName}`](0), seven);
+  assert.strictEqual(ret, retPtr);
 }

test/ffi/types/types.c

@@ -1,6 +1,9 @@
 #include "stdint.h"
 #define test(typ, name) typ test_add_##name(typ a, typ b) { return a + b; } \
-  void test_add_ptr_##name(typ * ret, typ * a, typ * b) { *ret = *a + *b; }
+  typ * test_add_ptr_##name(typ * ret, typ * a, typ * b) { \
+    *ret = *a + *b; \
+    return ret; \
+  }
 test(char, char);
 test(signed char, signed_char);
 test(unsigned char, unsigned_char);

test/parallel/test-ffi-buffer-pointer.js

@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const ffi = require('node:ffi');
+
+function assertIsPointer(thing) {
+  assert.strictEqual(typeof thing, 'bigint');
+  assert.ok(thing > 0n);
+}
+
+const buffer = Buffer.alloc(8);
+const arrayBufferViews = common.getArrayBufferViews(buffer);
+
+assertIsPointer(ffi.getBufferPointer(buffer));
+for (const view of arrayBufferViews) {
+  assertIsPointer(ffi.getBufferPointer(view));
+}
+assertIsPointer(ffi.getBufferPointer(new DataView(new ArrayBuffer(8))));
+assertIsPointer(ffi.getBufferPointer(new ArrayBuffer(8)));
+assertIsPointer(ffi.getBufferPointer(new SharedArrayBuffer(8)));
+
+[
+  7,
+  '7',
+  {},
+  () => {},
+  null,
+  undefined,
+  Symbol('7'),
+  true,
+].forEach((value) => {
+  assert.throws(() => {
+    ffi.getBufferPointer(value);
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+});
+

test/parallel/test-ffi-get-native-function.js

@@ -0,0 +1,27 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const ffi = require('node:ffi');
+
+const getpid = ffi.getNativeFunction(null, 'uv_os_getpid', 'int', []);
+assert.strictEqual(process.pid, getpid());
+
+assert.throws(() => {
+  ffi.getNativeFunction('strongbad', 'uv_os_getpid', 'int', []);
+}, { code: 'ERR_FFI_LIBRARY_LOAD_FAILED' });
+
+assert.throws(() => {
+  ffi.getNativeFunction(12345, 'uv_os_getpid', 'int', []);
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+
+assert.throws(() => {
+  ffi.getNativeFunction(null, 'strongbad', 'int', []);
+}, { code: 'ERR_FFI_SYMBOL_NOT_FOUND' });
+
+assert.throws(() => {
+  ffi.getNativeFunction(null, 'uv_os_getpid', 'strongbad', []);
+}, { code: 'ERR_FFI_UNSUPPORTED_TYPE' });
+
+assert.throws(() => {
+  ffi.getNativeFunction(null, 'uv_os_getpid', 'int', ['strongbad']);
+}, { code: 'ERR_FFI_UNSUPPORTED_TYPE' });