@amritk/nish-aarch64-linux 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/nish-aarch64-linux",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "The @amritk/nish native compiler for Linux on ARM64",
   "license": "MIT",
   "os": [

package/runtime/nish.d.ts

@@ -248,6 +248,55 @@ declare function signalFd(): i32;
  */
 declare function readSignal(fd: i32): i32;
 
+// ---- `nish:net` (WP34 N5) --------------------------------------------------------
+//
+// Every call answers an `i32`: `>= 0` on success, a negative errno otherwise, in
+// Linux's numbering on every platform for -11 (would block), -95, -32, -104,
+// -98 and -22. An address is 18 bytes of a `u8[]`: 16 of IPv6 address (IPv4 as
+// `::ffff:a.b.c.d`), then the port, big-endian. Every socket is non-blocking and
+// close-on-exec. No reading under Node, where each throws.
+
+/** Write the address form of a numeric `host` and `port` into `out`: 0, or -22. */
+declare function netAddress(out: u8[], host: string, port: i32): i32;
+/** The port the socket `fd` is bound to. */
+declare function netLocalPort(fd: i32): i32;
+/** A listening TCP socket with `SO_REUSEADDR`; `"::"` hears IPv4 and IPv6. */
+declare function tcpListen(host: string, port: i32, backlog: i32): i32;
+/** The next connection's descriptor, its address in `peer`; -11 when none waits. */
+declare function tcpAccept(fd: i32, peer: u8[]): i32;
+/** Up to `len` bytes into `buf` from `off`: the count, 0 at end of stream, or -11. */
+declare function netRead(fd: i32, buf: u8[], off: i32, len: i32): i32;
+/** Up to `len` bytes of `buf` from `off`: the count; a gone peer is -32, never SIGPIPE. */
+declare function netWrite(fd: i32, buf: readonly u8[], off: i32, len: i32): i32;
+/** Shut the read side (0), the write side (1) or both (2). */
+declare function netShutdown(fd: i32, how: i32): i32;
+/** Close the descriptor. */
+declare function netClose(fd: i32): i32;
+/** A UDP socket: flag 1 `SO_REUSEPORT`, flag 2 `UDP_GRO` (-95 on Darwin); ECN is always read. */
+declare function udpBind(host: string, port: i32, flags: i32): i32;
+/** `buf[off, off + len)` to `to`, cut into `segment`-byte datagrams when `segment > 0`, with ECN bits `ecn`. */
+declare function udpSendTo(
+  fd: i32,
+  buf: readonly u8[],
+  off: i32,
+  len: i32,
+  to: readonly u8[],
+  segment: i32,
+  ecn: i32
+): i32;
+/** One datagram, or several GRO coalesced, into `buf[off, off + len)`; the sender in `from`, `meta` [segment size, ECN]. */
+declare function udpRecvFrom(fd: i32, buf: u8[], off: i32, len: i32, from: u8[], meta: i32[]): i32;
+/** A readiness loop, level-triggered: epoll on Linux, kqueue on Darwin. */
+declare function pollCreate(): i32;
+/** Watch `fd` for `events` (1 readable, 2 writable) under `token`. */
+declare function pollAdd(loop: i32, fd: i32, events: i32, token: i32): i32;
+/** New events or a new token for a watched `fd`. */
+declare function pollModify(loop: i32, fd: i32, events: i32, token: i32): i32;
+/** Stop watching `fd`. */
+declare function pollRemove(loop: i32, fd: i32): i32;
+/** Wait up to `timeoutMs` (negative: forever); pairs `ready[2k]` token, `ready[2k + 1]` events (4: hang-up or error). */
+declare function pollWait(loop: i32, ready: i32[], timeoutMs: i32): i32;
+
 // ---- `Date` and `crypto` (WP34 N3) -----------------------------------------------
 //
 // `lib.es2022` already declares `Date`, whose `now()` is Nish's one member of it,
@@ -318,6 +367,48 @@ declare module "nish:process" {
   export const arch: string;
 }
 
+declare module "nish:net" {
+  /** The address form of a numeric `host` and `port` in `out`'s first 18 bytes: 0, or -22. */
+  export function netAddress(out: u8[], host: string, port: i32): i32;
+  /** The port the socket is bound to. */
+  export function netLocalPort(fd: i32): i32;
+  /** A listening TCP socket with `SO_REUSEADDR`; `"::"` hears IPv4 and IPv6. */
+  export function tcpListen(host: string, port: i32, backlog: i32): i32;
+  /** The next connection's descriptor, its address in `peer`; -11 when none waits. */
+  export function tcpAccept(fd: i32, peer: u8[]): i32;
+  /** Up to `len` bytes into `buf` from `off`: the count, 0 at end of stream, or -11. */
+  export function netRead(fd: i32, buf: u8[], off: i32, len: i32): i32;
+  /** Up to `len` bytes of `buf` from `off`: the count; a gone peer is -32, never SIGPIPE. */
+  export function netWrite(fd: i32, buf: readonly u8[], off: i32, len: i32): i32;
+  /** Shut the read side (0), the write side (1) or both (2). */
+  export function netShutdown(fd: i32, how: i32): i32;
+  export function netClose(fd: i32): i32;
+  /** A UDP socket: flag 1 `SO_REUSEPORT`, flag 2 `UDP_GRO` (-95 on Darwin); ECN is always read. */
+  export function udpBind(host: string, port: i32, flags: i32): i32;
+  /** `buf[off, off + len)` to `to`, cut into `segment`-byte datagrams when `segment > 0`, with ECN bits `ecn`. */
+  export function udpSendTo(
+    fd: i32,
+    buf: readonly u8[],
+    off: i32,
+    len: i32,
+    to: readonly u8[],
+    segment: i32,
+    ecn: i32
+  ): i32;
+  /** One datagram, or several GRO coalesced, into `buf[off, off + len)`; the sender in `from`, `meta` [segment size, ECN]. */
+  export function udpRecvFrom(fd: i32, buf: u8[], off: i32, len: i32, from: u8[], meta: i32[]): i32;
+  /** A readiness loop, level-triggered: epoll on Linux, kqueue on Darwin. */
+  export function pollCreate(): i32;
+  /** Watch `fd` for `events` (1 readable, 2 writable) under `token`. */
+  export function pollAdd(loop: i32, fd: i32, events: i32, token: i32): i32;
+  /** New events or a new token for a watched `fd`. */
+  export function pollModify(loop: i32, fd: i32, events: i32, token: i32): i32;
+  /** Stop watching `fd`. */
+  export function pollRemove(loop: i32, fd: i32): i32;
+  /** Wait up to `timeoutMs` (negative: forever); pairs `ready[2k]` token, `ready[2k + 1]` events (4: hang-up or error). */
+  export function pollWait(loop: i32, ready: i32[], timeoutMs: i32): i32;
+}
+
 declare module "nish:io" {
   /** `s` to stdout with no trailing newline and no conversion. */
   export function write(s: string): void;

package/runtime/nish.h

@@ -337,6 +337,64 @@ double nish_stat_mtime(const nish_str *path);
 int32_t nish_signal_fd(void);
 int32_t nish_read_signal(int32_t fd);
 
+/* ---- The network (WP34 N5), runtime/runtime-net.c, `nish:net` ------------
+ * Every call answers an `int32_t`: `>= 0` on success (a descriptor, a byte
+ * count, 0) and a negative errno otherwise, in Linux's numbering on every
+ * platform for -11 (would block), -95 (unsupported), -32 (the peer is gone),
+ * -104 (reset), -98 (address in use) and -22 (a bad argument). Every socket
+ * is non-blocking and close-on-exec. An address is 18 bytes of a `u8[]`
+ * (element type `uint8_t`): 16 of IPv6 address, IPv4 as `::ffff:a.b.c.d`,
+ * then the port, big-endian; a shorter array is -22. Nothing allocates.
+ *
+ * `nish_net_address(out, host, port)`: the form of a numeric `host`.
+ * `nish_net_local_port(fd)`: the port a socket is bound to.
+ * `nish_tcp_listen(host, port, backlog)`: `SO_REUSEADDR`, and `::` hears
+ * both families, or IPv4 alone on a kernel without IPv6.
+ * `nish_tcp_accept(fd, peer)`: a new descriptor and the peer's address.
+ * `nish_net_read` / `nish_net_write(fd, buf, off, len)`: bytes `[off, off +
+ * len)` of `buf`, which the compiled call has range-checked; a write to a
+ * gone peer is -32, never SIGPIPE. `nish_net_shutdown(fd, how)`: 0 read, 1
+ * write, 2 both. `nish_net_close(fd)`.
+ *
+ * UDP: `nish_udp_bind(host, port, flags)` binds a datagram socket, flag 1
+ * `SO_REUSEPORT` and flag 2 `UDP_GRO` (-95 on Darwin). `nish_udp_send_to(fd,
+ * buf, off, len, to, segment, ecn)` sends `buf[off, off + len)` to the
+ * address `to` in one `sendmsg`, cut into `segment`-byte datagrams by
+ * `UDP_SEGMENT` when `segment > 0`, with the ECN bits `ecn` (0..3); either on
+ * Darwin is -95. `nish_udp_recv_from(fd, buf, off, len, from, meta)` takes
+ * one datagram, or several `UDP_GRO` coalesced, writes the sender into `from`
+ * and into `meta` (element type `int32_t`, at least 2) the segment size, 0
+ * when none was coalesced, and the ECN bits.
+ *
+ * The readiness loop, level-triggered: epoll on Linux, kqueue on Darwin.
+ * `nish_poll_create()` is a close-on-exec loop descriptor.
+ * `nish_poll_add(loop, fd, events, token)` and `nish_poll_modify` watch `fd`
+ * for `events` (1 readable, 2 writable; any other bit is -22) under `token`,
+ * and `nish_poll_remove(loop, fd)` stops. `nish_poll_wait(loop, ready,
+ * timeout_ms)` waits at most `timeout_ms` (a negative one forever) and writes
+ * into `ready` (element type `int32_t`) a token and its events, 4 added for a
+ * hang-up or an error, per ready descriptor: at most `ready->len / 2` pairs
+ * and at most 64 in one call. It answers the count, 0 on a timeout or an
+ * interrupting signal, and -22 for a `ready` shorter than 2. */
+int32_t nish_net_address(nish_array *out, const nish_str *host, int32_t port);
+int32_t nish_net_local_port(int32_t fd);
+int32_t nish_tcp_listen(const nish_str *host, int32_t port, int32_t backlog);
+int32_t nish_tcp_accept(int32_t fd, nish_array *peer);
+int32_t nish_net_read(int32_t fd, nish_array *buf, int64_t off, int64_t len);
+int32_t nish_net_write(int32_t fd, const nish_array *buf, int64_t off, int64_t len);
+int32_t nish_net_shutdown(int32_t fd, int32_t how);
+int32_t nish_net_close(int32_t fd);
+int32_t nish_udp_bind(const nish_str *host, int32_t port, int32_t flags);
+int32_t nish_udp_send_to(int32_t fd, const nish_array *buf, int64_t off, int64_t len, const nish_array *to,
+                         int32_t segment, int32_t ecn);
+int32_t nish_udp_recv_from(int32_t fd, nish_array *buf, int64_t off, int64_t len, nish_array *from,
+                           nish_array *meta);
+int32_t nish_poll_create(void);
+int32_t nish_poll_add(int32_t loop, int32_t fd, int32_t events, int32_t token);
+int32_t nish_poll_modify(int32_t loop, int32_t fd, int32_t events, int32_t token);
+int32_t nish_poll_remove(int32_t loop, int32_t fd);
+int32_t nish_poll_wait(int32_t loop, nish_array *ready, int32_t timeout_ms);
+
 /* String to number (WP7), ASCII whitespace only. mode 0 is `parseFloat`
  * (longest JS decimal literal or `Infinity`, else NaN), mode 1 is `Number`
  * (the whole string, trimmed; blank is 0; `0x` hex accepted, as in JS),

package/runtime/nish.mjs

@@ -98,6 +98,29 @@ provide("statMtimeSync", shim.statMtimeSync);
 provide("signalFd", shim.signalFd);
 provide("readSignal", shim.readSignal);
 
+// `nish:net` (WP34 N5). Each throws, naming itself: a socket is ready only to
+// Node's event loop, which a program that owns its loop never returns to.
+for (const name of [
+  "netAddress",
+  "netLocalPort",
+  "tcpListen",
+  "tcpAccept",
+  "netRead",
+  "netWrite",
+  "netShutdown",
+  "netClose",
+  "udpBind",
+  "udpSendTo",
+  "udpRecvFrom",
+  "pollCreate",
+  "pollAdd",
+  "pollModify",
+  "pollRemove",
+  "pollWait",
+]) {
+  provide(name, () => shim.noNetReading(name));
+}
+
 // `crypto.getRandomValues(bytes)` (WP34 N3). Node has the global, but it
 // takes only a typed array and a `u8[]` is a plain `Array` here, so the one
 // method is replaced on Node's own `crypto` object by one that fills a plain