@ai-ecoverse/slicc-kernel 1.111.0 → 1.112.0

package/README.md

@@ -432,7 +432,7 @@ The kernel has one node name, `slicc` unless `createKernel({ hostname })` (or `c
 - **What `uname` says:** for an Emscripten program built with homescoop's `__syscall_uname` import (wasm-coreutils 9.12.0-7 on), the kernel answers `uname(2)`: sysname `Linux`, nodename the node name, release `6.0.0-slicc` (as `/proc/sys/kernel/osrelease`), version `#1 SMP PREEMPT_DYNAMIC` (as `/proc/version`), machine `wasm32` and domainname `(none)`, so `uname -a` and musl's `gethostname()` see them. `uname -o` is coreutils' compiled-in `Emscripten`. Older Emscripten builds still report their C library's `Emscripten 4.0.23` and `emscripten`, and WASIX programs `wasmer.sh`; the kernel has nothing to answer there.
 - **Resolving it:** `/etc/hosts` maps the node name and both of those names to `127.0.1.1` (Debian's convention), and name resolution answers them, and `localhost.localdomain`, itself, as `127.0.1.1` and `::1`. So a program that looks up its own host name, as git does for every commit, never asks the [uplink](#uplink), and `127.0.1.1` is the kernel's loopback.
 - **The trade-off:** a raw connection to the real `wasmer.sh` resolves to loopback too. HTTP(S) to it still goes through the realm proxy and the transport, which resolve names themselves; `wasmer.sh` is deliberately not in `no_proxy`.
-- **A real file wins:** a root that has its own `/etc/hostname` (or `/etc/hosts`, `/etc/passwd`) keeps it, and programs read that file rather than the synthetic one. The kernel's name still drives `HOSTNAME` and name resolution. A program that opens one of these synthetic files for writing (as root, since `/etc` is root's) gets a real one first: a root-owned `0644` copy of the defaults. So `echo '10.0.0.9 db' >> /etc/hosts` keeps `localhost` and the other default entries, `>` replaces them as on Linux, and `rm` returns to the synthetic file. The copy is `0644` whatever the umask. Programs that read `/etc/hosts` themselves (WASIX/musl ones, such as python's `socket.gethostbyname`) resolve an added name. The kernel's own resolver, which Emscripten programs, `ctx.net` and HTTP through the transport use, doesn't read the file yet ([#898](https://github.com/ai-ecoverse/slicc-kernel/issues/898)).
+- **A real file wins:** a root that has its own `/etc/hostname` (or `/etc/hosts`, `/etc/passwd`) keeps it, and programs read that file rather than the synthetic one. The kernel's name still drives `HOSTNAME` and name resolution. A program that opens one of these synthetic files for writing (as root, since `/etc` is root's) gets a real one first: a root-owned `0644` copy of the defaults. So `echo '10.0.0.9 db' >> /etc/hosts` keeps `localhost` and the other default entries, `>` replaces them as on Linux, and `rm` returns to the synthetic file. The copy is `0644` whatever the umask. Programs that read `/etc/hosts` themselves (WASIX/musl ones, such as python's `socket.gethostbyname`) resolve an added name. So does the kernel's own resolver, which Emscripten programs' `getaddrinfo`, WASIX `resolve` and `ctx.net` use ([#898](https://github.com/ai-ecoverse/slicc-kernel/issues/898)). It reads a real `/etc/hosts` as glibc does (`#` comments, aliases, IPv4 and IPv6, first entries first), re-reads it when its inode, size or mtime change, and answers a name the file lists before its built-in names. HTTP that goes through the transport by URL is resolved there, so `curl http://db/` doesn't use the file.
 
 ### Uplink
 

package/dist/kernel-worker.js

@@ -6192,7 +6192,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.111.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.112.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
@@ -14706,6 +14706,7 @@ var Resolver = class {
   own;
   cache = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  hosts;
   constructor(options) {
     this.uplink = options.uplink;
     this.routes = options.routes;
@@ -14713,6 +14714,14 @@ var Resolver = class {
     this.timeoutMs = options.timeoutMs ?? RESOLVE_TIMEOUT_MS;
     this.log = options.log ?? ((message3) => console.warn(message3));
     this.own = ownNames(options.hostname ?? DEFAULT_HOSTNAME);
+    this.hosts = options.hosts;
+  }
+  async fromFile(key, family) {
+    const listed = (await this.hosts?.().catch(() => void 0))?.get(key);
+    if (!listed) return void 0;
+    const v4 = listed.filter((a) => ipv4Bytes(a) !== void 0);
+    const v6 = listed.filter((a) => ipv4Bytes(a) === void 0);
+    return family === 4 ? v4 : family === 6 ? v6 : [...v4, ...v6];
   }
   async resolve(name2, family, blocking) {
     const key = name2.toLowerCase().replace(/\.$/, "");
@@ -14721,6 +14730,8 @@ var Resolver = class {
       const v4 = family !== 6 && local ? [local] : [];
       return family === 4 ? v4 : [...v4, key];
     }
+    const listed = this.hosts ? await this.fromFile(key, family) : void 0;
+    if (listed?.length) return listed;
     if (local) {
       const six = loopbackName(key, this.own) ? ["::1"] : [];
       return family === 6 ? six : family === 4 ? [local] : [local, ...six];
@@ -19122,6 +19133,43 @@ var JobTable = class {
   }
 };
 
+// src/kernel/net/hosts-file.ts
+var HOSTS_PATH = "/etc/hosts";
+function parseHosts(text) {
+  const table = /* @__PURE__ */ new Map();
+  for (const raw of text.split("\n")) {
+    const [address, ...names] = raw.replace(/#.*/, "").trim().split(/\s+/);
+    if (!address || names.length === 0) continue;
+    if (ipv4Bytes(address) === void 0 && ipv6Groups(address) === void 0) continue;
+    for (const name2 of names) {
+      const key = name2.toLowerCase().replace(/\.$/, "");
+      const known = table.get(key) ?? [];
+      if (!known.includes(address)) known.push(address);
+      table.set(key, known);
+    }
+  }
+  return table;
+}
+function hostsReader(fs, path = HOSTS_PATH) {
+  let stamp = "";
+  let table;
+  return async () => {
+    const st = await fs.stat(path).catch(() => void 0);
+    if (!st?.isFile) {
+      stamp = "";
+      table = void 0;
+      return void 0;
+    }
+    const now = `${st.ino}:${st.size}:${st.mtime.getTime()}`;
+    if (now === stamp && table) return table;
+    const text = await fs.readFile(path).catch(() => void 0);
+    if (text === void 0) return void 0;
+    stamp = now;
+    table = parseHosts(text);
+    return table;
+  };
+}
+
 // src/kernel/net/redirect-hops.ts
 var HELD_MS = 3e4;
 var HELD_MAX = 64;
@@ -22494,7 +22542,12 @@ var Launcher = class {
     this.uplink = options.uplink;
     this.routes = new Routes(options.uplink?.traits.ipv6 === true);
     if (options.uplink?.routes) this.routes.set(options.uplink.routes);
-    this.resolver = new Resolver({ uplink: options.uplink, routes: this.routes, hostname });
+    this.resolver = new Resolver({
+      uplink: options.uplink,
+      routes: this.routes,
+      hostname,
+      hosts: hostsReader(this.base)
+    });
     if (options.uplink) this.net.useUplink({ uplink: options.uplink, routes: this.routes });
     enableNetwork(this.net, {
       transport: this.transport,