syscall-napi 0.0.3 → 0.0.4

package/README.md

@@ -34,6 +34,10 @@ Supported argument types:
 In case of an error the promise is rejected with an error object.
 
 For params see `man 2 syscall`.
+
+### `sys.syscall.sync(...params)` => `BigInt`
+
+Same as above, but synchronous.
   
 ### `sys.__NR_xxx`
 This module provides syscall numbers (e.g. `__NR_getpid`) that are defined in `uapi/asm-generic/unistd.h` in the linux kernel.

package/lib/index.js

@@ -9,4 +9,16 @@ try {
   native = require("../build/Debug/syscall.node");
 }
 
-export default native;
+const { syscall_async, syscall_sync, ...other } = native;
+
+const syscall = (...args) => {
+  return syscall_async(...args);
+};
+syscall.sync = (...args) => {
+  return syscall_sync(...args);
+};
+
+export default {
+  syscall,
+  ...other
+};

package/native/syscall.c

@@ -63,7 +63,7 @@ static napi_status syscall_done(napi_env env, void* opaque, napi_deferred deferr
   return napi_ok;
 }
 
-static napi_status syscall_entry(napi_env env, napi_value* args, int arg_count, napi_value* result) {
+static napi_status syscall_async_entry(napi_env env, napi_value* args, int arg_count, napi_value* result) {
   int i;
   struct syscall_ctx* ctx = (struct syscall_ctx*) malloc(sizeof(*ctx));
   memset(ctx, 0, sizeof(*ctx));
@@ -107,6 +107,55 @@ static napi_status syscall_entry(napi_env env, napi_value* args, int arg_count,
   return napi_ok;
 }
 
+static napi_status syscall_sync_entry(napi_env env, napi_value* args, int arg_count, napi_value* result) {
+  int i;
+  struct syscall_ctx ctx;
+  memset(&ctx, 0, sizeof(ctx));
+
+  if(arg_count < 1) {
+    return napi_throw_error(env, NULL, "minimum required argument count for syscall() is 1");
+  }
+
+  if(arg_count > 8) {
+    return napi_throw_error(env, NULL, "maximum supported argument count for syscall() is 8");
+  }
+
+  NAPILIB_CHECK(napilib_require_bigint_int64(env, args[0], &ctx.num));
+
+  for(i = 1; i < arg_count; i += 1) {
+    int arg_idx = i - 1;
+    bool is_buffer = 0;
+
+    NAPILIB_CHECK(napi_is_buffer(env, args[i], &is_buffer));
+    if(is_buffer) {
+      void* data;
+      size_t length;
+
+      NAPILIB_CHECK(napi_get_buffer_info(env, args[i], &data, &length));
+      ctx.native_args[arg_idx] = (long) data;
+    } else {
+      NAPILIB_CHECK(napilib_require_bigint_int64(env, args[i], &ctx.native_args[arg_idx]));
+    }
+  }
+
+  ctx.res = syscall(ctx.num,
+                    ctx.native_args[0],
+                    ctx.native_args[1],
+                    ctx.native_args[2],
+                    ctx.native_args[3],
+                    ctx.native_args[4],
+                    ctx.native_args[5],
+                    ctx.native_args[6]);
+
+  if(ctx.res < 0) {
+    NAPILIB_CHECK(napilib_create_error_by_errno(env, errno, result));
+  } else {
+    NAPILIB_CHECK(napi_create_bigint_int64(env, ctx.res, result));
+  }
+
+  return napi_ok;
+}
+
 #define DEF_SYS_CONSTANT(env, obj, name) NAPILIB_CHECK(napilib_set_named_bigint_int64_property(env, obj, #name, name))
 
 static napi_status add_syscall_constants_to(napi_env env, napi_value target) {
@@ -385,7 +434,8 @@ static napi_status create_module_instance(napi_env env, napi_value* res) {
   NAPILIB_CHECK(napi_create_object(env, &exports));
 
   NAPILIB_CHECK(add_syscall_constants_to(env, exports));
-  NAPILIB_CHECK(napilib_set_named_simple_function_property(env, exports, "syscall", syscall_entry));
+  NAPILIB_CHECK(napilib_set_named_simple_function_property(env, exports, "syscall_async", syscall_async_entry));
+  NAPILIB_CHECK(napilib_set_named_simple_function_property(env, exports, "syscall_sync", syscall_sync_entry));
 
   *res = exports;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syscall-napi",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Node.js module to perform promise-based asynchronous syscalls",
   "main": "lib/index.js",
   "scripts": {

package/test/basic.js

@@ -5,9 +5,13 @@ import assert from "assert";
 import sys from "../lib/index.js";
 
 describe("basic", () => {
-  it("should run getpid() correctly", async () => {
-    // console.log("sys =", sys);
+  it("should run getpid() correctly [async]", async () => {
     const pid = await sys.syscall(sys.__NR_getpid);
     assert.equal(pid, process.pid);
   });
+
+  it("should run getpid() correctly [sync]", () => {
+    const pid = sys.syscall.sync(sys.__NR_getpid);
+    assert.equal(pid, process.pid);
+  });
 });