visaljs 0.0.1 → 0.0.3

package/node/src/host_http.c

@@ -1,21 +1,29 @@
-/* Host primitives for node:http (ADR 0012, host prelude): TCP servers on libuv, requests
- * parsed by llhttp (Node's parser), and the event loop's I/O backend. The prelude's http.js
- * builds Node's objects over them; C does the per-byte work: accepting, reading, parsing,
- * writing. Connections are numbered: C holds no JS objects but each server's callbacks (roots).
+/* Host primitives for node:http (ADR 0012, host prelude): 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
+ * per-byte work: parsing and writing. Connections are numbered by their net handle's id.
  *
- *   httpListen(host, port, backlog, onRequest, onBody, onComplete, onClose) → server id | -errno
- *     onRequest(conn, method, url, headers [k, v, …], major, minor, keepAlive)
+ *   httpParsers(onHead, onBody, onComplete, onUpgrade, onError) → parsers id (a server's, a client's)
+ *     onHead(conn, method | status, url | statusMessage, headers [k, v, …], major, minor, keepAlive, upgrade)
+ *                              → 0, or 1 when the message has no body (a response to HEAD), or 2
+ *                              to take the socket after the head (an upgrade, CONNECT): the parser
+ *                              lets go of it, and onUpgrade(conn, head) follows with the bytes
+ *                              after the head; an upgrade not taken parses on
  *     onBody(conn, chunk)      a Uint8Array (the prelude makes it a Buffer)
- *     onComplete(conn)         the request's end
- *     onClose(conn)            the connection is gone
- *   httpAddress(server) → [address, family, port];  httpCloseServer(server)
+ *     onComplete(conn, trailers)   the message's end; its trailers [k, v, …], or undefined
+ *     onError(conn, code, reason)  a parse error ("HPE_INVALID_METHOD", …); parsing stops
+ *   httpAttach(conn, parsers, response, maxHeaderSize) → 0 | -errno   the socket's bytes go to a
+ *                              request (or with `response`, a response) parser from now on
+ *   httpDetach(conn)           the socket's bytes go to JS again
+ *   httpExpired(parsers, headersTimeout, requestTimeout) → [conn, …]: the connections whose
+ *                              request (or its head) has taken longer, as Node's connectionsList
  *   httpWrite(conn, data)      a string (written as UTF-8) or a Uint8Array, corked: what a callback
  *                              writes goes out in one write when it (and its microtasks) returns
- *   httpEnd(conn, close)       after the writes: shut the connection down when `close` */
+ *   httpFlush(conn)            sends the corked output now (before the socket is ended)
+ *   httpDate() → the Date header's value
+ * 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 */
-#ifndef _WIN32
-#include <signal.h>
-#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -23,112 +31,62 @@
 
 #include "js_atoms.h"
 #include "js_buffer.h"
-#include "js_console.h"
 #include "js_convert.h"
 #include "js_exception.h"
+#include "js_gc.h"
 #include "js_node.h"
-#include "js_jobs.h"
 #include "js_ops.h"
+#include "js_uv.h"
 #include "jscontext.h"
 #include "jsstring.h"
 #include "llhttp.h"
-#include "uv.h"
-
-/* ---- The I/O backend (ADR 0008) ---------------------------------------------------------- */
-
-static uv_loop_t *loop;
-static uv_timer_t wake;      /* ends uv_run at the next timer's deadline; unref'd */
-static JSContext *loop_ctx;  /* the realm callbacks run in */
-static int failed;           /* exit status after an uncaught error in a callback */
-
-static void on_wake(uv_timer_t *t) { (void)t; }
 
 static void flush_pending(void);
+typedef struct Conn Conn;
+static void flush_conn(Conn *c);
 
-static bool io_alive(JSRuntime *rt) {
-    (void)rt;
-    return !failed && uv_loop_alive(loop);
-}
+/* ---- Parsers and connections ------------------------------------------------------------- */
 
-static int io_run(JSContext *ctx, int64_t timeout_ms) {
-    loop_ctx = ctx;
-    flush_pending();  /* what timers wrote, before waiting */
-    if (timeout_ms >= 0) uv_timer_start(&wake, on_wake, (uint64_t)timeout_ms, 0);
-    uv_run(loop, UV_RUN_ONCE);
-    uv_timer_stop(&wake);
-    return failed;
-}
-
-static const JSIOBackend uv_backend = { io_alive, io_run };
-
-static void ensure_loop(JSContext *ctx) {
-    if (loop) return;
-    loop = uv_default_loop();
-#ifndef _WIN32
-    /* a write to a connection the peer closed fails with EPIPE instead of killing the process,
-     * as in Node (which ignores SIGPIPE at startup) */
-    signal(SIGPIPE, SIG_IGN);
-#endif
-    uv_timer_init(loop, &wake);
-    uv_unref((uv_handle_t *)&wake);
-    loop_ctx = ctx;
-    ctx->rt->io = &uv_backend;
-}
-
-/* Calls a JS callback from an I/O callback, then the microtasks, as Node's MakeCallback does;
- * an uncaught error ends the loop with its status. */
-static void call_js(JSValue fn, uint32_t argc, JSValue *argv) {
-    if (failed) return;
-    JSContext *ctx = loop_ctx;
-    JSValue r = js_call(ctx, fn, JS_UNDEFINED, argc, argv);
-    if (js_is_exception(r)) {
-        failed = js_report_uncaught(ctx);
-        if (!failed) failed = 1;
-        uv_stop(loop);
-        return;
-    }
-    if (js_run_microtasks(ctx) < 0) {
-        failed = 1;
-        uv_stop(loop);
-    }
-    flush_pending();  /* what the callback and its microtasks wrote: one write per connection */
-}
-
-/* ---- Servers and connections ------------------------------------------------------------- */
-
-typedef struct Server {
-    uv_tcp_t handle;
-    JSValue  on_request, on_body, on_complete, on_close;  /* roots */
-    int      id;
-    bool     closed;
-} Server;
+typedef struct Parsers {
+    JSValue on_request, on_body, on_complete, on_upgrade, on_error;  /* roots */
+} Parsers;
 
 typedef struct Buf {
     char  *v;
     size_t n, cap;
 } Buf;
 
-typedef struct Conn {
-    uv_tcp_t      handle;
-    llhttp_t      parser;
-    Server       *server;
-    int           id;
-    bool          closing;
-    Buf           url, field, value;
-    JSValue       headers;  /* the request being parsed: an array (a root while parsing) */
-    bool          in_value;
-    bool          queued;   /* in `pending`: `out` goes out at the next flush */
-    Buf           out;      /* written but not sent: corked, as Node corks a response */
-} Conn;
-
-static Server **servers;
-static size_t nservers;
-static Conn **conns;
+struct Conn {
+    llhttp_t parser;
+    Parsers *parsers;
+    int      id;         /* the net handle's */
+    bool     response;   /* a client's: it parses responses */
+    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     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     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;
+    Buf      url, field, value;  /* url: a response's status message */
+    JSValue  headers;    /* the head's or the trailers' [k, v, …] being parsed (a root) */
+    bool     in_value;
+    bool     queued;     /* in `pending`: `out` goes out at the next flush */
+    Buf      out;        /* written but not sent: corked, as Node corks a response */
+};
+
+static Parsers **parsers;
+static size_t nparsers;
+static Conn **conns;   /* by net handle id */
 static size_t nconns;
-static int *pending;  /* ids of connections with corked output */
+static int *pending;   /* ids of connections with corked output */
 static size_t npending, pending_cap;
 static llhttp_settings_t settings;
 
+static JSContext *ctx_(void) { return js_uv_context(); }
+
 /* Room for n more bytes (and the NUL). */
 static void buf_reserve(Buf *b, size_t n) {
     if (b->n + n + 1 > b->cap) {
@@ -151,8 +109,19 @@ static void buf_append(Buf *b, const char *s, size_t n) {
 /* Header bytes as a string: Latin-1, as Node reads them. */
 static JSValue latin1(JSContext *ctx, const Buf *b) { return js_new_string_latin1(ctx, (const uint8_t *)(b->v ? b->v : ""), (uint32_t)b->n); }
 
+static JSValue bytes_value(JSContext *ctx, const char *at, size_t n) {
+    JSValue chunk = js_new_uint8_array(ctx, n);
+    if (js_is_exception(chunk)) js_fatal("out of memory in http");
+    uint8_t *data;
+    size_t len;
+    js_buffer_source_bytes(chunk, &data, &len);
+    if (n) memcpy(data, at, n);
+    return chunk;
+}
+
 static void push_header(Conn *c) {
-    JSContext *ctx = loop_ctx;
+    JSContext *ctx = ctx_();
+    if (js_is_undefined(c->headers)) c->headers = js_new_array(ctx, 0);  /* the first trailer */
     JSValue k = latin1(ctx, &c->field), v = latin1(ctx, &c->value);
     if (js_array_push(ctx, js_as_object(c->headers), k) < 0 || js_array_push(ctx, js_as_object(c->headers), v) < 0) js_fatal("out of memory in http");
     c->field.n = c->value.n = 0;
@@ -161,230 +130,269 @@ static void push_header(Conn *c) {
 
 static int on_message_begin(llhttp_t *p) {
     Conn *c = p->data;
+    if (c->detached) return -1;  /* let go of by an earlier callback */
     c->url.n = c->field.n = c->value.n = 0;
     c->in_value = false;
-    c->headers = js_new_array(loop_ctx, 0);
+    c->headers = js_new_array(ctx_(), 0);
+    c->active = true;
+    c->head_done = false;
+    c->header_bytes = 0;
+    c->begin_ms = uv_now(js_uv_loop(ctx_()));
     return 0;
 }
 
-static int on_url(llhttp_t *p, const char *at, size_t n) {
-    buf_append(&((Conn *)p->data)->url, at, n);
+/* Node's maxHeaderSize: the head's bytes so far (the URL and the header lines) */
+static int count_head(Conn *c, size_t n) {
+    if (c->head_done) return 0;
+    c->header_bytes += n;
+    if (c->max_header && c->header_bytes > c->max_header) {
+        c->overflow = true;
+        return -1;
+    }
     return 0;
 }
 
+static int on_url(llhttp_t *p, const char *at, size_t n) {
+    Conn *c = p->data;
+    buf_append(&c->url, at, n);
+    return count_head(c, n);
+}
+
 static int on_header_field(llhttp_t *p, const char *at, size_t n) {
     Conn *c = p->data;
     if (c->in_value) push_header(c);
     buf_append(&c->field, at, n);
-    return 0;
+    return count_head(c, n);
 }
 
 static int on_header_value(llhttp_t *p, const char *at, size_t n) {
     Conn *c = p->data;
     c->in_value = true;
     buf_append(&c->value, at, n);
-    return 0;
+    return count_head(c, n);
 }
 
+/* The head: JS makes the request (or response); it says whether the message has a body (1:
+ * none) and whether it takes the socket (2: llhttp pauses after the head). */
 static int on_headers_complete(llhttp_t *p) {
     Conn *c = p->data;
-    JSContext *ctx = loop_ctx;
+    if (c->detached) return -1;  /* let go of by an earlier callback */
+    JSContext *ctx = ctx_();
     if (c->in_value || c->field.n) push_header(c);
-    JSValue args[7] = {
-        js_int32(c->id), js_new_string_cstr(ctx, llhttp_method_name((llhttp_method_t)llhttp_get_method(p))), latin1(ctx, &c->url),
-        c->headers, js_int32(llhttp_get_http_major(p)), js_int32(llhttp_get_http_minor(p)), js_bool(llhttp_should_keep_alive(p)),
+    c->head_done = true;
+    JSValue first = c->response ? js_int32(llhttp_get_status_code(p))
+                                : js_new_string_cstr(ctx, llhttp_method_name((llhttp_method_t)llhttp_get_method(p)));
+    JSValue args[8] = {
+        js_int32(c->id), first, latin1(ctx, &c->url), c->headers, js_int32(llhttp_get_http_major(p)), js_int32(llhttp_get_http_minor(p)),
+        js_bool(llhttp_should_keep_alive(p)), js_bool(p->upgrade),
     };
     c->headers = JS_UNDEFINED;
-    call_js(c->server->on_request, 7, args);
-    return 0;
+    JSValue r = JS_UNDEFINED;
+    if (!js_uv_call(c->parsers->on_request, 8, args, &r)) return -1;
+    int skip = js_is_int32(r) ? js_as_int32(r) : 0;
+    if (skip == 2) c->upgrading = true;
+    return skip == 1 || skip == 2 ? skip : 0;
 }
 
 static int on_body(llhttp_t *p, const char *at, size_t n) {
     Conn *c = p->data;
-    JSValue chunk = js_new_uint8_array(loop_ctx, n);
-    if (js_is_exception(chunk)) return HPE_USER;
-    uint8_t *data;
-    size_t len;
-    js_buffer_source_bytes(chunk, &data, &len);
-    if (n) memcpy(data, at, n);
-    JSValue args[2] = { js_int32(c->id), chunk };
-    call_js(c->server->on_body, 2, args);
-    return 0;
+    if (c->detached) return -1;  /* let go of by an earlier callback */
+    JSValue args[2] = { js_int32(c->id), bytes_value(ctx_(), at, n) };
+    return js_uv_call(c->parsers->on_body, 2, args, NULL) ? 0 : -1;
 }
 
 static int on_message_complete(llhttp_t *p) {
     Conn *c = p->data;
-    JSValue args[1] = { js_int32(c->id) };
-    call_js(c->server->on_complete, 1, args);
-    return 0;
+    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;
+    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;
 }
 
-static void on_conn_closed(uv_handle_t *h) {
-    Conn *c = (Conn *)h;
-    JSValue args[1] = { js_int32(c->id) };
-    conns[c->id] = NULL;
-    call_js(c->server->on_close, 1, args);
-    js_remove_root(loop_ctx->rt, &c->headers);
-    free(c->url.v), free(c->field.v), free(c->value.v), free(c->out.v);
-    free(c);
-}
+static Conn *conn_of(int id) { return id >= 0 && (size_t)id < nconns ? conns[id] : NULL; }
 
-static void close_conn(Conn *c) {
-    if (c->closing) return;
-    c->closing = true;
-    uv_close((uv_handle_t *)&c->handle, on_conn_closed);
+static void parse_error(Conn *c, llhttp_errno_t e) {
+    c->detached = true;
+    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);
 }
 
-static void on_alloc(uv_handle_t *h, size_t suggested, uv_buf_t *buf) {
-    (void)h;
-    buf->base = malloc(suggested);
-    buf->len = buf->base ? suggested : 0;
+static void free_conn(Conn *c) {
+    js_remove_root(ctx_()->rt, &c->headers);
+    free(c->url.v), free(c->field.v), free(c->value.v), free(c->out.v);
+    free(c);
 }
 
-static const char BAD_REQUEST[] = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n";
-
-static void on_read(uv_stream_t *s, ssize_t n, const uv_buf_t *buf) {
-    Conn *c = (Conn *)s;
-    if (n > 0 && !c->closing) {
-        llhttp_errno_t e = llhttp_execute(&c->parser, buf->base, (size_t)n);
-        if (e != HPE_OK && e != HPE_PAUSED_UPGRADE && !c->closing) {
-            uv_buf_t b = uv_buf_init((char *)BAD_REQUEST, sizeof BAD_REQUEST - 1);
-            uv_try_write(s, &b, 1);
-            close_conn(c);
-        }
-    } else if (n < 0) {
-        close_conn(c);  /* EOF or an error */
-    }
-    free(buf->base);
+/* The connection's parser is done with (detached, replaced, or the socket closed): freed now, or
+ * 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;
+    c->detached = true;
+    if (c->executing) c->released = true;
+    else free_conn(c);
 }
 
-static void on_connection(uv_stream_t *listener, int status) {
-    if (status < 0) return;
-    Server *srv = (Server *)listener;
-    Conn *c = calloc(1, sizeof *c);
-    if (!c) js_fatal("out of memory in http");
-    uv_tcp_init(loop, &c->handle);
-    if (uv_accept(listener, (uv_stream_t *)&c->handle) < 0) {
-        uv_close((uv_handle_t *)&c->handle, (uv_close_cb)free);
-        return;
+/* 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;
+    if (c->detached) return false;
+    c->executing = true;
+    if (n < 0) {
+        if (n == UV_EOF) {
+            /* 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);
+        }
+        c->executing = false;
+        if (c->released) free_conn(c);
+        return false;
     }
-    uv_tcp_nodelay(&c->handle, 1);
-    c->server = srv;
-    c->headers = JS_UNDEFINED;
-    js_add_root(loop_ctx->rt, &c->headers);
-    size_t id = 0;
-    while (id < nconns && conns[id]) id++;
-    if (id == nconns) {
-        size_t n = nconns ? nconns * 2 : 64;
-        Conn **v = realloc(conns, n * sizeof *v);
-        if (!v) js_fatal("out of memory in http");
-        memset(v + nconns, 0, (n - nconns) * sizeof *v);
-        conns = v;
-        nconns = n;
+    const char *at = bytes, *end = bytes + n;
+    while (at < end && !c->detached) {
+        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 */
+            break;
+        }
+        const char *pos = llhttp_get_error_pos(&c->parser);
+        if (!c->upgrading) {  /* an upgrade JS didn't take: the request was an ordinary one */
+            llhttp_resume_after_upgrade(&c->parser);
+            at = pos;
+            continue;
+        }
+        /* the socket is JS's from here: what it reads next goes to its stream, as in Node */
+        c->detached = true;
+        JSValue args[2] = { js_int32(c->id), bytes_value(ctx_(), pos, (size_t)(end - pos)) };
+        (void)js_uv_call(c->parsers->on_upgrade, 2, args, NULL);
+        break;
     }
-    conns[id] = c;
-    c->id = (int)id;
-    llhttp_init(&c->parser, HTTP_REQUEST, &settings);
-    c->parser.data = c;
-    uv_read_start((uv_stream_t *)&c->handle, on_alloc, on_read);
+    c->executing = false;
+    if (c->released) free_conn(c);
+    return true;
 }
 
-static Conn *conn_arg(uint32_t argc, const JSValue *argv) {
-    if (argc == 0 || !js_is_int32(argv[0])) return NULL;
-    int32_t id = js_as_int32(argv[0]);
-    return id >= 0 && (size_t)id < nconns ? conns[id] : NULL;
-}
+static void hook_close(void *data) { release_conn(data); }
 
-static Server *server_arg(uint32_t argc, const JSValue *argv) {
-    if (argc == 0 || !js_is_int32(argv[0])) return NULL;
-    int32_t id = js_as_int32(argv[0]);
-    return id >= 0 && (size_t)id < nservers ? servers[id] : NULL;
-}
+static const JSNetHook http_hook = { hook_read, hook_close };
 
-/* httpListen(host, port, backlog, onRequest, onBody, onComplete, onClose) */
-JSValue js_host_http_listen(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+/* httpParsers(onHead, onBody, onComplete, onUpgrade, onError) → 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 < 7) return js_throw_type_error(ctx, "httpListen: 7 arguments expected");
-    ensure_loop(ctx);
+    if (argc < 5) return js_throw_type_error(ctx, "httpParsers: 5 arguments expected");
     if (!settings.on_message_begin) {
         llhttp_settings_init(&settings);
         settings.on_message_begin = on_message_begin;
         settings.on_url = on_url;
+        settings.on_status = on_url;  /* a response's status message, where a request's URL goes */
         settings.on_header_field = on_header_field;
         settings.on_header_value = on_header_value;
         settings.on_headers_complete = on_headers_complete;
         settings.on_body = on_body;
         settings.on_message_complete = on_message_complete;
+        (void)js_uv_loop(ctx);
+        js_uv_set_flush(flush_pending);
     }
-    char host[64] = "::";
-    if (js_is_string(argv[0])) host[js_view_to_utf8(js_string_view(ctx, argv[0]), host, sizeof host - 1)] = '\0';
-    double port = 0, backlog = 511;
-    if (js_to_number(ctx, &port, argv[1]) < 0 || js_to_number(ctx, &backlog, argv[2]) < 0) return JS_EXCEPTION;
-    struct sockaddr_storage addr;
-    int r = strchr(host, ':') ? uv_ip6_addr(host, (int)port, (struct sockaddr_in6 *)&addr) : uv_ip4_addr(host, (int)port, (struct sockaddr_in *)&addr);
-    if (r < 0) return js_int32(r);
-    Server *srv = calloc(1, sizeof *srv);
-    if (!srv) js_fatal("out of memory in http");
-    uv_tcp_init(loop, &srv->handle);
-    r = uv_tcp_bind(&srv->handle, (const struct sockaddr *)&addr, 0);
-    if (r == 0) r = uv_listen((uv_stream_t *)&srv->handle, (int)backlog, on_connection);
-    if (r < 0) {
-        uv_close((uv_handle_t *)&srv->handle, (uv_close_cb)free);
-        return js_int32(r);
-    }
-    srv->on_request = argv[3], srv->on_body = argv[4], srv->on_complete = argv[5], srv->on_close = argv[6];
-    js_add_root(ctx->rt, &srv->on_request), js_add_root(ctx->rt, &srv->on_body);
-    js_add_root(ctx->rt, &srv->on_complete), js_add_root(ctx->rt, &srv->on_close);
-    Server **v = realloc(servers, (nservers + 1) * sizeof *v);
+    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];
+    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);
+    Parsers **v = realloc(parsers, (nparsers + 1) * sizeof *v);
     if (!v) js_fatal("out of memory in http");
-    servers = v;
-    srv->id = (int)nservers;
-    servers[nservers++] = srv;
-    return js_int32(srv->id);
+    parsers = v;
+    parsers[nparsers] = p;
+    return js_int32((int32_t)nparsers++);
 }
 
-/* httpAddress(server) → [address, family, port] */
-JSValue js_host_http_address(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+/* httpAttach(conn, parsers, response, maxHeaderSize) → 0 | -errno: a new parser for the socket */
+JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)new_target;
-    Server *srv = server_arg(argc, argv);
-    if (!srv || srv->closed) return JS_NULL;
-    struct sockaddr_storage addr;
-    int len = sizeof addr;
-    if (uv_tcp_getsockname(&srv->handle, (struct sockaddr *)&addr, &len) < 0) return JS_NULL;
-    char name[64] = "";
-    int port;
-    const char *family;
-    if (addr.ss_family == AF_INET6) {
-        uv_ip6_name((struct sockaddr_in6 *)&addr, name, sizeof name);
-        port = ntohs(((struct sockaddr_in6 *)&addr)->sin6_port);
-        family = "IPv6";
-    } else {
-        uv_ip4_name((struct sockaddr_in *)&addr, name, sizeof name);
-        port = ntohs(((struct sockaddr_in *)&addr)->sin_port);
-        family = "IPv4";
+    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) {
+        size_t n = nconns ? nconns : 64;
+        while (n <= (size_t)id) n *= 2;
+        Conn **v = realloc(conns, n * sizeof *v);
+        if (!v) js_fatal("out of memory in http");
+        memset(v + nconns, 0, (n - nconns) * sizeof *v);
+        conns = v;
+        nconns = n;
     }
-    JSValue items[3] = { js_new_string_cstr(ctx, name), js_new_string_cstr(ctx, family), js_int32(port) };
-    return js_new_array_from(ctx, items, 3);
+    if (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;
+    c->parsers = parsers[pi];
+    c->response = argc > 2 && js_truthy(argv[2]);
+    c->max_header = argc > 3 && js_is_int32(argv[3]) && js_as_int32(argv[3]) > 0 ? (size_t)js_as_int32(argv[3]) : 0;
+    c->headers = JS_UNDEFINED;
+    c->active = true;  /* a new connection's first request is timed from now */
+    c->begin_ms = uv_now(js_uv_loop(ctx));
+    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);
+    return js_int32(0);
 }
 
-/* httpCloseServer(server): stops listening */
-JSValue js_host_http_close_server(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+/* httpDetach(conn): the socket's bytes go to JS again (its corked output goes first) */
+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;
-    Server *srv = server_arg(argc, argv);
-    if (srv && !srv->closed) {
-        srv->closed = true;
-        uv_close((uv_handle_t *)&srv->handle, NULL);  /* its callbacks stay rooted: requests may still finish */
+    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);
+        release_conn(c);
     }
     return JS_UNDEFINED;
 }
 
+/* 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 */
+JSValue js_host_http_expired(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 < 3 || !js_is_int32(argv[0])) return js_throw_type_error(ctx, "httpExpired: (parsers, headersTimeout, requestTimeout) expected");
+    int32_t pi = js_as_int32(argv[0]);
+    double headers_timeout = 0, request_timeout = 0;
+    if (js_to_number(ctx, &headers_timeout, argv[1]) < 0 || js_to_number(ctx, &request_timeout, argv[2]) < 0) return JS_EXCEPTION;
+    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];
+        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)) {
+            c->active = false;
+            if (js_array_push(ctx, js_as_object(list), js_int32(c->id)) < 0) return JS_EXCEPTION;
+        }
+    }
+    return list;
+}
+
+/* ---- Writing ----------------------------------------------------------------------------- */
+
 typedef struct WriteReq {
     uv_write_t req;
     char      *data;
 } WriteReq;
 
 static void on_written(uv_write_t *req, int status) {
-    (void)status;
+    (void)status;  /* a failed write shows as the socket's read error, or its close */
     WriteReq *w = (WriteReq *)req;
     free(w->data);
     free(w);
@@ -393,13 +401,17 @@ 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;
-    if (c->closing || c->out.n == 0) return;
+    uv_stream_t *s = js_net_stream(c->id);
+    if (!s || c->out.n == 0) {
+        c->out.n = 0;
+        return;
+    }
     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 */
     uv_buf_t b = uv_buf_init(c->out.v, (unsigned)c->out.n);
     c->out = (Buf){ 0 };
-    if (uv_write(&w->req, (uv_stream_t *)&c->handle, &b, 1, on_written) < 0) {
+    if (uv_write(&w->req, s, &b, 1, on_written) < 0) {
         free(w->data);
         free(w);
     }
@@ -407,8 +419,8 @@ static void flush_conn(Conn *c) {
 
 static void flush_pending(void) {
     for (size_t i = 0; i < npending; i++) {
-        int id = pending[i];
-        if (id >= 0 && (size_t)id < nconns && conns[id] && conns[id]->queued) flush_conn(conns[id]);
+        Conn *c = conn_of(pending[i]);
+        if (c && c->queued) flush_conn(c);
     }
     npending = 0;
 }
@@ -416,8 +428,8 @@ static void flush_pending(void) {
 /* 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 = conn_arg(argc, argv);
-    if (!c || c->closing || argc < 2) return JS_FALSE;
+    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 (js_is_string(argv[1])) {
         JSStrView v = js_string_view(ctx, argv[1]);
         size_t n = js_view_to_utf8(v, NULL, 0);
@@ -445,25 +457,11 @@ JSValue js_host_http_write(JSContext *ctx, JSValue callee, JSValue this_val, uin
     return JS_TRUE;
 }
 
-static void on_shutdown(uv_shutdown_t *req, int status) {
-    (void)status;
-    Conn *c = (Conn *)req->handle;
-    free(req);
-    close_conn(c);
-}
-
-/* httpEnd(conn, close): the response is written; with `close`, shut the connection down after it */
-JSValue js_host_http_end(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+/* httpFlush(conn): the corked output goes out now, ahead of what the socket writes next */
+JSValue js_host_http_flush(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 = conn_arg(argc, argv);
-    if (!c || c->closing || argc < 2 || !js_truthy(argv[1])) return JS_UNDEFINED;
-    if (c->queued) flush_conn(c);  /* the response goes out before the shutdown */
-    uv_shutdown_t *req = malloc(sizeof *req);
-    if (!req) js_fatal("out of memory in http");
-    if (uv_shutdown(req, (uv_stream_t *)&c->handle, on_shutdown) < 0) {
-        free(req);
-        close_conn(c);
-    }
+    Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
+    if (c && c->queued) flush_conn(c);
     return JS_UNDEFINED;
 }