visaljs 0.0.6 → 0.0.8

package/node/src/host_http.c

@@ -1,4 +1,4 @@
-/* Host primitives for node:http (ADR 0012, host prelude): llhttp (Node's parser) on node:net's
+/* Host primitives for node:http: llhttp (Node's parser) on node:net's
  * sockets, for a server's requests and a client's responses. As in Node, a connection is a
  * net.Socket, but its bytes go to the parser in C, not through JS: host_net.c's hook hands them
  * over. The prelude's http.js builds Node's objects from what the parser finds; C does the
@@ -22,6 +22,12 @@
  *                              writes goes out in one write when it (and its microtasks) returns
  *   httpFlush(conn)            sends the corked output now (before the socket is ended)
  *   httpDate() → the Date header's value
+ * A socket whose bytes aren't its handle's (a TLS socket's are decrypted in JS, a Duplex has no
+ * handle) is a fed connection, with a negative id: JS gives its parser the bytes, and its output
+ * goes to a JS writer (which the TLS socket encrypts).
+ *   httpFedOpen(writer) → conn     writer(bytes) gets what the connection's output flushes
+ *   httpFeed(conn, bytes | null) → whether the parser took them (null: the end of the input)
+ *   httpFedClose(conn)             the connection is done with (its socket closed)
  * The loop is host_loop.c's; the sockets are host_net.c's. */
 #define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t, struct addrinfo */
 #include <stdio.h>
@@ -77,10 +83,18 @@ struct Conn {
     Buf      out;        /* written but not sent: corked, as Node corks a response */
 };
 
+/* A fed connection: its writer, and the parser it has now (a new one per kept-alive request). */
+typedef struct Fed {
+    JSValue writer;  /* a root */
+    Conn   *conn;
+} Fed;
+
 static Parsers **parsers;
 static size_t nparsers;
 static Conn **conns;   /* by net handle id */
 static size_t nconns;
+static Fed **feds;     /* fed connections: id -(k + 1) is feds[k] */
+static size_t nfeds;
 static int *pending;   /* ids of connections with corked output */
 static size_t npending, pending_cap;
 static llhttp_settings_t settings;
@@ -211,7 +225,19 @@ static int on_message_complete(llhttp_t *p) {
     return js_uv_call(c->parsers->on_complete, 2, args, NULL) ? 0 : -1;
 }
 
-static Conn *conn_of(int id) { return id >= 0 && (size_t)id < nconns ? conns[id] : NULL; }
+static Fed *fed_of(int id) {
+    if (id >= 0) return NULL;
+    size_t k = (size_t)(-(id + 1));
+    return k < nfeds ? feds[k] : NULL;
+}
+
+static Conn *conn_of(int id) {
+    if (id < 0) {
+        Fed *f = fed_of(id);
+        return f ? f->conn : NULL;
+    }
+    return (size_t)id < nconns ? conns[id] : NULL;
+}
 
 static void parse_error(Conn *c, llhttp_errno_t e) {
     c->detached = true;
@@ -233,16 +259,20 @@ static void free_conn(Conn *c) {
  * when llhttp returns if a callback let go of it (a client frees its parser in the response's
  * last callback, and starts the next request in a microtask). */
 static void release_conn(Conn *c) {
-    if (conns[c->id] == c) conns[c->id] = NULL;
+    Fed *f = fed_of(c->id);
+    if (f) {
+        if (f->conn == c) f->conn = NULL;
+    } else if (conns[c->id] == c) {
+        conns[c->id] = NULL;
+    }
     c->detached = true;
     if (c->executing) c->released = true;
     else free_conn(c);
 }
 
-/* The socket's bytes, before JS sees them: parsed while attached; EOF and errors go on to JS
- * (the socket's 'end' and 'error'). */
-static bool hook_read(void *data, ssize_t n, const char *bytes) {
-    Conn *c = data;
+/* A connection's bytes: parsed while attached; EOF and errors go on to JS (the socket's 'end'
+ * and 'error'). False when the parser doesn't take them. */
+static bool parse_input(Conn *c, ssize_t n, const char *bytes) {
     if (c->detached) return false;
     c->executing = true;
     if (n < 0) {
@@ -281,6 +311,16 @@ static bool hook_read(void *data, ssize_t n, const char *bytes) {
     return true;
 }
 
+/* A socket's bytes, before JS sees them. */
+/* a socket's read, parsed in C: its callbacks (a body and its end) run before the microtasks and
+ * nextTicks do, as in Node, where one read is one callback scope */
+static bool hook_read(void *data, ssize_t n, const char *bytes) {
+    js_uv_nest(1);
+    bool ok = parse_input(data, n, bytes);
+    js_uv_nest(-1);
+    return js_uv_drain() && ok;
+}
+
 static void hook_close(void *data) { release_conn(data); }
 
 static const JSNetHook http_hook = { hook_read, hook_close };
@@ -320,8 +360,11 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     if (argc < 2 || !js_is_int32(argv[0]) || !js_is_int32(argv[1])) return js_throw_type_error(ctx, "httpAttach: (conn, parsers) expected");
     int id = js_as_int32(argv[0]);
     int32_t pi = js_as_int32(argv[1]);
-    if (pi < 0 || (size_t)pi >= nparsers || !js_net_stream(id)) return js_int32(UV_EBADF);
-    if ((size_t)id >= nconns) {
+    Fed *f = fed_of(id);
+    if (pi < 0 || (size_t)pi >= nparsers || (id < 0 ? !f : !js_net_stream(id))) return js_int32(UV_EBADF);
+    if (f) {
+        if (f->conn) release_conn(f->conn);
+    } else if ((size_t)id >= nconns) {
         size_t n = nconns ? nconns : 64;
         while (n <= (size_t)id) n *= 2;
         Conn **v = realloc(conns, n * sizeof *v);
@@ -330,7 +373,7 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
         conns = v;
         nconns = n;
     }
-    if (conns[id]) release_conn(conns[id]);  /* a kept-alive socket's next request: a fresh parser */
+    if (!f && conns[id]) release_conn(conns[id]);  /* a kept-alive socket's next request: a fresh parser */
     Conn *c = calloc(1, sizeof *c);
     if (!c) js_fatal("out of memory in http");
     c->id = id;
@@ -343,8 +386,12 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     js_add_root(ctx->rt, &c->headers);
     llhttp_init(&c->parser, c->response ? HTTP_RESPONSE : HTTP_REQUEST, &settings);
     c->parser.data = c;
-    conns[id] = c;
-    js_net_hook(id, &http_hook, c);
+    if (f) {
+        f->conn = c;  /* its bytes come from httpFeed */
+    } else {
+        conns[id] = c;
+        js_net_hook(id, &http_hook, c);
+    }
     return js_int32(0);
 }
 
@@ -354,7 +401,7 @@ JSValue js_host_http_detach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
     if (c) {
         if (c->queued) flush_conn(c);
-        js_net_hook(c->id, NULL, NULL);
+        if (c->id >= 0) js_net_hook(c->id, NULL, NULL);
         release_conn(c);
     }
     return JS_UNDEFINED;
@@ -372,8 +419,8 @@ JSValue js_host_http_expired(JSContext *ctx, JSValue callee, JSValue this_val, u
     JSValue list = js_new_array(ctx, 0);
     if (pi < 0 || (size_t)pi >= nparsers) return list;
     uint64_t now = uv_now(js_uv_loop(ctx));
-    for (size_t i = 0; i < nconns; i++) {
-        Conn *c = conns[i];
+    for (size_t i = 0; i < nconns + nfeds; i++) {
+        Conn *c = i < nconns ? conns[i] : feds[i - nconns] ? feds[i - nconns]->conn : NULL;
         if (!c || c->parsers != parsers[pi] || !c->active || c->detached) continue;
         uint64_t age = now - c->begin_ms;
         if ((!c->head_done && headers_timeout > 0 && (double)age > headers_timeout) || (request_timeout > 0 && (double)age > request_timeout)) {
@@ -401,6 +448,15 @@ static void on_written(uv_write_t *req, int status) {
 /* Sends a connection's corked output as one write. */
 static void flush_conn(Conn *c) {
     c->queued = false;
+    Fed *f = fed_of(c->id);
+    if (f) {  /* to its writer: the connection may be gone when it returns */
+        if (c->out.n == 0) return;
+        JSValue bytes = bytes_value(ctx_(), c->out.v, c->out.n);
+        c->out.n = 0;
+        JSValue writer = f->writer;
+        (void)js_uv_call(writer, 1, &bytes, NULL);
+        return;
+    }
     uv_stream_t *s = js_net_stream(c->id);
     if (!s || c->out.n == 0) {
         c->out.n = 0;
@@ -417,19 +473,26 @@ static void flush_conn(Conn *c) {
     }
 }
 
+/* Taken over before it runs: a fed connection's writer runs JS, which may write (and flush) more. */
 static void flush_pending(void) {
-    for (size_t i = 0; i < npending; i++) {
-        Conn *c = conn_of(pending[i]);
-        if (c && c->queued) flush_conn(c);
+    while (npending > 0) {
+        int *ids = pending;
+        size_t n = npending;
+        pending = NULL;
+        npending = pending_cap = 0;
+        for (size_t i = 0; i < n; i++) {
+            Conn *c = conn_of(ids[i]);
+            if (c && c->queued) flush_conn(c);
+        }
+        free(ids);
     }
-    npending = 0;
 }
 
 /* httpWrite(conn, data): corked until the current callback (and its microtasks) returns */
 JSValue js_host_http_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)new_target;
     Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
-    if (!c || argc < 2 || !js_net_stream(c->id)) return JS_FALSE;
+    if (!c || argc < 2 || (c->id >= 0 && !js_net_stream(c->id))) return JS_FALSE;
     if (js_is_string(argv[1])) {
         JSStrView v = js_string_view(ctx, argv[1]);
         size_t n = js_view_to_utf8(v, NULL, 0);
@@ -465,6 +528,66 @@ JSValue js_host_http_flush(JSContext *ctx, JSValue callee, JSValue this_val, uin
     return JS_UNDEFINED;
 }
 
+/* ---- Fed connections --------------------------------------------------------------------- */
+
+/* httpFedOpen(writer) → conn: a connection whose bytes JS feeds */
+JSValue js_host_http_fed_open(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    if (argc < 1 || !js_is_callable(argv[0])) return js_throw_type_error(ctx, "httpFedOpen: a writer expected");
+    size_t k = 0;
+    while (k < nfeds && feds[k]) k++;
+    if (k == nfeds) {
+        size_t n = nfeds ? nfeds * 2 : 16;
+        Fed **v = realloc(feds, n * sizeof *v);
+        if (!v) js_fatal("out of memory in http");
+        memset(v + nfeds, 0, (n - nfeds) * sizeof *v);
+        feds = v;
+        nfeds = n;
+    }
+    Fed *f = calloc(1, sizeof *f);  /* by itself: its writer is a root at a fixed address */
+    if (!f) js_fatal("out of memory in http");
+    f->writer = argv[0];
+    js_add_root(ctx->rt, &f->writer);
+    feds[k] = f;
+    return js_int32(-(int32_t)k - 1);
+}
+
+/* httpFeed(conn, bytes | null) → whether the parser took them; null: the input ended */
+JSValue js_host_http_feed(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    Conn *c = argc > 0 && js_is_int32(argv[0]) && js_as_int32(argv[0]) < 0 ? conn_of(js_as_int32(argv[0])) : NULL;
+    if (!c) return JS_FALSE;
+    /* called from JS: the parser's callbacks run in it, so no microtask or nextTick runs between
+     * two of them (a body and its end come in the same turn, as in Node) */
+    if (argc < 2 || js_is_null(argv[1]) || js_is_undefined(argv[1])) {
+        js_uv_nest(1);
+        bool ok = parse_input(c, UV_EOF, NULL);
+        js_uv_nest(-1);
+        return js_bool(ok);
+    }
+    uint8_t *bytes;
+    size_t n;
+    if (!js_buffer_source_bytes(argv[1], &bytes, &n)) return js_throw_type_error(ctx, "httpFeed: bytes expected");
+    if (n == 0) return JS_TRUE;
+    js_uv_nest(1);
+    bool ok = parse_input(c, (ssize_t)n, (const char *)bytes);
+    js_uv_nest(-1);
+    return js_bool(ok);
+}
+
+/* httpFedClose(conn): its parser and writer go */
+JSValue js_host_http_fed_close(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    int id = argc > 0 && js_is_int32(argv[0]) ? js_as_int32(argv[0]) : 0;
+    Fed *f = fed_of(id);
+    if (!f) return JS_UNDEFINED;
+    if (f->conn) release_conn(f->conn);
+    feds[-(id + 1)] = NULL;
+    js_remove_root(ctx->rt, &f->writer);
+    free(f);
+    return JS_UNDEFINED;
+}
+
 /* httpDate(): the Date header's value, IMF-fixdate, formatted once per second (as Node caches it) */
 JSValue js_host_http_date(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)argc, (void)argv, (void)new_target;

package/node/src/host_loop.c

@@ -1,4 +1,4 @@
-/* The libuv loop the host modules share (ADR 0008's I/O backend): node:http and node:net
+/* The libuv loop the host modules share: node:http and node:net
  * install it on first use, so programs without I/O don't link libuv. */
 #define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t, struct addrinfo */
 #ifndef _WIN32
@@ -16,6 +16,7 @@ static uv_timer_t wake;      /* ends uv_run at the next timer's deadline; unref'
 static JSContext *loop_ctx;  /* the realm callbacks run in */
 static int failed;           /* exit status after an uncaught error in a callback */
 static void (*flush_hook)(void);
+static int call_depth;       /* js_uv_calls under way: one made from JS (a fed http parser's) nests */
 
 static void on_wake(uv_timer_t *t) { (void)t; }
 
@@ -63,13 +64,29 @@ JSContext *js_uv_context(void) { return loop_ctx; }
 
 void js_uv_set_flush(void (*fn)(void)) { flush_hook = fn; }
 
+void js_uv_nest(int delta) { call_depth += delta; }
+
+bool js_uv_drain(void) {
+    if (failed) return false;
+    if (call_depth > 0) return true;
+    if (js_run_microtasks(loop_ctx) < 0) {
+        failed = loop_ctx->rt->failure;
+        uv_stop(loop);
+        return false;
+    }
+    flush();
+    return true;
+}
+
 bool js_uv_call(JSValue fn, uint32_t argc, JSValue *argv, JSValue *result) {
     if (failed) return false;
     JSContext *ctx = loop_ctx;
-    /* under no async context (ADR 0020): the prelude binds a callback to the one it was given in */
+    /* under no async context: the prelude binds a callback to the one it was given in */
     JSValue saved = js_async_context(ctx);
     js_set_async_context(ctx, JS_UNDEFINED);
+    call_depth++;
     JSValue r = js_call(ctx, fn, JS_UNDEFINED, argc, argv);
+    call_depth--;
     js_set_async_context(ctx, saved);
     if (js_is_exception(r)) {
         failed = js_report_uncaught(ctx);
@@ -79,6 +96,12 @@ bool js_uv_call(JSValue fn, uint32_t argc, JSValue *argv, JSValue *result) {
         }
         r = JS_UNDEFINED;  /* handled ('uncaughtException'): the program goes on */
     }
+    /* microtasks run, and output goes out, when the outermost callback returns, as in Node: a call
+     * made while JS is running (a parser fed from a 'data' listener) leaves them to it */
+    if (call_depth > 0) {
+        if (result) *result = r;
+        return true;
+    }
     if (js_run_microtasks(ctx) < 0) {
         failed = ctx->rt->failure;
         uv_stop(loop);

package/node/src/host_net.c

@@ -22,6 +22,9 @@
  *   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
+ *   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 */
 #include <stdlib.h>
@@ -45,9 +48,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 +68,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 +87,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;
@@ -414,6 +424,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 +454,43 @@ HOST_FN(js_host_net_keep_alive) {
     return js_int32(uv_tcp_keepalive(&h->u.tcp, argc > 1 && js_truthy(argv[1]), delay));
 }
 
+/* ---- 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;