koffi 2.3.12 → 2.3.14

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.14
+
+**Main changes:**
+
+- Add `koffi.errno()` function to get and set current errno value
+- Add `koffi.os.errno` object with valid errno codes
+
+#### Koffi 2.3.13
+
+**Main changes:**
+
+- Add `koffi.address()` to get the raw value of a wrapper pointer
+
 #### Koffi 2.3.12
 
 **Main fixes:**

package/doc/misc.md

@@ -101,3 +101,25 @@ max_type_size        | 64 MiB  | Maximum size of Koffi types (for arrays and str
 *New in Koffi 2.3.2*
 
 You can use `koffi.stats()` to get a few statistics related to Koffi.
+
+## POSIX error codes
+
+*New in Koffi 2.3.14*
+
+You can use `koffi.errno()` to the current errno value, and `koffi.errno(value)` to change it.
+
+The standard POSIX error codes are available in `koffi.os.errno`, as in the example below:
+
+```js
+const assert = require('assert');
+const koffi = require('koffi');
+
+const lib = koffi.load('libc.so.6');
+
+const close = lib.func('int close(int fd)');
+
+close(-1);
+assert.equal(koffi.errno(), koffi.os.errno.EBADF);
+
+console.log('close() with invalid FD is POSIX compliant!');
+```

package/doc/pointers.md

@@ -133,3 +133,7 @@ By default, just like for objects, array arguments are copied from JS to C but n
 Disposable types allow you to register a function that will automatically called after each C to JS conversion performed by Koffi. This can be used to avoid leaking heap-allocated strings, for example.
 
 Read the documentation for [disposable types](calls.md#heap-allocated-values) on the page about function calls.
+
+## Unwrap pointers
+
+You can use `koffi.address(ptr)` on a pointer to get the numeric value as a [BigInt object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).

package/package.json

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

package/src/index.d.ts

@@ -101,8 +101,6 @@ declare module 'koffi' {
     export function out(value: TypeSpec): IKoffiCType;
     export function inout(value: TypeSpec): IKoffiCType;
 
-    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
-
     export function disposable(type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec, freeFunction: Function): IKoffiCType;
@@ -114,10 +112,12 @@ declare module 'koffi' {
     export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function unregister(callback: IKoffiRegisteredCallback): void;
 
+    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
     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 address(value: any): bigint;
 
     export function sizeof(type: TypeSpec): number;
     export function alignof(type: TypeSpec): number;
@@ -131,6 +131,13 @@ declare module 'koffi' {
     export function config(cfg: Record<string, unknown>): Record<string, unknown>;
     export function stats(): Record<string, unknown>;
 
-    export let internal: Boolean;
-    export let extension: String;
+    export function errno(): number;
+    export function errno(value: number): number;
+
+    export const internal: Boolean;
+    export const extension: String;
+
+    export const os: {
+        errno: Record<string, number>
+    };
 }

package/src/koffi/src/errno.inc

@@ -0,0 +1,480 @@
+// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the “Software”), to deal in 
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+#include <errno.h>
+
+struct ErrnoCodeInfo {
+    const char *name;
+    int value;
+};
+
+const ErrnoCodeInfo ErrnoCodes[] = {
+#ifdef E2BIG
+    {"E2BIG", E2BIG },
+#endif
+#ifdef EACCES
+    {"EACCES", EACCES },
+#endif
+#ifdef EADDRINUSE
+    {"EADDRINUSE", EADDRINUSE },
+#endif
+#ifdef EADDRNOTAVAIL
+    {"EADDRNOTAVAIL", EADDRNOTAVAIL },
+#endif
+#ifdef EADV
+    {"EADV", EADV },
+#endif
+#ifdef EAFNOSUPPORT
+    {"EAFNOSUPPORT", EAFNOSUPPORT },
+#endif
+#ifdef EAGAIN
+    {"EAGAIN", EAGAIN },
+#endif
+#ifdef EALREADY
+    {"EALREADY", EALREADY },
+#endif
+#ifdef EAUTH
+    {"EAUTH", EAUTH },
+#endif
+#ifdef EBADE
+    {"EBADE", EBADE },
+#endif
+#ifdef EBADF
+    {"EBADF", EBADF },
+#endif
+#ifdef EBADFD
+    {"EBADFD", EBADFD },
+#endif
+#ifdef EBADMSG
+    {"EBADMSG", EBADMSG },
+#endif
+#ifdef EBADR
+    {"EBADR", EBADR },
+#endif
+#ifdef EBADRPC
+    {"EBADRPC", EBADRPC },
+#endif
+#ifdef EBADRQC
+    {"EBADRQC", EBADRQC },
+#endif
+#ifdef EBADSLT
+    {"EBADSLT", EBADSLT },
+#endif
+#ifdef EBFONT
+    {"EBFONT", EBFONT },
+#endif
+#ifdef EBUSY
+    {"EBUSY", EBUSY },
+#endif
+#ifdef ECANCELED
+    {"ECANCELED", ECANCELED },
+#endif
+#ifdef ECAPMODE
+    {"ECAPMODE", ECAPMODE },
+#endif
+#ifdef ECHILD
+    {"ECHILD", ECHILD },
+#endif
+#ifdef ECHRNG
+    {"ECHRNG", ECHRNG },
+#endif
+#ifdef ECOMM
+    {"ECOMM", ECOMM },
+#endif
+#ifdef ECONNABORTED
+    {"ECONNABORTED", ECONNABORTED },
+#endif
+#ifdef ECONNREFUSED
+    {"ECONNREFUSED", ECONNREFUSED },
+#endif
+#ifdef ECONNRESET
+    {"ECONNRESET", ECONNRESET },
+#endif
+#ifdef EDEADLK
+    {"EDEADLK", EDEADLK },
+#endif
+#ifdef EDEADLOCK
+    {"EDEADLOCK", EDEADLOCK },
+#endif
+#ifdef EDESTADDRREQ
+    {"EDESTADDRREQ", EDESTADDRREQ },
+#endif
+#ifdef EDOM
+    {"EDOM", EDOM },
+#endif
+#ifdef EDOOFUS
+    {"EDOOFUS", EDOOFUS },
+#endif
+#ifdef EDOTDOT
+    {"EDOTDOT", EDOTDOT },
+#endif
+#ifdef EDQUOT
+    {"EDQUOT", EDQUOT },
+#endif
+#ifdef EEXIST
+    {"EEXIST", EEXIST },
+#endif
+#ifdef EFAULT
+    {"EFAULT", EFAULT },
+#endif
+#ifdef EFBIG
+    {"EFBIG", EFBIG },
+#endif
+#ifdef EFTYPE
+    {"EFTYPE", EFTYPE },
+#endif
+#ifdef EHOSTDOWN
+    {"EHOSTDOWN", EHOSTDOWN },
+#endif
+#ifdef EHOSTUNREACH
+    {"EHOSTUNREACH", EHOSTUNREACH },
+#endif
+#ifdef EHWPOISON
+    {"EHWPOISON", EHWPOISON },
+#endif
+#ifdef EIDRM
+    {"EIDRM", EIDRM },
+#endif
+#ifdef EILSEQ
+    {"EILSEQ", EILSEQ },
+#endif
+#ifdef EINPROGRESS
+    {"EINPROGRESS", EINPROGRESS },
+#endif
+#ifdef EINTEGRITY
+    {"EINTEGRITY", EINTEGRITY },
+#endif
+#ifdef EINTR
+    {"EINTR", EINTR },
+#endif
+#ifdef EINVAL
+    {"EINVAL", EINVAL },
+#endif
+#ifdef EIO
+    {"EIO", EIO },
+#endif
+#ifdef EISCONN
+    {"EISCONN", EISCONN },
+#endif
+#ifdef EISDIR
+    {"EISDIR", EISDIR },
+#endif
+#ifdef EISNAM
+    {"EISNAM", EISNAM },
+#endif
+#ifdef EKEYEXPIRED
+    {"EKEYEXPIRED", EKEYEXPIRED },
+#endif
+#ifdef EKEYREJECTED
+    {"EKEYREJECTED", EKEYREJECTED },
+#endif
+#ifdef EKEYREVOKED
+    {"EKEYREVOKED", EKEYREVOKED },
+#endif
+#ifdef EL2HLT
+    {"EL2HLT", EL2HLT },
+#endif
+#ifdef EL2NSYNC
+    {"EL2NSYNC", EL2NSYNC },
+#endif
+#ifdef EL3HLT
+    {"EL3HLT", EL3HLT },
+#endif
+#ifdef EL3RST
+    {"EL3RST", EL3RST },
+#endif
+#ifdef ELIBACC
+    {"ELIBACC", ELIBACC },
+#endif
+#ifdef ELIBBAD
+    {"ELIBBAD", ELIBBAD },
+#endif
+#ifdef ELIBEXEC
+    {"ELIBEXEC", ELIBEXEC },
+#endif
+#ifdef ELIBMAX
+    {"ELIBMAX", ELIBMAX },
+#endif
+#ifdef ELIBSCN
+    {"ELIBSCN", ELIBSCN },
+#endif
+#ifdef ELNRNG
+    {"ELNRNG", ELNRNG },
+#endif
+#ifdef ELOOP
+    {"ELOOP", ELOOP },
+#endif
+#ifdef EMEDIUMTYPE
+    {"EMEDIUMTYPE", EMEDIUMTYPE },
+#endif
+#ifdef EMFILE
+    {"EMFILE", EMFILE },
+#endif
+#ifdef EMLINK
+    {"EMLINK", EMLINK },
+#endif
+#ifdef EMSGSIZE
+    {"EMSGSIZE", EMSGSIZE },
+#endif
+#ifdef EMULTIHOP
+    {"EMULTIHOP", EMULTIHOP },
+#endif
+#ifdef ENAMETOOLONG
+    {"ENAMETOOLONG", ENAMETOOLONG },
+#endif
+#ifdef ENAVAIL
+    {"ENAVAIL", ENAVAIL },
+#endif
+#ifdef ENEEDAUTH
+    {"ENEEDAUTH", ENEEDAUTH },
+#endif
+#ifdef ENETDOWN
+    {"ENETDOWN", ENETDOWN },
+#endif
+#ifdef ENETRESET
+    {"ENETRESET", ENETRESET },
+#endif
+#ifdef ENETUNREACH
+    {"ENETUNREACH", ENETUNREACH },
+#endif
+#ifdef ENFILE
+    {"ENFILE", ENFILE },
+#endif
+#ifdef ENOANO
+    {"ENOANO", ENOANO },
+#endif
+#ifdef ENOATTR
+    {"ENOATTR", ENOATTR },
+#endif
+#ifdef ENOBUFS
+    {"ENOBUFS", ENOBUFS },
+#endif
+#ifdef ENOCSI
+    {"ENOCSI", ENOCSI },
+#endif
+#ifdef ENODATA
+    {"ENODATA", ENODATA },
+#endif
+#ifdef ENODEV
+    {"ENODEV", ENODEV },
+#endif
+#ifdef ENOENT
+    {"ENOENT", ENOENT },
+#endif
+#ifdef ENOEXEC
+    {"ENOEXEC", ENOEXEC },
+#endif
+#ifdef ENOKEY
+    {"ENOKEY", ENOKEY },
+#endif
+#ifdef ENOLCK
+    {"ENOLCK", ENOLCK },
+#endif
+#ifdef ENOLINK
+    {"ENOLINK", ENOLINK },
+#endif
+#ifdef ENOMEDIUM
+    {"ENOMEDIUM", ENOMEDIUM },
+#endif
+#ifdef ENOMEM
+    {"ENOMEM", ENOMEM },
+#endif
+#ifdef ENOMSG
+    {"ENOMSG", ENOMSG },
+#endif
+#ifdef ENONET
+    {"ENONET", ENONET },
+#endif
+#ifdef ENOPKG
+    {"ENOPKG", ENOPKG },
+#endif
+#ifdef ENOPROTOOPT
+    {"ENOPROTOOPT", ENOPROTOOPT },
+#endif
+#ifdef ENOSPC
+    {"ENOSPC", ENOSPC },
+#endif
+#ifdef ENOSR
+    {"ENOSR", ENOSR },
+#endif
+#ifdef ENOSTR
+    {"ENOSTR", ENOSTR },
+#endif
+#ifdef ENOSYS
+    {"ENOSYS", ENOSYS },
+#endif
+#ifdef ENOTBLK
+    {"ENOTBLK", ENOTBLK },
+#endif
+#ifdef ENOTCAPABLE
+    {"ENOTCAPABLE", ENOTCAPABLE },
+#endif
+#ifdef ENOTCONN
+    {"ENOTCONN", ENOTCONN },
+#endif
+#ifdef ENOTDIR
+    {"ENOTDIR", ENOTDIR },
+#endif
+#ifdef ENOTEMPTY
+    {"ENOTEMPTY", ENOTEMPTY },
+#endif
+#ifdef ENOTNAM
+    {"ENOTNAM", ENOTNAM },
+#endif
+#ifdef ENOTRECOVERABLE
+    {"ENOTRECOVERABLE", ENOTRECOVERABLE },
+#endif
+#ifdef ENOTSOCK
+    {"ENOTSOCK", ENOTSOCK },
+#endif
+#ifdef ENOTSUP
+    {"ENOTSUP", ENOTSUP },
+#endif
+#ifdef ENOTTY
+    {"ENOTTY", ENOTTY },
+#endif
+#ifdef ENOTUNIQ
+    {"ENOTUNIQ", ENOTUNIQ },
+#endif
+#ifdef ENXIO
+    {"ENXIO", ENXIO },
+#endif
+#ifdef EOPNOTSUPP
+    {"EOPNOTSUPP", EOPNOTSUPP },
+#endif
+#ifdef EOTHER
+    {"EOTHER", EOTHER },
+#endif
+#ifdef EOVERFLOW
+    {"EOVERFLOW", EOVERFLOW },
+#endif
+#ifdef EOWNERDEAD
+    {"EOWNERDEAD", EOWNERDEAD },
+#endif
+#ifdef EPERM
+    {"EPERM", EPERM },
+#endif
+#ifdef EPFNOSUPPORT
+    {"EPFNOSUPPORT", EPFNOSUPPORT },
+#endif
+#ifdef EPIPE
+    {"EPIPE", EPIPE },
+#endif
+#ifdef EPROCLIM
+    {"EPROCLIM", EPROCLIM },
+#endif
+#ifdef EPROCUNAVAIL
+    {"EPROCUNAVAIL", EPROCUNAVAIL },
+#endif
+#ifdef EPROGMISMATCH
+    {"EPROGMISMATCH", EPROGMISMATCH },
+#endif
+#ifdef EPROGUNAVAIL
+    {"EPROGUNAVAIL", EPROGUNAVAIL },
+#endif
+#ifdef EPROTO
+    {"EPROTO", EPROTO },
+#endif
+#ifdef EPROTONOSUPPORT
+    {"EPROTONOSUPPORT", EPROTONOSUPPORT },
+#endif
+#ifdef EPROTOTYPE
+    {"EPROTOTYPE", EPROTOTYPE },
+#endif
+#ifdef ERANGE
+    {"ERANGE", ERANGE },
+#endif
+#ifdef EREMCHG
+    {"EREMCHG", EREMCHG },
+#endif
+#ifdef EREMOTE
+    {"EREMOTE", EREMOTE },
+#endif
+#ifdef EREMOTEIO
+    {"EREMOTEIO", EREMOTEIO },
+#endif
+#ifdef ERESTART
+    {"ERESTART", ERESTART },
+#endif
+#ifdef ERFKILL
+    {"ERFKILL", ERFKILL },
+#endif
+#ifdef EROFS
+    {"EROFS", EROFS },
+#endif
+#ifdef ERPCMISMATCH
+    {"ERPCMISMATCH", ERPCMISMATCH },
+#endif
+#ifdef ESHUTDOWN
+    {"ESHUTDOWN", ESHUTDOWN },
+#endif
+#ifdef ESOCKTNOSUPPORT
+    {"ESOCKTNOSUPPORT", ESOCKTNOSUPPORT },
+#endif
+#ifdef ESPIPE
+    {"ESPIPE", ESPIPE },
+#endif
+#ifdef ESRCH
+    {"ESRCH", ESRCH },
+#endif
+#ifdef ESRMNT
+    {"ESRMNT", ESRMNT },
+#endif
+#ifdef ESTALE
+    {"ESTALE", ESTALE },
+#endif
+#ifdef ESTRPIPE
+    {"ESTRPIPE", ESTRPIPE },
+#endif
+#ifdef ETIME
+    {"ETIME", ETIME },
+#endif
+#ifdef ETIMEDOUT
+    {"ETIMEDOUT", ETIMEDOUT },
+#endif
+#ifdef ETOOMANYREFS
+    {"ETOOMANYREFS", ETOOMANYREFS },
+#endif
+#ifdef ETXTBSY
+    {"ETXTBSY", ETXTBSY },
+#endif
+#ifdef EUCLEAN
+    {"EUCLEAN", EUCLEAN },
+#endif
+#ifdef EUNATCH
+    {"EUNATCH", EUNATCH },
+#endif
+#ifdef EUSERS
+    {"EUSERS", EUSERS },
+#endif
+#ifdef EWOULDBLOCK
+    {"EWOULDBLOCK", EWOULDBLOCK },
+#endif
+#ifdef EXDEV
+    {"EXDEV", EXDEV },
+#endif
+#ifdef EXFULL
+    {"EXFULL", EXFULL },
+#endif
+#ifdef STRUNCATE
+    {"STRUNCATE", STRUNCATE },
+#endif
+};

package/src/koffi/src/ffi.cc

@@ -27,6 +27,7 @@
 #ifdef _WIN32
     #include "win32.hh"
 #endif
+#include "errno.inc"
 
 #ifdef _WIN32
     #ifndef NOMINMAX
@@ -722,19 +723,30 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
+static inline bool CheckExternalPointer(Napi::Env env, Napi::Value value)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (!value.IsExternal() || CheckValueTag(instance, value, &TypeInfoMarker) ||
+                               CheckValueTag(instance, value, &CastMarker) ||
+                               CheckValueTag(instance, value, &MagicUnionMarker)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external pointer", GetValueType(instance, value));
+        return false;
+    }
+
+    return true;
+}
+
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsExternal() || CheckValueTag(instance, info[0], &TypeInfoMarker)) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external", GetValueType(instance, info[0]));
+    if (!CheckExternalPointer(env, info[0]))
         return env.Null();
-    }
 
     Napi::External<void> external = info[0].As<Napi::External<void>>();
     void *ptr = external.Data();
@@ -744,6 +756,26 @@ static Napi::Value CallFree(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+static Napi::Value GetOrSetErrNo(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() >= 1) {
+        Napi::Number value = info[0].As<Napi::Number>();
+
+        if (!value.IsNumber()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for errno, expected integer", GetValueType(instance, value));
+            return env.Null();
+        }
+
+        errno = value;
+    }
+
+    Napi::Number ret = Napi::Number::New(env, errno);
+    return ret;
+}
+
 static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -1973,6 +2005,26 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     return ret;
 }
 
+static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+    if (!CheckExternalPointer(env, info[0]))
+        return env.Null();
+
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    void *ptr = external.Data();
+
+    uint64_t ptr64 = (uint64_t)(uintptr_t)ptr;
+    Napi::BigInt bigint = Napi::BigInt::New(env, ptr64);
+
+    return bigint;
+}
+
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     if (RG_LIKELY(exec_call)) {
@@ -2038,6 +2090,23 @@ static void SetExports(Napi::Env env, Func func)
 
     func("as", Napi::Function::New(env, CastValue));
     func("decode", Napi::Function::New(env, DecodeValue));
+    func("address", Napi::Function::New(env, GetPointerAddress));
+
+    func("errno", Napi::Function::New(env, GetOrSetErrNo));
+
+    Napi::Object os = Napi::Object::New(env);
+    func("os", os);
+
+    // Init constants mapping
+    {
+        Napi::Object codes = Napi::Object::New(env);
+
+        for (const ErrnoCodeInfo &info: ErrnoCodes) {
+            codes.Set(info.name, Napi::Number::New(env, info.value));
+        }
+
+        os.Set("errno", codes);
+    }
 
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));