@ai-ecoverse/slicc-kernel 1.154.3 → 1.155.0

package/README.md

@@ -453,7 +453,7 @@ The module's default export (or its `main` export) is called with a context and
 - `wait(pid, { untraced })` resolves with `{ status }` once a child ends, or `{ status: 128 + signal, signal }` when a signal ended it, without blocking the program; with `untraced: true` it also resolves when the child stops, with `{ status: 128 + signal, signal, stopped: true }`, as `waitpid` with `WUNTRACED` (a child's `wait({ untraced })` is the same), and options that aren't an object are `EINVAL`; `kill(pid, signal)` signals any process, by number or as `'SIGTERM'` (the default);
 - `sudo(args)`, what the [`sudo`](#sudo) command calls: `args` are its arguments after `sudo`, and it resolves with `{ pid }`, the command the kernel started as the program's child, to `wait` for; `{ run }`, an argv to run as the caller (with `users: 'off'`); `{ list }`, the text of `sudo -l`; or `{ error, errno }`, the message to print;
 - `crontab({ action, user?, text? })`, what the [`crontab`](#cron) command calls: `action` is `'list'`, `'remove'` or `'install'` (with the table as `text`), on the caller's own table or, for an effective uid of 0, on `user`'s. It resolves with `{ text }` (the table for `list`, `''` otherwise) or `{ error }`, the message to print. A malformed call is `EINVAL`;
-- `net`: `listen({ port, host, backlog })` and `connect({ host, port, signal })` (`host` defaults to `127.0.0.1`) on the kernel's loopback, the same sockets WASIX programs use, so a JS server is reached by other processes, by the page as `<port>.kernel.localhost` (`loopbackFetch`, `dial`) and by attached clients. A listener has its `port` (as bound, so port `0` picks a free one), `accept({ signal })`, `close()` and `for await` over its connections. A connection has `local` and `remote` addresses, `readable` and `writable` web streams (closing the writable shuts down the sending side, so the peer reads the end), and `close()`. The loopback is IPv4 (`127.0.0.1` by default, or `0.0.0.0`), so an IPv6 host such as `::1` fails with `EADDRNOTAVAIL` for both `listen` and `connect`, and binding and connecting fail as they would for a WASIX program (`EADDRINUSE`, `ECONNREFUSED`, `EADDRNOTAVAIL`). `sync.net.listen` takes the same options and gives the same listener, bound and listening when it returns, so its `port` is known at once, as Node's `listen()` needs ([#1398](https://github.com/ai-ecoverse/slicc-kernel/issues/1398)); it needs the sync lane. A blocked accept, read or write waits without holding anything in the kernel, so aborting it or closing the socket leaves nothing behind. A write to a connection the peer closed fails with `EPIPE` and no `SIGPIPE`;
+- `net`: `listen({ port, host, backlog })` and `connect({ host, port, signal })` (`host` defaults to `127.0.0.1`) on the kernel's loopback, the same sockets WASIX programs use, so a JS server is reached by other processes, by the page as `<port>.kernel.localhost` (`loopbackFetch`, `dial`) and by attached clients. A listener has its `port` (as bound, so port `0` picks a free one), `accept({ signal })`, `close()` and `for await` over its connections. A connection has `local` and `remote` addresses, `readable` and `writable` web streams (closing the writable shuts down the sending side, so the peer reads the end), `close()`, and `reset()`, which closes it with an RST as Node's `resetAndDestroy()` does ([#1530](https://github.com/ai-ecoverse/slicc-kernel/issues/1530)): on the kernel's loopback, the peer's pending and later reads and its writes fail with `ECONNRESET` instead of seeing the end, and bytes still in flight to it are dropped. A TLS connection (`secure()`, a `tls` connect on the loopback) resets the same way. On an uplink connection `reset()` closes at once with a FIN, as the transport can't send an RST: bytes still buffered for the peer are discarded instead of sent. The loopback is IPv4 (`127.0.0.1` by default, or `0.0.0.0`), so an IPv6 host such as `::1` fails with `EADDRNOTAVAIL` for both `listen` and `connect`, and binding and connecting fail as they would for a WASIX program (`EADDRINUSE`, `ECONNREFUSED`, `EADDRNOTAVAIL`). `sync.net.listen` takes the same options and gives the same listener, bound and listening when it returns, so its `port` is known at once, as Node's `listen()` needs ([#1398](https://github.com/ai-ecoverse/slicc-kernel/issues/1398)); it needs the sync lane. A blocked accept, read or write waits without holding anything in the kernel, so aborting it or closing the socket leaves nothing behind. A write to a connection the peer closed fails with `EPIPE` and no `SIGPIPE`;
 - `net.connect({ host, port, tls: { servername, alpn, rejectUnauthorized, ca, path, cert, key, passphrase, sni, checkHostname, keylog } })` takes one of two paths. By default it's **A1, TLS through the transport** ([#914](https://github.com/ai-ecoverse/slicc-kernel/issues/914)), described first below. For a destination the uplink routes it can also be **A2, a TLS handshake in the kernel** ([#922](https://github.com/ai-ecoverse/slicc-kernel/issues/922)), described after it. `conn.tls.path` (`'transport'` or `'kernel'`) and `conn.tls.substitutes` say which one was taken.
   - **What it does:** there's no handshake in the kernel. The connection carries plain HTTP/1.1 (and WebSocket upgrades) to the realm proxy's HTTP path for the origin `https://<servername or host>[:port]`, exactly as a `CONNECT` through `127.0.0.1:3128` does after the kernel terminates its TLS. The transport (the page's `fetch` or WebSocket, or the uplink's) makes the real TLS connection and verifies it. So `https.request` over a socket, keep-alive agents, `agent-base` and `wss://` clients work with the transport's semantics. That includes sealed placeholders in headers, which reach the transport exactly as from `ctx.fetch`.
   - **The `tls` property:** the connection's `tls` is `{ path: 'transport', substitutes: true, protocol: 'transport', alpnProtocol: 'http/1.1', authorized: true, servername }`. `authorized` means the transport verified the server. There's no peer certificate chain and no TLS version of the kernel's own, so don't read it as a real handshake's result.

package/dist/kernel-worker.js

@@ -6097,8 +6097,8 @@ function link(a, b) {
     pipe.openRead();
     pipe.openWrite();
   }
-  a.attach({ rx: ba, tx: ab });
-  b.attach({ rx: ab, tx: ba });
+  a.attach({ rx: ba, tx: ab, peer: b });
+  b.attach({ rx: ab, tx: ba, peer: a });
 }
 var SERVE_CHUNK = 64 * 1024;
 var NEVER_ABORTED = new AbortController().signal;
@@ -6110,6 +6110,8 @@ var KernelSocket = class _KernelSocket {
   dialing;
   failed;
   reset;
+  abortive = false;
+  refused;
   local;
   peer;
   peerCred;
@@ -6146,20 +6148,25 @@ var KernelSocket = class _KernelSocket {
   }
   async read(max, signal) {
     const { rx } = this.connection();
+    if (this.refused) throw this.refused;
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.read(max, signal));
+    if (this.refused) throw this.refused;
     if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
   async peek(max, signal) {
     const { rx } = this.connection();
+    if (this.refused) throw this.refused;
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.peek(max, signal));
+    if (this.refused) throw this.refused;
     if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
   async write(bytes, signal) {
     const { tx } = this.connection();
+    if (this.refused) throw this.refused;
     if (this.writeShut) throw new KernelError("EPIPE");
     if (this.reset?.code === "EPROTO") throw this.reset;
     return pipeCall(() => tx.write(bytes, signal));
@@ -6346,10 +6353,11 @@ var KernelSocket = class _KernelSocket {
       handshaking = false;
       signal.removeEventListener("abort", abandon);
     }
-    this.link = uplinkLink(made2.conn, (err) => {
+    const plain3 = uplinkLink(made2.conn, (err) => {
       this.reset = err instanceof KernelError && err.code === "EPROTO" ? err : new KernelError("ECONNRESET");
       this.changes.wake();
     });
+    this.link = { ...plain3, ...raw2.peer ? { peer: raw2.peer } : {} };
     this.changes.wake();
     return made2.info;
   }
@@ -6467,8 +6475,22 @@ var KernelSocket = class _KernelSocket {
   setOption(level, name2, value2) {
     this.options.set(`${level}:${name2}`, value2);
   }
+  resetOnClose() {
+    this.connection();
+    this.abortive = true;
+  }
+  abort() {
+    const link2 = this.link;
+    if (link2.peer) link2.peer.resetBy();
+    else link2.tx.closeRead();
+  }
+  resetBy() {
+    this.refused ??= new KernelError("ECONNRESET");
+    this.changes.wake();
+  }
   close() {
     const was = this.state;
+    if (this.abortive && was === "connected") this.abort();
     this.state = "closed";
     this.dialing?.abort(new KernelError("ECONNABORTED"));
     this.dialing = void 0;
@@ -8090,7 +8112,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.154.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.155.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -23272,6 +23294,7 @@ var SOCKET_OPS = [
   "sock-accept",
   "sock-connect",
   "sock-shutdown",
+  "sock-reset",
   "sock-name",
   "sock-getopt",
   "sock-setopt",
@@ -23339,6 +23362,9 @@ async function socketSyscall(req, proc) {
     case "sock-shutdown":
       anySocketAt(fds, req.fd).shutdown(req.how);
       return ok3();
+    case "sock-reset":
+      socketAt(fds, req.fd).resetOnClose();
+      return ok3();
     case "sock-name": {
       const socket = anySocketAt(fds, req.fd);
       const addr = req.peer ? socket.peer : socket.local;