koffi 2.3.13 → 2.3.15

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.15
+
+**Main changes:**
+
+- Improve manual decoding of 0-terminated strings
+- Add checks around array conversion hints
+
+#### 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:**

package/doc/calls.md

@@ -68,6 +68,60 @@ The same can be done when declaring a function with a C-like prototype string, w
 - `_Out_` for output parameters
 - `_Inout_` for dual input/output parameters
 
+### Primitive value
+
+This Windows example enumerate all Chrome windows along with their PID and their title. The `GetWindowThreadProcessId()` function illustrates how to get a primitive value from an output argument.
+
+```js
+const koffi = require('koffi');
+const user32 = koffi.load('user32.dll');
+
+const DWORD = koffi.alias('DWORD', 'uint32_t');
+const HANDLE = koffi.pointer(koffi.opaque('HANDLE'));
+const HWND = koffi.alias('HWND', HANDLE);
+
+const FindWindowEx = user32.func('HWND __stdcall FindWindowExW(HWND hWndParent, HWND hWndChildAfter, const char16_t *lpszClass, const char16_t *lpszWindow)');
+const GetWindowThreadProcessId = user32.func('DWORD __stdcall GetWindowThreadProcessId(HWND hWnd, _Out_ DWORD *lpdwProcessId)');
+const GetWindowText = user32.func('int __stdcall GetWindowTextA(HWND hWnd, _Out_ uint8_t *lpString, int nMaxCount)');
+
+for (let hwnd = null;;) {
+    hwnd = FindWindowEx(0, hwnd, 'Chrome_WidgetWin_1', null);
+
+    if (!hwnd)
+        break;
+
+    // Get PID
+    let pid;
+    {
+        let ptr = [null];
+        let tid = GetWindowThreadProcessId(hwnd, ptr);
+
+        if (!tid) {
+            // Maybe the process ended in-between?
+            continue;
+        }
+
+        pid = ptr[0];
+    }
+
+    // Get window title
+    let title;
+    {
+        let buf = Buffer.allocUnsafe(1024);
+        let length = GetWindowText(hwnd, buf, buf.length);
+
+        if (!length) {
+            // Maybe the process ended in-between?
+            continue;
+        }
+
+        title = koffi.decode(buf, 'char', length);
+    }
+
+    console.log({ PID: pid, Title: title });
+}
+```
+
 ### Struct example
 
 This example calls the POSIX function `gettimeofday()`, and uses the prototype-like syntax.

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/package.json

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

package/src/core/libcc/libcc.cc

@@ -5891,6 +5891,8 @@ bool StreamReader::Open(Span<const uint8_t> buf, const char *filename,
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<memory>";
 
@@ -5912,6 +5914,8 @@ bool StreamReader::Open(FILE *fp, const char *filename, CompressionType compress
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     RG_ASSERT(fp);
     RG_ASSERT(filename);
@@ -5935,6 +5939,8 @@ OpenResult StreamReader::Open(const char *filename, CompressionType compression_
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     RG_ASSERT(filename);
     this->filename = DuplicateString(filename, &str_alloc).ptr;
@@ -5962,6 +5968,8 @@ bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const ch
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
     raw_read = 0;
+    read_total = 0;
+    read_max = -1;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<closure>";
 
@@ -6081,6 +6089,13 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
         eof = source.eof;
     }
 
+    if (RG_UNLIKELY(!error && read_max >= 0 && read_len > read_max - read_total)) {
+        LogError("Exceeded max stream size of %1", FmtDiskSize(read_max));
+        error = true;
+        return -1;
+    }
+    read_total += read_len;
+
     return read_len;
 }
 

package/src/core/libcc/libcc.hh

@@ -4229,6 +4229,9 @@ class StreamReader {
     const char *filename = nullptr;
     bool error = true;
 
+    int64_t read_total = 0;
+    int64_t read_max = -1;
+
     struct {
         SourceType type = SourceType::Memory;
         union U {
@@ -4289,15 +4292,18 @@ public:
 
     const char *GetFileName() const { return filename; }
     CompressionType GetCompressionType() const { return compression_type; }
+    int64_t GetReadLimit() { return read_max; }
     bool IsValid() const { return filename && !error; }
     bool IsEOF() const { return eof; }
 
     FILE *GetFile() const;
     int GetDescriptor() const;
 
+    void SetReadLimit(int64_t limit) { read_max = limit; }
+
     Size Read(Span<uint8_t> out_buf);
     Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
-    Size Read(Size max_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, max_len)); }
+    Size Read(Size buf_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, buf_len)); }
 
     Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
     Size ReadAll(Size max_len, HeapArray<char> *out_buf)

package/src/index.d.ts

@@ -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
@@ -755,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();
@@ -795,6 +816,11 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         ArrayHint hint = {};
 
         if (to == "Typed" || to == "typed") {
+            if (!(ref->flags & (int)TypeFlag::HasTypedArray)) {
+                ThrowError<Napi::Error>(env, "Array hint 'Typed' cannot be used with type %1", ref->name);
+                return env.Null();
+            }
+
             hint = ArrayHint::Typed;
         } else if (to == "Array" || to == "array") {
             hint = ArrayHint::Array;
@@ -1712,7 +1738,6 @@ void LibraryHolder::Unref() const
     }
 }
 
-
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
@@ -1729,6 +1754,13 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     type->size = size;
     type->align = align;
 
+    if (IsInteger(type) || IsFloat(type)) {
+        type->flags |= (int)TypeFlag::HasTypedArray;
+    }
+    if (TestStr(type->name, "char") || TestStr(type->name, "char16") || TestStr(type->name, "char16_t")) {
+        type->flags |= (int)TypeFlag::IsCharLike;
+    }
+
     if (ref) {
         const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
         RG_ASSERT(marker);
@@ -1978,10 +2010,16 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value value = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-    int64_t len = has_len ? info[2u + has_offset].As<Napi::Number>().Int64Value() : -1;
 
-    Napi::Value ret = Decode(value, offset, type, len);
-    return ret;
+    if (has_len) {
+        Size len = info[2u + has_offset].As<Napi::Number>();
+
+        Napi::Value ret = Decode(value, offset, type, &len);
+        return ret;
+    } else {
+        Napi::Value ret = Decode(value, offset, type);
+        return ret;
+    }
 }
 
 static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
@@ -2071,6 +2109,22 @@ static void SetExports(Napi::Env env, Func func)
     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"));
 #elif defined(__APPLE__)

package/src/koffi/src/ffi.hh

@@ -103,6 +103,11 @@ struct FunctionInfo;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
+enum class TypeFlag {
+    HasTypedArray = 1 << 0,
+    IsCharLike = 1 << 1
+};
+
 enum class ArrayHint {
     Array,
     Typed,
@@ -120,6 +125,7 @@ struct TypeInfo {
     PrimitiveKind primitive;
     int32_t size;
     int16_t align;
+    uint16_t flags;
 
     DisposeFunc *dispose;
     Napi::FunctionReference dispose_ref;

package/src/koffi/src/util.cc

@@ -329,11 +329,12 @@ const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
 {
     ArrayHint hint = {};
 
-    if (TestStr(ref->name, "char") || TestStr(ref->name, "char16") ||
-                                             TestStr(ref->name, "char16_t")) {
+    if (ref->flags & (int)TypeFlag::IsCharLike) {
         hint = ArrayHint::String;
-    } else {
+    } else if (ref->flags & (int)TypeFlag::HasTypedArray) {
         hint = ArrayHint::Typed;
+    } else {
+        hint = ArrayHint::Array;
     }
 
     return MakeArrayType(instance, ref, len, hint, true);
@@ -1002,7 +1003,7 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 #undef SWAP
 }
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len)
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len)
 {
     Napi::Env env = value.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1035,13 +1036,35 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size le
     return ret;
 }
 
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len)
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (len >= 0 && type->primitive != PrimitiveKind::String &&
-                    type->primitive != PrimitiveKind::String16) {
-        type = MakeArrayType(instance, type, len);
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16) {
+        if (*len >= 0) {
+            type = MakeArrayType(instance, type, *len);
+        } else {
+            if (RG_UNLIKELY(!(type->flags & (int)TypeFlag::IsCharLike))) {
+                ThrowError<Napi::TypeError>(env, "Only char-like types can find their length automatically", type->name);
+                return env.Null();
+            }
+
+            switch (type->primitive) {
+                case PrimitiveKind::Int8: {
+                    Size count = strlen((const char *)ptr);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+                case PrimitiveKind::Int16: {
+                    Size count = WideStringLength((const char16_t *)ptr, RG_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                default: { RG_UNREACHABLE(); } break;
+            }
+
+        }
+
     }
 
 #define RETURN_INT(Type, NewCall) \
@@ -1080,18 +1103,18 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size
         case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewBigInt); } break;
         case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewBigInt); } break;
         case PrimitiveKind::String: {
-            if (len >= 0) {
+            if (len) {
                 const char *str = *(const char **)ptr;
-                return str ? Napi::String::New(env, str, len) : env.Null();
+                return str ? Napi::String::New(env, str, *len) : env.Null();
             } else {
                 const char *str = *(const char **)ptr;
                 return str ? Napi::String::New(env, str) : env.Null();
             }
         } break;
         case PrimitiveKind::String16: {
-            if (len >= 0) {
+            if (len) {
                 const char16_t *str16 = *(const char16_t **)ptr;
-                return str16 ? Napi::String::New(env, str16, len) : env.Null();
+                return str16 ? Napi::String::New(env, str16, *len) : env.Null();
             } else {
                 const char16_t *str16 = *(const char16_t **)ptr;
                 return str16 ? Napi::String::New(env, str16) : env.Null();

package/src/koffi/src/util.hh

@@ -160,8 +160,8 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
 void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len = -1);
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len = -1);
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
 
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {