visaljs 0.0.7 → 0.0.9

package/node/src/host_net.c

@@ -12,7 +12,7 @@
  *   NET_CLOSE       the handle is closed (netClose or netReset) and its id free
  *
  *   netOpen(pipe, cb) → id                     a TCP handle, or with `pipe` a pipe's
- *   netOpenFd(id, fd) → 0 | -errno              netGuessHandle(fd) → "TCP" | "PIPE" | "TTY" | …
+ *   netOpenFd(id, fd) → 0 | -errno, netFd(id) → fd | -errno              netGuessHandle(fd) → "TCP" | "PIPE" | "TTY" | …
  *   netBind(id, ip | path, port, flags), netListen(id, backlog) → 0 | -errno   flags: 1 ipv6Only, 2 reusePort
  *   netChmod(id, mode) → 0 | -errno            a listening pipe's: 1 readable, 2 writable by all
  *   netConnect(id, ip | path, port) → 0 | -errno (a NET_CONNECT follows)
@@ -22,8 +22,16 @@
  *   netShutdown(id), netClose(id), netReset(id) → 0 | -errno, netRef(id, ref)
  *   netAddress(id, peer) → [address, family, port] | path | -errno
  *   netNoDelay(id, on), netKeepAlive(id, on, seconds) → 0 | -errno
+ *   netTypeOfService(id, tos) → 0 | -errno, and with tos -1 the socket's → tos | -errno
+ *   ttyOpen(fd, cb) → id | -errno               a terminal's handle (node:tty's ReadStream), read as
+ *                                                a stream; it answers the pipe-only calls as a pipe
+ *   ttySetRawMode(id, raw) → 0 | -errno
  *   dnsLookup(host, family, cb) → cb(errno, code, [[address, family], …]) */
 #define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t, struct addrinfo */
+#ifdef __APPLE__
+#define _DARWIN_C_SOURCE  /* IP_TOS, which _POSIX_C_SOURCE hides on macOS */
+#endif
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -45,9 +53,11 @@ typedef struct NetHandle {
         uv_stream_t stream;
         uv_tcp_t    tcp;
         uv_pipe_t   pipe;
+        uv_tty_t    tty;
     } u;
     int     id;
-    bool    is_pipe;
+    bool    is_pipe;  /* a pipe's, or a terminal's (it has no address, nor TCP's options) */
+    bool    is_tty;
     const JSNetHook *hook;  /* node:http's parser, which reads before JS */
     void   *hook_data;
     bool    closing;
@@ -63,12 +73,8 @@ static void emit(NetHandle *h, int event, JSValue value) {
     (void)js_uv_call(h->cb, 2, args, NULL);
 }
 
-static NetHandle *new_handle(JSContext *ctx, bool is_pipe, JSValue cb) {
-    NetHandle *h = calloc(1, sizeof *h);
-    if (!h) js_fatal("out of memory in net");
-    h->is_pipe = is_pipe;
-    if (is_pipe) uv_pipe_init(js_uv_loop(ctx), &h->u.pipe, 0);
-    else uv_tcp_init(js_uv_loop(ctx), &h->u.tcp);
+/* An initialized handle, numbered, with its callback. */
+static NetHandle *add_handle(JSContext *ctx, NetHandle *h, JSValue cb) {
     size_t id = 0;
     while (id < nhandles && handles[id]) id++;
     if (id == nhandles) {
@@ -86,6 +92,15 @@ static NetHandle *new_handle(JSContext *ctx, bool is_pipe, JSValue cb) {
     return h;
 }
 
+static NetHandle *new_handle(JSContext *ctx, bool is_pipe, JSValue cb) {
+    NetHandle *h = calloc(1, sizeof *h);
+    if (!h) js_fatal("out of memory in net");
+    h->is_pipe = is_pipe;
+    if (is_pipe) uv_pipe_init(js_uv_loop(ctx), &h->u.pipe, 0);
+    else uv_tcp_init(js_uv_loop(ctx), &h->u.tcp);
+    return add_handle(ctx, h, cb);
+}
+
 static void on_closed(uv_handle_t *uh) {
     NetHandle *h = (NetHandle *)uh;
     handles[h->id] = NULL;
@@ -112,7 +127,9 @@ uv_stream_t *js_net_stream(int id) {
 }
 
 bool js_net_hook(int id, const JSNetHook *hook, void *data) {
-    NetHandle *h = open_handle(id);
+    /* a hook is set on an open socket, but taken off a closing one too: its close calls the hook,
+     * whose data (node:http's parser) may be freed by then */
+    NetHandle *h = hook ? open_handle(id) : (id >= 0 && (size_t)id < nhandles ? handles[id] : NULL);
     if (!h) return false;
     h->hook = hook;
     h->hook_data = data;
@@ -124,9 +141,10 @@ static NetHandle *handle_arg(uint32_t argc, const JSValue *argv) {
 }
 
 /* A string argument as UTF-8 in buf. */
-static void string_arg(JSContext *ctx, JSValue v, char *buf, size_t size) {
-    buf[0] = '\0';
-    if (js_is_string(v)) buf[js_view_to_utf8(js_string_view(ctx, v), buf, size - 1)] = '\0';
+static size_t string_arg(JSContext *ctx, JSValue v, char *buf, size_t size) {
+    size_t n = js_is_string(v) ? js_view_to_utf8(js_string_view(ctx, v), buf, size - 1) : 0;
+    buf[n] = '\0';
+    return n;
 }
 
 /* An IP address and port; -errno for an address that isn't one. */
@@ -177,6 +195,20 @@ HOST_FN(js_host_net_open_fd) {
     return js_int32(h->is_pipe ? uv_pipe_open(&h->u.pipe, fd) : uv_tcp_open(&h->u.tcp, (uv_os_sock_t)fd));
 }
 
+/* netFd(id) → the handle's descriptor | -errno (-1 for a Windows socket's, as Node's) */
+HOST_FN(js_host_net_fd) {
+    UNUSED;
+    NetHandle *h = handle_arg(argc, argv);
+    if (!h) return js_int32(UV_EBADF);
+#ifdef _WIN32
+    return js_int32(-1);
+#else
+    uv_os_fd_t fd;
+    int r = uv_fileno((uv_handle_t *)&h->u.stream, &fd);
+    return js_int32(r < 0 ? r : fd);
+#endif
+}
+
 /* netBind(id, ip, port, flags 1 ipv6Only | 2 reusePort), or a pipe's netBind(id, path) */
 HOST_FN(js_host_net_bind) {
     UNUSED;
@@ -184,8 +216,8 @@ HOST_FN(js_host_net_bind) {
     if (!h || argc < 2) return js_int32(UV_EBADF);
     if (h->is_pipe) {
         char path[PATH_MAX_LEN];
-        string_arg(ctx, argv[1], path, sizeof path);
-        return js_int32(uv_pipe_bind2(&h->u.pipe, path, strlen(path), 0));
+        size_t n = string_arg(ctx, argv[1], path, sizeof path);  /* a Linux abstract path starts with a NUL */
+        return js_int32(uv_pipe_bind2(&h->u.pipe, path, n, UV_PIPE_NO_TRUNCATE));
     }
     struct sockaddr_storage addr;
     int r = sockaddr_arg(ctx, argv[1], argc > 2 ? argv[2] : JS_UNDEFINED, &addr);
@@ -243,8 +275,8 @@ HOST_FN(js_host_net_connect) {
     int r;
     if (h->is_pipe) {
         char path[PATH_MAX_LEN];
-        string_arg(ctx, argv[1], path, sizeof path);
-        r = uv_pipe_connect2(req, &h->u.pipe, path, strlen(path), 0, on_connect);
+        size_t n = string_arg(ctx, argv[1], path, sizeof path);
+        r = uv_pipe_connect2(req, &h->u.pipe, path, n, UV_PIPE_NO_TRUNCATE, on_connect);
     } else {
         struct sockaddr_storage addr;
         r = sockaddr_arg(ctx, argv[1], argc > 2 ? argv[2] : JS_UNDEFINED, &addr);
@@ -414,6 +446,7 @@ HOST_FN(js_host_net_address) {
     NetHandle *h = handle_arg(argc, argv);
     if (!h) return js_int32(UV_EBADF);
     bool peer = argc > 1 && js_truthy(argv[1]);
+    if (h->is_tty) return js_int32(UV_ENOTSOCK);
     if (h->is_pipe) {
         char path[PATH_MAX_LEN];
         size_t n = sizeof path;
@@ -443,6 +476,87 @@ HOST_FN(js_host_net_keep_alive) {
     return js_int32(uv_tcp_keepalive(&h->u.tcp, argc > 1 && js_truthy(argv[1]), delay));
 }
 
+/* netTypeOfService(id, tos): IP_TOS, or IPV6_TCLASS on an IPv6 socket, as Node's TCPWrap sets
+ * and reads it; with tos -1, the socket's */
+HOST_FN(js_host_net_type_of_service) {
+    UNUSED;
+    NetHandle *h = handle_arg(argc, argv);
+    if (!h || h->is_pipe) return js_int32(h ? UV_EINVAL : UV_EBADF);
+    int tos = argc > 1 && js_is_int32(argv[1]) ? js_as_int32(argv[1]) : -1;
+    uv_os_fd_t fd;
+    int err = uv_fileno((uv_handle_t *)&h->u.tcp, &fd);
+    if (err) return js_int32(err);
+    struct sockaddr_storage storage;
+    int len = sizeof storage;
+    err = uv_tcp_getsockname(&h->u.tcp, (struct sockaddr *)&storage, &len);
+    if (err) return js_int32(err);
+    int level, option;
+    if (storage.ss_family == AF_INET) {
+        level = IPPROTO_IP;
+        option = IP_TOS;
+    } else if (storage.ss_family == AF_INET6) {
+#ifdef IPV6_TCLASS
+        level = IPPROTO_IPV6;
+        option = IPV6_TCLASS;
+#else
+        return js_int32(UV_ENOTSUP);
+#endif
+    } else {
+        return js_int32(UV_EINVAL);
+    }
+#ifdef _WIN32
+    if (tos >= 0) {
+        return js_int32(setsockopt((SOCKET)fd, level, option, (const char *)&tos, sizeof tos) == 0
+                            ? 0 : uv_translate_sys_error(WSAGetLastError()));
+    }
+    int got = 0, got_len = sizeof got;
+    if (getsockopt((SOCKET)fd, level, option, (char *)&got, &got_len) != 0) return js_int32(uv_translate_sys_error(WSAGetLastError()));
+#else
+    if (tos >= 0) return js_int32(setsockopt(fd, level, option, &tos, sizeof tos) == 0 ? 0 : uv_translate_sys_error(errno));
+    int got = 0;
+    socklen_t got_len = sizeof got;
+    if (getsockopt(fd, level, option, &got, &got_len) != 0) return js_int32(uv_translate_sys_error(errno));
+#endif
+    return js_int32(got);
+}
+
+/* ---- Terminals ----------------------------------------------------------------------------- */
+
+static bool raw_mode_set;
+
+static void reset_tty_mode(void) {
+    uv_tty_reset_mode();
+}
+
+/* ttyOpen(fd, cb) → id | -errno: a terminal's handle, read like a pipe's */
+HOST_FN(js_host_tty_open) {
+    UNUSED;
+    if (argc < 1 || !js_is_int32(argv[0])) return js_int32(UV_EBADF);
+    NetHandle *h = calloc(1, sizeof *h);
+    if (!h) js_fatal("out of memory in net");
+    int r = uv_tty_init(js_uv_loop(ctx), &h->u.tty, js_as_int32(argv[0]), 0);
+    if (r < 0) {
+        free(h);
+        return js_int32(r);
+    }
+    h->is_pipe = true;
+    h->is_tty = true;
+    return js_int32(add_handle(ctx, h, argc > 1 ? argv[1] : JS_UNDEFINED)->id);
+}
+
+/* ttySetRawMode(id, raw) → 0 | -errno: keys as they're typed, unechoed; the terminal's mode is
+ * restored at exit, as Node's is */
+HOST_FN(js_host_tty_set_raw_mode) {
+    UNUSED;
+    NetHandle *h = handle_arg(argc, argv);
+    if (!h || !h->is_tty) return js_int32(UV_EBADF);
+    if (!raw_mode_set) {
+        raw_mode_set = true;
+        atexit(reset_tty_mode);
+    }
+    return js_int32(uv_tty_set_mode(&h->u.tty, argc > 1 && js_truthy(argv[1]) ? UV_TTY_MODE_RAW : UV_TTY_MODE_NORMAL));
+}
+
 /* ---- dns.lookup ---------------------------------------------------------------------------- */
 
 typedef struct Lookup {

package/node/src/host_os.c

@@ -1,10 +1,11 @@
-/* Host primitives for node:os (ADR 0012): the system's facts through libuv, as Node's os module
+/* Host primitives for node:os: the system's facts through libuv, as Node's os module
  * gets them, and the constants (signals and errno numbers) of the platform the program was built
  * for. Failures return -errno, which the prelude turns into Node's SystemError. */
 #define _GNU_SOURCE  /* libuv's headers, and every signal and errno name the platform has */
 #include "js_node.h"
 
 #include <errno.h>
+#include <stdio.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
@@ -24,6 +25,59 @@ static JSValue array_of(JSContext *ctx, const JSValue *items, uint32_t n) {
     return a;
 }
 
+/* osInterfaces(): [name, address, netmask, family (4 | 6), mac, internal, scopeid, …], 7 per
+ * address (uv_interface_addresses), or -errno. */
+PRIMITIVE(js_host_os_interfaces) {
+    UNUSED_PRIMITIVE_ARGS;
+    uv_interface_address_t *list;
+    int count;
+    int r = uv_interface_addresses(&list, &count);
+    if (r < 0) return js_int32(r);
+    JSValue a = js_new_array(ctx, (uint32_t)count * 7);
+    for (int i = 0; i < count && !js_is_exception(a); i++) {
+        uv_interface_address_t *ia = &list[i];
+        char address[INET6_ADDRSTRLEN], netmask[INET6_ADDRSTRLEN], mac[18];
+        bool v6 = ia->address.address4.sin_family == AF_INET6;
+        if (v6) {
+            uv_ip6_name(&ia->address.address6, address, sizeof address);
+            uv_ip6_name(&ia->netmask.netmask6, netmask, sizeof netmask);
+        } else {
+            uv_ip4_name(&ia->address.address4, address, sizeof address);
+            uv_ip4_name(&ia->netmask.netmask4, netmask, sizeof netmask);
+        }
+        const unsigned char *m = (const unsigned char *)ia->phys_addr;
+        snprintf(mac, sizeof mac, "%02x:%02x:%02x:%02x:%02x:%02x", m[0], m[1], m[2], m[3], m[4], m[5]);
+        JSValue items[7] = {
+            js_new_string_cstr(ctx, ia->name), js_new_string_cstr(ctx, address), js_new_string_cstr(ctx, netmask),
+            js_int32(v6 ? 6 : 4), js_new_string_cstr(ctx, mac), js_bool(ia->is_internal),
+            js_number(v6 ? (double)ia->address.address6.sin6_scope_id : 0),
+        };
+        for (int k = 0; k < 7; k++) {
+            if (js_is_exception(items[k]) || js_array_append(ctx, a, items[k]) < 0) {
+                a = JS_EXCEPTION;
+                break;
+            }
+        }
+    }
+    uv_free_interface_addresses(list, count);
+    return a;
+}
+
+/* osGetPriority(pid) → priority | -errno */
+PRIMITIVE(js_host_os_get_priority) {
+    (void)ctx, (void)callee, (void)this_val, (void)new_target;
+    int priority;
+    int r = uv_os_getpriority(argc > 0 && js_is_number(argv[0]) ? (uv_pid_t)js_as_number(argv[0]) : 0, &priority);
+    return js_int32(r < 0 ? r : priority);
+}
+
+/* osSetPriority(pid, priority) → 0 | -errno */
+PRIMITIVE(js_host_os_set_priority) {
+    (void)ctx, (void)callee, (void)this_val, (void)new_target;
+    if (argc < 2 || !js_is_number(argv[0]) || !js_is_int32(argv[1])) return js_int32(UV_EINVAL);
+    return js_int32(uv_os_setpriority((uv_pid_t)js_as_number(argv[0]), js_as_int32(argv[1])));
+}
+
 /* osUname(): [sysname, release, version, machine], or -errno. */
 PRIMITIVE(js_host_os_uname) {
     UNUSED_PRIMITIVE_ARGS;

package/node/src/host_proc.c

@@ -0,0 +1,291 @@
+/* Host primitives for the program's own process (node:process beyond the runtime's process object):
+ * the working directory, the file mode mask, uptime, CPU and resource usage, the parent, memory
+ * limits, user and group ids (POSIX), abort, exit and execve. Child processes are host_process.c's.
+ *
+ *   procChdir(path) → 0 | -errno                procUmask(mask | -1) → the old mask (-1: only read it)
+ *   procUptime() → seconds since the program started
+ *   procCpuUsage(thread) → [user µs, system µs] | -errno     procResourceUsage() → [16 numbers] | -errno
+ *   procPpid() → pid                            procMemory() → [available, constrained] bytes
+ *   procSetId(kind, id) → 0 | -errno   kind 0 setuid, 1 setgid, 2 seteuid, 3 setegid
+ *   procUserId(name) → id | -1                  procGroupId(name) → id | -1
+ *   procUserName(id) → name | null              procGetGroups() → [gid, …] | -errno
+ *   procSetGroups([gid, …]) → 0 | -errno        procInitGroups(user, gid) → 0 | -errno
+ *   procAbort()                                 procReallyExit(code): output flushed, no 'exit'
+ *   procExecve(file, [arg, …], [key=value, …]) → -errno (it returns only when it fails) */
+#define _POSIX_C_SOURCE 200809L
+#define _DEFAULT_SOURCE  /* getgroups, setgroups, initgroups */
+#define _DARWIN_C_SOURCE /* the same, on macOS */
+#include "js_node.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <uv.h>
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <grp.h>
+#include <pwd.h>
+#include <unistd.h>
+#endif
+
+#include "js_atoms.h"
+#include "js_buffer.h"
+#include "js_convert.h"
+#include "js_exception.h"
+#include "js_object.h"
+#include "jscontext.h"
+#include "jsstring.h"
+
+#define HOST_FN(name) JSValue name(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target)
+#define UNUSED (void)ctx, (void)callee, (void)this_val, (void)new_target
+
+/* when the program started: set before main, in a program that links this file */
+static uint64_t start_ns;
+__attribute__((constructor)) static void record_start(void) { start_ns = uv_hrtime(); }
+
+/* A string argument as UTF-8, malloc'd; NULL for anything else. */
+static char *string_arg(JSContext *ctx, JSValue v) {
+    if (!js_is_string(v)) return NULL;
+    JSStrView view = js_string_view(ctx, v);
+    size_t n = js_view_to_utf8(view, NULL, 0);
+    char *s = malloc(n + 1);
+    if (!s) js_fatal("out of memory");
+    js_view_to_utf8(view, s, n);
+    s[n] = '\0';
+    return s;
+}
+
+static JSValue numbers(JSContext *ctx, const double *v, uint32_t n) {
+    JSValue values[16];
+    for (uint32_t i = 0; i < n; i++) values[i] = js_number(v[i]);
+    return js_new_array_from(ctx, values, n);
+}
+
+HOST_FN(js_host_proc_chdir) {
+    UNUSED;
+    char *path = argc > 0 ? string_arg(ctx, argv[0]) : NULL;
+    if (!path) return js_int32(UV_EINVAL);
+    int r = uv_chdir(path);
+    free(path);
+    return js_int32(r);
+}
+
+HOST_FN(js_host_proc_umask) {
+    UNUSED;
+    int mask = argc > 0 && js_is_int32(argv[0]) ? js_as_int32(argv[0]) : -1;
+    if (mask < 0) {  /* read: set it, then back */
+        int old = (int)umask(0);
+        umask((mode_t)old);
+        return js_int32(old);
+    }
+    return js_int32((int)umask((mode_t)(mask & 0777)));
+}
+
+HOST_FN(js_host_proc_uptime) {
+    UNUSED, (void)argc, (void)argv;
+    return js_number((double)(uv_hrtime() - start_ns) / 1e9);
+}
+
+static double usec(uv_timeval_t t) { return (double)t.tv_sec * 1e6 + (double)t.tv_usec; }
+
+HOST_FN(js_host_proc_cpu_usage) {
+    UNUSED;
+    uv_rusage_t ru;
+    int r = argc > 0 && js_truthy(argv[0]) ? uv_getrusage_thread(&ru) : uv_getrusage(&ru);
+    if (r < 0) return js_int32(r);
+    double v[2] = { usec(ru.ru_utime), usec(ru.ru_stime) };
+    return numbers(ctx, v, 2);
+}
+
+/* in Node's order: userCPUTime, systemCPUTime, maxRSS (KiB), sharedMemorySize, unsharedDataSize,
+ * unsharedStackSize, minorPageFault, majorPageFault, swappedOut, fsRead, fsWrite, ipcSent,
+ * ipcReceived, signalsCount, voluntaryContextSwitches, involuntaryContextSwitches */
+HOST_FN(js_host_proc_resource_usage) {
+    UNUSED, (void)argc, (void)argv;
+    uv_rusage_t ru;
+    int r = uv_getrusage(&ru);
+    if (r < 0) return js_int32(r);
+    double v[16] = {
+        usec(ru.ru_utime), usec(ru.ru_stime), (double)ru.ru_maxrss, (double)ru.ru_ixrss, (double)ru.ru_idrss, (double)ru.ru_isrss,
+        (double)ru.ru_minflt, (double)ru.ru_majflt, (double)ru.ru_nswap, (double)ru.ru_inblock, (double)ru.ru_oublock,
+        (double)ru.ru_msgsnd, (double)ru.ru_msgrcv, (double)ru.ru_nsignals, (double)ru.ru_nvcsw, (double)ru.ru_nivcsw,
+    };
+    return numbers(ctx, v, 16);
+}
+
+HOST_FN(js_host_proc_ppid) {
+    UNUSED, (void)argc, (void)argv;
+    return js_number((double)uv_os_getppid());
+}
+
+HOST_FN(js_host_proc_memory) {
+    UNUSED, (void)argc, (void)argv;
+    double v[2] = { (double)uv_get_available_memory(), (double)uv_get_constrained_memory() };
+    return numbers(ctx, v, 2);
+}
+
+HOST_FN(js_host_proc_abort) {
+    UNUSED, (void)argc, (void)argv;
+    fflush(stdout);
+    fflush(stderr);
+    abort();
+}
+
+HOST_FN(js_host_proc_really_exit) {
+    UNUSED;
+    int code = argc > 0 && js_is_int32(argv[0]) ? js_as_int32(argv[0]) : 0;
+    fflush(stdout);
+    fflush(stderr);
+    exit(code);
+}
+
+#ifndef _WIN32
+
+HOST_FN(js_host_proc_set_id) {
+    UNUSED;
+    if (argc < 2 || !js_is_int32(argv[0]) || !js_is_number(argv[1])) return js_int32(UV_EINVAL);
+    double d = js_as_number(argv[1]);
+    int r;
+    switch (js_as_int32(argv[0])) {
+    case 0: r = setuid((uid_t)d); break;
+    case 1: r = setgid((gid_t)d); break;
+    case 2: r = seteuid((uid_t)d); break;
+    case 3: r = setegid((gid_t)d); break;
+    default: return js_int32(UV_EINVAL);
+    }
+    return js_int32(r < 0 ? -errno : 0);
+}
+
+HOST_FN(js_host_proc_user_id) {
+    UNUSED;
+    char *name = argc > 0 ? string_arg(ctx, argv[0]) : NULL;
+    if (!name) return js_int32(-1);
+    struct passwd *pw = getpwnam(name);
+    free(name);
+    return pw ? js_number((double)pw->pw_uid) : js_int32(-1);
+}
+
+HOST_FN(js_host_proc_group_id) {
+    UNUSED;
+    char *name = argc > 0 ? string_arg(ctx, argv[0]) : NULL;
+    if (!name) return js_int32(-1);
+    struct group *gr = getgrnam(name);
+    free(name);
+    return gr ? js_number((double)gr->gr_gid) : js_int32(-1);
+}
+
+HOST_FN(js_host_proc_user_name) {
+    UNUSED;
+    if (argc < 1 || !js_is_number(argv[0])) return JS_NULL;
+    struct passwd *pw = getpwuid((uid_t)js_as_number(argv[0]));
+    return pw ? js_new_string_cstr(ctx, pw->pw_name) : JS_NULL;
+}
+
+HOST_FN(js_host_proc_get_groups) {
+    UNUSED, (void)argc, (void)argv;
+    int n = getgroups(0, NULL);
+    if (n < 0) return js_int32(-errno);
+    gid_t *groups = malloc(((size_t)n + 1) * sizeof *groups);
+    if (!groups) js_fatal("out of memory");
+    n = getgroups(n, groups);
+    if (n < 0) {
+        free(groups);
+        return js_int32(-errno);
+    }
+    /* the effective group too, as Node lists it */
+    gid_t egid = getegid();
+    bool listed = false;
+    for (int i = 0; i < n; i++) listed |= groups[i] == egid;
+    if (!listed) groups[n++] = egid;
+    JSValue list = js_new_array(ctx, (uint32_t)n);
+    for (int i = 0; i < n && !js_is_exception(list); i++) {
+        if (js_array_push(ctx, js_as_object(list), js_number((double)groups[i])) < 0) list = JS_EXCEPTION;
+    }
+    free(groups);
+    return list;
+}
+
+HOST_FN(js_host_proc_set_groups) {
+    UNUSED;
+    if (argc < 1 || !js_is_object(argv[0])) return js_int32(UV_EINVAL);
+    JSValue len = js_get_value(ctx, argv[0], JS_ATOM(length));
+    if (!js_is_number(len)) return js_int32(UV_EINVAL);
+    size_t n = (size_t)js_as_number(len);
+    gid_t *groups = malloc((n + 1) * sizeof *groups);
+    if (!groups) js_fatal("out of memory");
+    for (size_t i = 0; i < n; i++) {
+        JSValue v = js_get_index(ctx, argv[0], js_int32((int32_t)i));
+        if (!js_is_number(v)) {
+            free(groups);
+            return js_int32(UV_EINVAL);
+        }
+        groups[i] = (gid_t)js_as_number(v);
+    }
+    int r = setgroups(n, groups);
+    free(groups);
+    return js_int32(r < 0 ? -errno : 0);
+}
+
+HOST_FN(js_host_proc_init_groups) {
+    UNUSED;
+    char *user = argc > 0 ? string_arg(ctx, argv[0]) : NULL;
+    if (!user || argc < 2 || !js_is_number(argv[1])) {
+        free(user);
+        return js_int32(UV_EINVAL);
+    }
+    int r = initgroups(user, (gid_t)js_as_number(argv[1]));
+    free(user);
+    return js_int32(r < 0 ? -errno : 0);
+}
+
+/* the strings of an array, NULL-terminated, malloc'd */
+static char **string_list(JSContext *ctx, JSValue array) {
+    if (!js_is_object(array)) return NULL;
+    JSValue len = js_get_value(ctx, array, JS_ATOM(length));
+    size_t n = js_is_number(len) ? (size_t)js_as_number(len) : 0;
+    char **list = calloc(n + 1, sizeof *list);
+    if (!list) js_fatal("out of memory");
+    for (size_t i = 0; i < n; i++) {
+        list[i] = string_arg(ctx, js_get_index(ctx, array, js_int32((int32_t)i)));
+        if (!list[i]) list[i] = strdup("");
+    }
+    return list;
+}
+
+static void free_list(char **list) {
+    for (size_t i = 0; list && list[i]; i++) free(list[i]);
+    free(list);
+}
+
+HOST_FN(js_host_proc_execve) {
+    UNUSED;
+    char *file = argc > 0 ? string_arg(ctx, argv[0]) : NULL;
+    char **args = argc > 1 ? string_list(ctx, argv[1]) : NULL;
+    char **env = argc > 2 ? string_list(ctx, argv[2]) : NULL;
+    if (!file || !args || !env) {
+        free(file), free_list(args), free_list(env);
+        return js_int32(UV_EINVAL);
+    }
+    fflush(stdout);
+    fflush(stderr);
+    execve(file, args, env);
+    int e = errno;
+    free(file), free_list(args), free_list(env);
+    return js_int32(-e);
+}
+
+#else  /* Windows: Node has none of these */
+
+HOST_FN(js_host_proc_set_id) { UNUSED, (void)argc, (void)argv; return js_int32(UV_ENOSYS); }
+HOST_FN(js_host_proc_user_id) { UNUSED, (void)argc, (void)argv; return js_int32(-1); }
+HOST_FN(js_host_proc_group_id) { UNUSED, (void)argc, (void)argv; return js_int32(-1); }
+HOST_FN(js_host_proc_user_name) { UNUSED, (void)argc, (void)argv; return JS_NULL; }
+HOST_FN(js_host_proc_get_groups) { UNUSED, (void)argc, (void)argv; return js_int32(UV_ENOSYS); }
+HOST_FN(js_host_proc_set_groups) { UNUSED, (void)argc, (void)argv; return js_int32(UV_ENOSYS); }
+HOST_FN(js_host_proc_init_groups) { UNUSED, (void)argc, (void)argv; return js_int32(UV_ENOSYS); }
+HOST_FN(js_host_proc_execve) { UNUSED, (void)argc, (void)argv; return js_int32(UV_ENOSYS); }
+
+#endif