visaljs 0.0.8 → 0.0.10

package/node/src/host_http.c

@@ -50,11 +50,12 @@
 static void flush_pending(void);
 typedef struct Conn Conn;
 static void flush_conn(Conn *c);
+static size_t pending_bytes(Conn *c);
 
 /* ---- Parsers and connections ------------------------------------------------------------- */
 
 typedef struct Parsers {
-    JSValue on_request, on_body, on_complete, on_upgrade, on_error;  /* roots */
+    JSValue on_request, on_body, on_complete, on_upgrade, on_error, on_drain;  /* roots */
 } Parsers;
 
 typedef struct Buf {
@@ -70,9 +71,13 @@ struct Conn {
     bool     detached;   /* upgraded, or a parse error: the parser doesn't read any more */
     bool     executing;  /* llhttp is running on it: it can't be freed yet */
     bool     released;   /* let go of while executing: freed when llhttp returns */
+    bool     detach_after;  /* detached when llhttp is done with the read (httpDetach's afterRead) */
     bool     upgrading;  /* JS took the upgrade the head asked for */
     bool     active;     /* a message is under way (or the connection is new): timeouts count */
     bool     head_done;  /* its head is complete: what follows are its body and trailers */
+    bool     in_message; /* a message has begun and isn't complete: the connection isn't idle */
+    llhttp_errno_t failed;  /* the parse error it stopped at: more bytes report it again, as Node's */
+    bool     need_drain; /* JS waits for its output to drain (a write over the high-water mark) */
     bool     overflow;   /* its head is over max_header bytes */
     uint64_t begin_ms;   /* when the message began (the loop's time) */
     size_t   header_bytes, max_header;
@@ -150,6 +155,7 @@ static int on_message_begin(llhttp_t *p) {
     c->headers = js_new_array(ctx_(), 0);
     c->active = true;
     c->head_done = false;
+    c->in_message = true;
     c->header_bytes = 0;
     c->begin_ms = uv_now(js_uv_loop(ctx_()));
     return 0;
@@ -220,6 +226,7 @@ static int on_message_complete(llhttp_t *p) {
     if (c->detached) return -1;  /* let go of by an earlier callback */
     if (c->in_value || c->field.n) push_header(c);  /* the last trailer */
     c->active = false;
+    c->in_message = false;
     JSValue args[2] = { js_int32(c->id), c->headers };
     c->headers = JS_UNDEFINED;
     return js_uv_call(c->parsers->on_complete, 2, args, NULL) ? 0 : -1;
@@ -239,14 +246,20 @@ static Conn *conn_of(int id) {
     return (size_t)id < nconns ? conns[id] : NULL;
 }
 
-static void parse_error(Conn *c, llhttp_errno_t e) {
+/* the parse error, with Node's bytesParsed and rawPacket: how far into the read llhttp got, and
+ * the read (none for a message cut short at the end of the stream) */
+static void parse_error(Conn *c, llhttp_errno_t e, const char *bytes, size_t n) {
     c->detached = true;
+    c->failed = e;
     c->active = false;
     JSContext *ctx = ctx_();
     const char *code = c->overflow ? "HPE_HEADER_OVERFLOW" : llhttp_errno_name(e);
     const char *reason = c->overflow ? "Header overflow" : llhttp_get_error_reason(&c->parser);
-    JSValue args[3] = { js_int32(c->id), js_new_string_cstr(ctx, code), js_new_string_cstr(ctx, reason ? reason : "") };
-    (void)js_uv_call(c->parsers->on_error, 3, args, NULL);
+    const char *pos = bytes ? llhttp_get_error_pos(&c->parser) : NULL;
+    int32_t parsed = pos && pos >= bytes && pos <= bytes + n ? (int32_t)(pos - bytes) : 0;
+    JSValue args[5] = { js_int32(c->id), js_new_string_cstr(ctx, code), js_new_string_cstr(ctx, reason ? reason : ""), js_int32(parsed),
+                        bytes ? bytes_value(ctx, bytes, n) : JS_UNDEFINED };
+    (void)js_uv_call(c->parsers->on_error, 5, args, NULL);
 }
 
 static void free_conn(Conn *c) {
@@ -270,9 +283,34 @@ static void release_conn(Conn *c) {
     else free_conn(c);
 }
 
+/* The socket's bytes go to JS again: the corked output first, then the parser let go of. */
+static void detach_conn(Conn *c) {
+    if (c->queued) flush_conn(c);
+    if (c->id >= 0) js_net_hook(c->id, NULL, NULL);
+    release_conn(c);
+}
+
+/* llhttp is done with a read: a parser let go of meanwhile is freed, or detached if asked to be. */
+static void read_done(Conn *c) {
+    c->executing = false;
+    if (c->released) {
+        free_conn(c);
+    } else if (c->detach_after) {
+        c->detach_after = false;
+        detach_conn(c);
+    }
+}
+
 /* 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 && c->failed != HPE_OK && n > 0 && !c->executing) {
+        /* a parser that failed fails again on what follows, with those bytes (Node's execute) */
+        c->executing = true;
+        parse_error(c, c->failed, bytes, (size_t)n);
+        read_done(c);
+        return true;
+    }
     if (c->detached) return false;
     c->executing = true;
     if (n < 0) {
@@ -280,10 +318,9 @@ static bool parse_input(Conn *c, ssize_t n, const char *bytes) {
             /* a request cut short is the server's parse error; a client's response cut short shows
              * as its 'aborted', when the socket closes (as Node's socketOnEnd ignores finish()) */
             llhttp_errno_t e = llhttp_finish(&c->parser);
-            if (e != HPE_OK && !c->detached && !c->response) parse_error(c, e);
+            if (e != HPE_OK && !c->detached && !c->response) parse_error(c, e, NULL, 0);
         }
-        c->executing = false;
-        if (c->released) free_conn(c);
+        read_done(c);
         return false;
     }
     const char *at = bytes, *end = bytes + n;
@@ -291,7 +328,7 @@ static bool parse_input(Conn *c, ssize_t n, const char *bytes) {
         llhttp_errno_t e = llhttp_execute(&c->parser, at, (size_t)(end - at));
         if (e == HPE_OK || c->detached) break;  /* released or upgraded by a callback: stop here */
         if (e != HPE_PAUSED_UPGRADE) {
-            parse_error(c, e);  /* nothing runs once a callback failed in JS: the loop is ending */
+            parse_error(c, e, bytes, (size_t)n);  /* nothing runs once a callback failed in JS: the loop is ending */
             break;
         }
         const char *pos = llhttp_get_error_pos(&c->parser);
@@ -306,8 +343,7 @@ static bool parse_input(Conn *c, ssize_t n, const char *bytes) {
         (void)js_uv_call(c->parsers->on_upgrade, 2, args, NULL);
         break;
     }
-    c->executing = false;
-    if (c->released) free_conn(c);
+    read_done(c);
     return true;
 }
 
@@ -325,7 +361,48 @@ static void hook_close(void *data) { release_conn(data); }
 
 static const JSNetHook http_hook = { hook_read, hook_close };
 
-/* httpParsers(onHead, onBody, onComplete, onUpgrade, onError) → id */
+/* ---- An idle client socket's guard --------------------------------------------------------- */
+
+/* Bytes a socket reads while it waits in an agent's pool (no request on it): a server sending what
+ * nobody asked for, which the next request would take for its response. Node's free socket data
+ * guard: the bytes are dropped and JS destroys the socket. Its end and errors go on to JS. */
+static JSValue guard_callback = JS_UNDEFINED;
+static bool guard_rooted;
+
+static bool guard_read(void *data, ssize_t n, const char *bytes) {
+    (void)bytes;
+    if (n <= 0) return false;
+    int id = (int)(intptr_t)data;
+    js_net_hook(id, NULL, NULL);
+    if (js_is_callable(guard_callback)) {
+        JSValue arg = js_int32(id);
+        js_uv_nest(1);
+        (void)js_uv_call(guard_callback, 1, &arg, NULL);
+        js_uv_nest(-1);
+        (void)js_uv_drain();
+    }
+    return true;
+}
+
+static void guard_close(void *data) { (void)data; }
+
+static const JSNetHook guard_hook = { guard_read, guard_close };
+
+/* httpGuard(conn, onData) → whether it's guarded: onData(conn) when the socket reads while idle */
+JSValue js_host_http_guard(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 < 2 || !js_is_int32(argv[0])) return JS_FALSE;
+    int id = js_as_int32(argv[0]);
+    if (id < 0 || ((size_t)id < nconns && conns[id])) return JS_FALSE;  /* a parser has it */
+    if (!guard_rooted) {
+        js_add_root(ctx->rt, &guard_callback);
+        guard_rooted = true;
+    }
+    guard_callback = argv[1];
+    return js_bool(js_net_hook(id, &guard_hook, (void *)(intptr_t)id));
+}
+
+/* httpParsers(onHead, onBody, onComplete, onUpgrade, onError, onDrain) → id */
 JSValue js_host_http_parsers(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 < 5) return js_throw_type_error(ctx, "httpParsers: 5 arguments expected");
@@ -345,8 +422,9 @@ JSValue js_host_http_parsers(JSContext *ctx, JSValue callee, JSValue this_val, u
     Parsers *p = malloc(sizeof *p);
     if (!p) js_fatal("out of memory in http");
     p->on_request = argv[0], p->on_body = argv[1], p->on_complete = argv[2], p->on_upgrade = argv[3], p->on_error = argv[4];
+    p->on_drain = argc > 5 ? argv[5] : JS_UNDEFINED;
     js_add_root(ctx->rt, &p->on_request), js_add_root(ctx->rt, &p->on_body), js_add_root(ctx->rt, &p->on_complete);
-    js_add_root(ctx->rt, &p->on_upgrade), js_add_root(ctx->rt, &p->on_error);
+    js_add_root(ctx->rt, &p->on_upgrade), js_add_root(ctx->rt, &p->on_error), js_add_root(ctx->rt, &p->on_drain);
     Parsers **v = realloc(parsers, (nparsers + 1) * sizeof *v);
     if (!v) js_fatal("out of memory in http");
     parsers = v;
@@ -395,18 +473,43 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     return js_int32(0);
 }
 
-/* httpDetach(conn): the socket's bytes go to JS again (its corked output goes first) */
+/* httpDetach(conn, afterRead): the socket's bytes go to JS again (its corked output goes first);
+ * with afterRead, from a parser callback, once llhttp is done with the read, as Node's client frees
+ * its parser after the read (what follows a response in it is still parsed) */
 JSValue js_host_http_detach(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)ctx, (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) {
-        if (c->queued) flush_conn(c);
-        if (c->id >= 0) js_net_hook(c->id, NULL, NULL);
-        release_conn(c);
-    }
+    if (!c) return JS_UNDEFINED;
+    if (argc > 1 && js_truthy(argv[1]) && c->executing) c->detach_after = true;
+    else detach_conn(c);
     return JS_UNDEFINED;
 }
 
+/* httpBusy(conn): whether a message is under way on the connection (begun, not complete), as Node's
+ * ConnectionsList tells an idle connection from an active one */
+JSValue js_host_http_busy(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (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;
+    return js_bool(c && c->in_message && !c->detached);
+}
+
+/* httpPending(conn) → the bytes written to it that haven't gone out yet (a response's backpressure) */
+JSValue js_host_http_pending(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (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;
+    return js_number(c ? (double)pending_bytes(c) : 0);
+}
+
+/* httpWatchDrain(conn) → true when nothing is pending (drained already), else the parsers' onDrain
+ * is called once it all has gone out */
+JSValue js_host_http_watch_drain(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (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 || pending_bytes(c) == 0) return JS_TRUE;
+    c->need_drain = true;
+    return JS_FALSE;
+}
+
 /* httpExpired(parsers, headersTimeout, requestTimeout) → the connections over time, as Node's
  * ConnectionsList::Expired: a head not complete within headersTimeout, or a request not
  * complete within requestTimeout, from its start (or the connection's); 0 turns one off */
@@ -436,13 +539,30 @@ JSValue js_host_http_expired(JSContext *ctx, JSValue callee, JSValue this_val, u
 typedef struct WriteReq {
     uv_write_t req;
     char      *data;
+    int        id;  /* the connection's: whether its output has drained, once written */
 } WriteReq;
 
+/* bytes written to the connection but not yet sent: corked, or in libuv's write queue */
+static size_t pending_bytes(Conn *c) {
+    uv_stream_t *s = c->id >= 0 ? js_net_stream(c->id) : NULL;
+    return c->out.n + (s ? uv_stream_get_write_queue_size(s) : 0);
+}
+
 static void on_written(uv_write_t *req, int status) {
     (void)status;  /* a failed write shows as the socket's read error, or its close */
     WriteReq *w = (WriteReq *)req;
+    int id = w->id;
     free(w->data);
     free(w);
+    /* JS waited for the output to drain (Node's 'drain' on the response) */
+    Conn *c = conn_of(id);
+    if (c && c->need_drain && pending_bytes(c) == 0) {
+        c->need_drain = false;
+        if (js_is_callable(c->parsers->on_drain)) {
+            JSValue arg = js_int32(id);
+            (void)js_uv_call(c->parsers->on_drain, 1, &arg, NULL);
+        }
+    }
 }
 
 /* Sends a connection's corked output as one write. */
@@ -465,6 +585,7 @@ static void flush_conn(Conn *c) {
     WriteReq *w = malloc(sizeof *w);
     if (!w) js_fatal("out of memory in http");
     w->data = c->out.v;  /* the buffer goes with the write; the connection starts a new one */
+    w->id = c->id;
     uv_buf_t b = uv_buf_init(c->out.v, (unsigned)c->out.n);
     c->out = (Buf){ 0 };
     if (uv_write(&w->req, s, &b, 1, on_written) < 0) {
@@ -488,12 +609,20 @@ static void flush_pending(void) {
     }
 }
 
-/* httpWrite(conn, data): corked until the current callback (and its microtasks) returns */
+/* httpWrite(conn, data, latin1): corked until the current callback (and its microtasks) returns; a
+ * string as UTF-8, or with latin1 a byte a character (its low byte), as Node writes a head */
 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 || (c->id >= 0 && !js_net_stream(c->id))) return JS_FALSE;
-    if (js_is_string(argv[1])) {
+    if (js_is_string(argv[1]) && argc > 2 && js_truthy(argv[2])) {
+        JSStrView v = js_string_view(ctx, argv[1]);
+        if (v.length == 0) return JS_TRUE;
+        buf_reserve(&c->out, v.length);
+        if (v.latin1) memcpy(c->out.v + c->out.n, v.chars, v.length);
+        else for (uint32_t i = 0; i < v.length; i++) c->out.v[c->out.n + i] = (char)(js_view_at(v, i) & 0xff);
+        c->out.n += v.length;
+    } else if (js_is_string(argv[1])) {
         JSStrView v = js_string_view(ctx, argv[1]);
         size_t n = js_view_to_utf8(v, NULL, 0);
         if (n == 0) return JS_TRUE;
@@ -555,7 +684,8 @@ JSValue js_host_http_fed_open(JSContext *ctx, JSValue callee, JSValue this_val,
 /* 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;
+    /* a fed connection's bytes; or a socket's that JS read before the parser took the socket */
+    Conn *c = argc > 0 && js_is_int32(argv[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) */

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,11 +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>
 
@@ -122,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;
@@ -134,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. */
@@ -187,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;
@@ -194,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);
@@ -253,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);
@@ -454,6 +476,50 @@ 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;

package/node/src/host_sys.c

@@ -19,6 +19,7 @@
 #include "jscontext.h"
 #include "js_ops.h"
 #include "jsstring.h"
+#include "js_uv.h"
 
 /* Each error by its C errno and its libuv code: the same number on POSIX, but on Windows libuv
  * has codes of its own (UV_ECONNREFUSED is -4078) while the C library's errno has the C values. */
@@ -155,6 +156,14 @@ JSValue js_host_timer_unref(JSContext *ctx, JSValue callee, JSValue this_val, ui
     return js_int32((int32_t)js_add_timer(ctx, argv[0], js_as_number(argv[1]), true));
 }
 
+/* loopNow() → libuv's time in ms, as of the last poll (Node's getLibuvNow): what a socket's
+ * activity is measured with, without a clock read or an allocation per read and write */
+JSValue js_host_loop_now(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;
+    return js_number((double)uv_now(js_uv_loop(ctx)));
+}
+
 /* the id a timer primitive takes: a positive int32, else 0 */
 static uint32_t timer_id(uint32_t argc, const JSValue *argv, uint32_t i) {
     return i < argc && js_is_int32(argv[i]) && js_as_int32(argv[i]) > 0 ? (uint32_t)js_as_int32(argv[i]) : 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "visaljs",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Ahead-of-time JavaScript to C compiler: the command line",
   "license": "MIT",
   "repository": {

package/runtime/include/js_atoms.h

@@ -22,6 +22,10 @@ typedef struct JSRuntime JSRuntime;
 typedef struct JSAtomTable {
     struct JSAtomEntry { JSString *str; uint32_t hash; } *entries;  /* open addressing; str NULL = empty */
     size_t cap, count;
+    /* The atoms added since the last collection: the only ones a young collection can find dead,
+     * since an old cell stays marked until a full collection. malloc'd. */
+    JSString **young;
+    size_t young_count, young_cap;
 } JSAtomTable;
 
 /* ---- The runtime's predefined atoms ------------------------------------ */