summaryrefslogtreecommitdiff
path: root/src/detached
diff options
context:
space:
mode:
Diffstat (limited to 'src/detached')
-rw-r--r--src/detached/client.zig1406
-rw-r--r--src/detached/server.zig1478
-rw-r--r--src/detached/wire.zig1296
3 files changed, 17 insertions, 4163 deletions
diff --git a/src/detached/client.zig b/src/detached/client.zig
deleted file mode 100644
index 617ae342..00000000
--- a/src/detached/client.zig
+++ /dev/null
@@ -1,1406 +0,0 @@
-//! THE FRONTEND SIDE of a detached session: a socket, a grid, and no core.
-//!
-//! A FRONTEND IS INPUT AND SCREEN, and that is the whole of it. Keystrokes,
-//! mouse, window size go out; frames come back and get painted. This is the
-//! shape the ESP32-P4 serial console has always had — a panel and a keypad on
-//! the far end of a wire, performing no effects of its own — and after the
-//! machine-local IO moved into the daemon it is the shape EVERY frontend has,
-//! terminal and window alike.
-//!
-//! THIS SIDE DOES NOT OWN A `Pardes`. There is no `update`, no `postEvent` and
-//! no `Host` in this file. The core lives in the detached process (server.zig),
-//! which is also where every `Host.VTable` call now lands: forking a pane's
-//! shell, writing a file, watching a path and reading the theme directory are
-//! all done BY THE DAEMON, against the same machine's kernel it shares with
-//! this frontend over an AF_UNIX socket. NO FORK HAPPENS IN A FRONTEND ANY
-//! MORE. That is not a simplification of this file, it is the fix: a pane's
-//! shell used to be a child of whichever frontend forked it, so leaving killed
-//! the shells of a session whose entire promise is outliving frontends.
-//!
-//! `Client` is NOT a renderer either. It owns `grid` and `cursor`: the cells the
-//! session is showing, kept current by applying frames as they arrive. Whoever
-//! owns a terminal (or a window, or an ESP32-P4 panel) reads those and paints.
-//! The split is deliberate — pardes already has terminal frontends, and a second
-//! one living in here would be a second convention for a job that has one.
-//!
-//! THE ATTACH IS NOT A BLOCKING HANDSHAKE. `open` connects and writes the
-//! `hello`; the `welcome` (or the `refuse`) arrives through the ordinary
-//! `wait`/`next` loop like everything else. A frontend therefore has one loop
-//! and one place it sleeps, instead of a startup path that can hang for two
-//! seconds before its terminal is even in raw mode. `attached()` says whether
-//! the session has greeted us; `refusal` says why it did not.
-//!
-//! WHAT ARRIVES. `next` hands back one decoded `wire.ServerMsg` at a time, and
-//! there are exactly seven of them:
-//! * `welcome` and `frame` have already been applied to `slot`/`cols`/`rows`/
-//! `grid`/`cursor` by the time you see them. They are returned so a frontend
-//! knows the screen moved.
-//! * `set_clipboard`, `read_clipboard` and `open_link` are the only effects
-//! still on the wire, and they are here because each needs THIS HUMAN'S
-//! DISPLAY: a daemon nobody is looking at has no clipboard and no browser.
-//! The answer to `read_clipboard` is not a reply message: it is an ordinary
-//! `Event.paste` sent back through `send`, which is the same asynchronous
-//! shape `read_clipboard` already has in-process.
-//! * `refuse` is followed by the session closing the connection, and `quit`
-//! means the session itself has ended.
-//! The switch in `next` is exhaustive over that set on purpose: putting a
-//! machine-local effect back on the wire is a compile error here, and the test
-//! at the bottom of this file says so in the other direction too.
-//!
-//! GEOMETRY. `cols`/`rows` are the SESSION's grid, which with several frontends
-//! attached is the smallest common one and can be smaller than this frontend's
-//! window. Tell the session about the window with `resize`; do not assume the
-//! next frame will agree with it.
-//!
-//! BORROWED BYTES. Every slice in a returned `ServerMsg` points into this
-//! client's receive buffer and is valid until the next call to `next` or
-//! `wait`. A frontend that needs a payload for longer copies it — the same rule
-//! the core's own `Event.output` bytes have.
-const std = @import("std");
-const libc = std.c;
-const pardes = @import("../pardes.zig");
-const dump = @import("../dump.zig");
-const server = @import("server.zig");
-const wire = @import("wire.zig");
-
-const read_chunk = 16 * 1024;
-
-pub const Error = error{
- /// No `$XDG_RUNTIME_DIR` and no `$HOME`, or a name that is not one path
- /// component — there is no socket path to try.
- NoSessionPath,
- /// Nothing is listening there: the name is wrong, or that session ended.
- /// Its socket file, if it is still lying about, is unlinked by the sweep the
- /// next detached session runs.
- NoSession,
- /// The socket is there and this frontend will not talk to it: the directory
- /// or the socket is not a private one of ours (server.zig `vetted`). A
- /// planted socket at a derivable path collects every keystroke typed into
- /// the frontend that trusts it, so this is refused rather than reported as
- /// "no session" — the two need different answers from a human.
- NotPrivate,
- /// The session hung up, or the connection failed under us. Every read and
- /// write path funnels here: a frontend's answer to all of them is the same
- /// (report and exit), so distinguishing them would be a distinction nobody
- /// acts on.
- Closed,
- /// The session said something before it said `welcome`.
- Ungreeted,
-};
-
-pub const Client = struct {
- gpa: std.mem.Allocator,
- fd: c_int = -1,
- /// Which client slot the session gave this connection. Diagnostics only,
- /// and it exists so both sides print the same number.
- slot: u8 = 0,
- /// Set by a `refuse`, and the reason a frontend prints before exiting.
- refusal: ?wire.Refusal = null,
- /// The SESSION's grid, not this frontend's window. Zero until the welcome.
- cols: u16 = 0,
- rows: u16 = 0,
- /// `cols * rows` cells: what the session is showing right now.
- grid: std.ArrayListUnmanaged(pardes.Cell) = .empty,
- cursor: ?wire.Cursor = null,
- pointer_shape: pardes.Surface.PointerShape = .arrow,
- body_layers: [pardes.MAX_PANES]pardes.Layer = @splat(.{}),
- tag_layers: [pardes.MAX_TAG_LAYERS]pardes.Layer = @splat(.{}),
- /// The session's placed regions, as its last frame gave them.
- regions: std.ArrayListUnmanaged(pardes.Region) = .empty,
- /// The palette its chrome is drawn in, as its last frame gave it.
- chrome: pardes.Chrome = .{},
- /// The post chain its frames are drawn through, as the session last
- /// sent it; its paths and SPIR-V owned here. `post_key` moves with it.
- post: wire.Post = .{},
- post_key: u32 = 0,
- in: std.ArrayListUnmanaged(u8) = .empty,
- out: std.ArrayListUnmanaged(u8) = .empty,
- /// Bytes of `in` belonging to the message `next` returned last. Compacted at
- /// the top of the next call, which is exactly what makes that message's
- /// borrowed slices valid until then and no longer.
- held: usize = 0,
-
- /// Connect to the session called `name` and say hello, telling it this
- /// frontend's window. Does not wait: the greeting arrives through `next`.
- pub fn open(gpa: std.mem.Allocator, name: []const u8, cols: u16, rows: u16) (Error || wire.Error)!Client {
- var path_buf: [server.path_max]u8 = undefined;
- const path = server.sessionPath(&path_buf, name) orelse return error.NoSessionPath;
- // `vetted` is one predicate over two different failures, and a human is
- // owed different words for them: `NotPrivate` promises, in its own doc
- // above, that the socket IS there. So ask the cheap question first,
- // because the commonest failure of all is a mistyped session name —
- // until this, `Attach nosuchsession` put "attach: NotPrivate" on the
- // message row, which reads as an accusation rather than a typo. Spelled
- // with the `access` this file already uses in `resolve`.
- const F_OK: c_int = 0;
- if (libc.access(path, F_OK) != 0) return error.NoSession;
- // Both ends vet, and this is this end's half: the session refuses a
- // directory or a socket anyone else can reach before it binds, and until
- // this a frontend connected to whatever it found at the path it derived.
- // See server.zig `vetted` for what is asked and why it is asked there.
- if (!server.vetted(path)) return error.NotPrivate;
- var addr: libc.sockaddr.un = .{ .path = @splat(0) };
- @memcpy(addr.path[0 .. path.len + 1], path[0 .. path.len + 1]);
- const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM, 0);
- if (fd < 0) return error.NoSession;
- // CLOEXEC anyway, even though a frontend no longer forks pane shells:
- // `open_link` runs this display's browser, and a `xdg-open` inheriting
- // this socket would keep the session believing a frontend is attached
- // long after this process left.
- server.setCloexec(fd);
- if (comptime server.darwin) {
- // linux says MSG_NOSIGNAL per write and darwin says it once per
- // socket, which is what `nosignal` being 0 on darwin MEANS — so
- // this call is the whole of that platform's protection and the
- // comment on `nosignal` used to say `open` made it without `open`
- // making it. A session that ends mid-write must not take the
- // frontend down with SIGPIPE. server.zig `accept` is the mirror.
- const on: c_int = 1;
- _ = libc.setsockopt(fd, libc.SOL.SOCKET, libc.SO.NOSIGPIPE, &on, @sizeOf(c_int));
- }
- // Still blocking for the connect itself, which on AF_UNIX either lands
- // in the listener's backlog immediately or is refused; there is no
- // in-progress state to poll for.
- if (libc.connect(fd, @ptrCast(&addr), @sizeOf(@TypeOf(addr))) != 0) {
- _ = libc.close(fd);
- return error.NoSession;
- }
- _ = server.setNonblock(fd);
- var c: Client = .{ .gpa = gpa, .fd = fd };
- errdefer c.deinit();
- try c.send(.{ .hello = .{
- .cols = @min(cols, wire.max_cols),
- .rows = @min(rows, wire.max_rows),
- } });
- return c;
- }
-
- /// Has the session greeted us? Until it has, `grid` is empty and nothing
- /// has been drawn.
- pub fn attached(c: *const Client) bool {
- return c.cols != 0;
- }
-
- pub fn deinit(c: *Client) void {
- if (c.fd >= 0) _ = libc.close(c.fd);
- c.fd = -1;
- c.grid.deinit(c.gpa);
- for (&c.body_layers) |*layer| {
- c.gpa.free(layer.cells);
- layer.* = .{};
- }
- for (&c.tag_layers) |*layer| c.gpa.free(layer.cells);
- c.regions.deinit(c.gpa);
- c.freePost();
- c.in.deinit(c.gpa);
- c.out.deinit(c.gpa);
- }
-
- /// Leave without ending the session. The `bye` is a courtesy — the session
- /// handles a frontend that simply dies, and proving it does is what that
- /// test is for — but it turns "the peer vanished" into "the peer left" in
- /// the session's log, which is worth seven bytes.
- pub fn detach(c: *Client) void {
- c.send(.bye) catch {};
- c.deinit();
- }
-
- /// One message on its way to the core. Everything a frontend collects goes
- /// through here, and after the IO moved into the daemon that is a short
- /// list: keys, the mouse, a window resize, and the paste that answers a
- /// `read_clipboard`. `ClientMsg.output`/`.eof` still exist on the wire but
- /// no frontend sends them any more — pty bytes are read by the process that
- /// forked the shell, which is the daemon.
- pub fn send(c: *Client, msg: wire.ClientMsg) (Error || wire.Error)!void {
- const want = wire.clientBound(msg);
- c.out.ensureUnusedCapacity(c.gpa, want) catch return error.Closed;
- const at = c.out.items.len;
- // Encoded straight into the queue's tail rather than through a scratch
- // buffer: a paste is four megabytes and copying it twice is two copies.
- c.out.items.len += want;
- const bytes = wire.encodeClient(c.out.items[at..], msg) catch |err| {
- // AND THE QUEUE GOES BACK. `want` bytes of it are uninitialised
- // right now, and leaving them there — which is what a bare `try`
- // did — puts that much stack-shaped garbage on the socket at the
- // next flush: the session decodes it as a message, refuses it, and
- // drops a frontend whose only mistake was a message this protocol
- // cannot carry (an `Event.command` past 64 KiB is `Overlong`, and a
- // caller that mis-sized the queue is `WriteFailed`).
- c.out.items.len = at;
- return err;
- };
- c.out.items.len = at + bytes.len;
- return c.flush();
- }
-
- /// Tell the session this frontend's window changed. Not a promise about the
- /// next frame: with other frontends attached the session grid is the
- /// smallest common one.
- ///
- /// Clamped, like the hello in `open`: a window past `max_cols`/`max_rows`
- /// is a geometry the protocol cannot carry, and the decoder on the far end
- /// answers one with `BadValue` — which `apply` turns into `close(.protocol)`
- /// with no `refuse` behind it, so the frontend was told only that the
- /// session "hung up on the connect". A 4K display at a small font is
- /// already past `max_rows`, which made an ordinary big screen unable to
- /// attach at all. Asking for the largest grid the wire carries is what this
- /// file's GEOMETRY note already promises a frontend gets: the session is
- /// drawn at ITS size wherever the window is bigger, exactly as it is when
- /// another frontend is the smaller one.
- ///
- /// A ZERO is dropped rather than clamped, and that asymmetry is the whole
- /// point of `getCols` refusing zero in the first place: the session grid is
- /// the smallest common one, so a frontend that reported 1 would collapse
- /// every other frontend to a single cell. `TIOCGWINSZ` answers 0x0 while a
- /// terminal is being torn down and tty.zig forwards a `winsize` verbatim
- /// (its ATTACH path already refuses a zero one, its resize path did not),
- /// so this is reachable without a hostile peer — and it reached the session
- /// as the same mute `close(.protocol)` the oversize geometry did. Keeping
- /// the last real window is what a momentary zero means.
- pub fn resize(c: *Client, cols: u16, rows: u16) (Error || wire.Error)!void {
- if (cols == 0 or rows == 0) return;
- return c.send(.{ .event = .{ .resize = .{
- .cols = @min(cols, wire.max_cols),
- .rows = @min(rows, wire.max_rows),
- } } });
- }
-
- /// Wait up to `timeout_ms` for the session to say something, and push
- /// whatever we still owe it. Zero blocks. This is the frontend's one
- /// sleeping place FOR THE SOCKET; the terminal it draws on is polled by
- /// whoever owns that, which is why this takes a timeout rather than a second
- /// descriptor.
- pub fn wait(c: *Client, timeout_ms: u32) (Error || wire.Error)!void {
- if (c.fd < 0) return error.Closed;
- try c.flush();
- var fds: [1]libc.pollfd = .{.{
- .fd = c.fd,
- .events = if (c.out.items.len != 0) poll_in | poll_out else poll_in,
- .revents = 0,
- }};
- const timeout: c_int = if (timeout_ms == 0) -1 else @intCast(@min(timeout_ms, std.math.maxInt(c_int)));
- if (libc.poll(&fds, 1, timeout) <= 0) return; // a timeout, or EINTR
- if (fds[0].revents & poll_out != 0) try c.flush();
- // POLLIN wins over POLLHUP: a session that wrote a `quit` and then
- // closed has bytes worth reading.
- if (fds[0].revents & poll_in != 0) return c.fill();
- if (fds[0].revents & (poll_hup | poll_err | poll_nval) != 0) return error.Closed;
- }
-
- /// The next complete message, or null when the buffer holds only part of
- /// one. `welcome` and `frame` have already been applied to this client's
- /// own state; every slice in the result borrows the receive buffer until the
- /// next call here or to `wait`.
- pub fn next(c: *Client) (Error || wire.Error)!?wire.ServerMsg {
- // Retire the message returned last, now that its borrow window is over.
- if (c.held != 0) {
- if (c.held == c.in.items.len) {
- c.in.clearRetainingCapacity();
- } else {
- std.mem.copyForwards(u8, c.in.items, c.in.items[c.held..]);
- c.in.items.len -= c.held;
- }
- c.held = 0;
- }
- const found = (try wire.framed(c.in.items)) orelse return null;
- const msg = try wire.decodeServer(found.tag, found.payload);
- c.held = found.total;
- switch (msg) {
- .welcome => |v| {
- // Both sides check the version. This side checks it too because
- // a session speaking something else may not have recognised our
- // hello as one either, and a frontend must not paint a frame it
- // decoded by a layout the other end does not use.
- if (v.version != wire.version) return error.Ungreeted;
- c.slot = v.slot;
- try c.reshape(v.cols, v.rows);
- },
- .refuse => |why| c.refusal = why,
- .frame => |f| {
- // A frame before the greeting would be the session drawing for a
- // connection it never accepted.
- if (!c.attached()) return error.Ungreeted;
- // A geometry change and a late attach are the same case on this
- // side too: reshape, and require the FULL frame the session
- // promises for it. Applying a diff to a grid we just cleared
- // would leave every untouched cell blank.
- if (f.cols != c.cols or f.rows != c.rows) {
- if (f.kind != .full) return error.BadValue;
- try c.reshape(f.cols, f.rows);
- }
- try f.apply(c.grid.items);
- f.applyLayers(c.gpa, &c.body_layers, &c.tag_layers, &c.regions, &c.chrome) catch |err| return switch (err) {
- error.OutOfMemory => error.Closed,
- else => @as(wire.Error, @errorCast(err)),
- };
- c.cursor = f.cursor;
- c.pointer_shape = f.pointer_shape;
- },
- // The session has ended. Left for the caller to act on, and the
- // descriptor stays open so `deinit` is the only place that closes.
- .quit => {},
- // THIS frontend is done and the session is not. Same shape as
- // `quit` and the same non-answer here — the caller leaves its loop
- // — but the opposite meaning about what survives, so a frontend
- // must not collapse the two: `quit` is the session ending and
- // `detach` is success. Guarded, because a peer that has not greeted
- // us has no standing to dismiss us either.
- .detach => if (!c.attached()) return error.Ungreeted,
- // The three display effects need this process's clipboard and this
- // process's browser, so they are the caller's to perform and there
- // is nothing for a `Client` to update. Listed rather than swept up
- // by an `else`: an `else` here would silently accept a
- // machine-local effect returning to the wire, and the point of the
- // rewrite is that it cannot.
- //
- // Guarded like `.frame`, and for a stronger reason than drawing:
- // these reach the human's clipboard and the human's browser. The
- // protocol version is checked in the `.welcome` arm above and
- // nowhere else, so a peer that simply never greets us has had its
- // version checked by nobody — and until it does, it does not get to
- // open a URI on this display or read this display's selection back
- // over the socket. `Ungreeted` is the same refusal a frame gets.
- .set_clipboard, .read_clipboard, .open_link => if (!c.attached()) return error.Ungreeted,
- // Kept, like the chrome: the frames that follow are drawn
- // through it.
- .post => |chain| {
- if (!c.attached()) return error.Ungreeted;
- c.freePost();
- c.post = chain;
- for (c.post.passes[0..c.post.len]) |*pass| {
- pass.path = c.gpa.dupe(u8, pass.path) catch return error.Closed;
- pass.spirv = c.gpa.dupe(u8, pass.spirv) catch return error.Closed;
- }
- c.post_key +%= 1;
- },
- }
- return msg;
- }
-
- fn freePost(c: *Client) void {
- for (c.post.passes[0..c.post.len]) |pass| {
- c.gpa.free(pass.path);
- c.gpa.free(pass.spirv);
- }
- c.post = .{};
- }
-
- // ---- internals --------------------------------------------------------
-
- fn reshape(c: *Client, cols: u16, rows: u16) (Error || wire.Error)!void {
- c.grid.resize(c.gpa, @as(usize, cols) * @as(usize, rows)) catch return error.Closed;
- // Unpainted, which a frontend draws as the terminal's own default cell.
- // The full frame that follows paints over it.
- @memset(c.grid.items, .{});
- c.cols = cols;
- c.rows = rows;
- c.cursor = null;
- c.pointer_shape = .arrow;
- }
-
- /// Take everything the kernel is holding, not one chunk of it. The server
- /// deliberately reads its clients ONE chunk per round, because it is
- /// dividing a loop between thirty-two of them; a frontend has exactly one
- /// peer, and reading one 16 KiB slice per poll would leave it a full frame
- /// behind on every large one — and the session drops a frontend whose queue
- /// it cannot drain (server.zig `out_backlog`).
- fn fill(c: *Client) (Error || wire.Error)!void {
- var buf: [read_chunk]u8 = undefined;
- while (true) {
- const got = libc.read(c.fd, &buf, buf.len);
- if (got == 0) return error.Closed;
- if (got < 0) return switch (libc.errno(got)) {
- .INTR => continue,
- // Nothing more is ready; what we have is what there was.
- .AGAIN => {},
- else => error.Closed,
- };
- c.in.appendSlice(c.gpa, buf[0..@intCast(got)]) catch return error.Closed;
- }
- }
-
- fn flush(c: *Client) Error!void {
- if (c.fd < 0) return error.Closed;
- var off: usize = 0;
- while (off < c.out.items.len) {
- const n = libc.send(c.fd, c.out.items.ptr + off, c.out.items.len - off, nosignal);
- if (n < 0) switch (libc.errno(n)) {
- .INTR => continue,
- // The session is not draining us. The rest waits for POLLOUT;
- // the queue is bounded in practice because a frontend's output
- // is keystrokes and pty chunks, never frames.
- .AGAIN => break,
- else => return error.Closed,
- };
- if (n == 0) break;
- off += @intCast(n);
- }
- if (off == 0) return;
- if (off == c.out.items.len) return c.out.clearRetainingCapacity();
- std.mem.copyForwards(u8, c.out.items, c.out.items[off..]);
- c.out.items.len -= off;
- }
-};
-
-// The socket primitives are server.zig's, which is the file that owns this
-// transport's conventions and both ends of it — see its `setNonblock`,
-// `nosignal` and `poll_*`. There was a third copy of all of them here.
-const nosignal = server.nosignal;
-const poll_in = server.poll_in;
-const poll_out = server.poll_out;
-const poll_hup = server.poll_hup;
-const poll_err = server.poll_err;
-const poll_nval = server.poll_nval;
-
-/// Which session an attach meant, answered before a frontend opens its window.
-///
-/// `--attach=<name>` is taken at its word beyond one `access` on the socket
-/// file, because the connect is the real authority on whether anything is
-/// listening — and a typo is the one failure worth catching earlier, since the
-/// alternative is a full-screen flash on the way to a one-line message. Bare
-/// `--attach`, and the bare `Attach` word, is THE session: bare `--detach`
-/// names itself by its own pid, and nobody can be expected to read a pid out
-/// of `$XDG_RUNTIME_DIR`. With exactly one listening, that is the one meant;
-/// with none or several this says WHICH case it is instead of picking one.
-///
-/// Both the directory and the filename convention come off ONE probe through
-/// `server.sessionPath` rather than being re-derived here, for the reason that
-/// function exists at all: the side that binds and the side that looks must
-/// never be able to disagree about where a session lives.
-///
-/// It lives in this file, rather than in either shell, because BOTH frontends
-/// now ask the same question — a terminal for `--attach` and the SDL window
-/// for the `Attach` word — and a second copy of a directory scan is exactly
-/// how the two of them would start disagreeing.
-pub const Resolved = union(enum) {
- /// The session to open. Borrows `requested` when it was named, and `buf`
- /// when it had to be scanned for.
- name: []const u8,
- /// No socket of that name, or no session at all. The caller knows which it
- /// asked for, so it owns the wording.
- none,
- /// Several are listening, and choosing between them is not ours to do.
- ambiguous: usize,
-};
-
-pub fn resolve(buf: *[server.path_max]u8, requested: []const u8) Resolved {
- if (requested.len != 0) {
- var one_buf: [server.path_max]u8 = undefined;
- const one = server.sessionPath(&one_buf, requested) orelse return .none;
- const F_OK: c_int = 0;
- if (libc.access(one, F_OK) != 0) return .none;
- return .{ .name = requested };
- }
- const probe_name = "0";
- var probe_buf: [server.path_max]u8 = undefined;
- const probe = server.sessionPath(&probe_buf, probe_name) orelse return .none;
- const base = std.fs.path.basename(probe);
- const cut = std.mem.lastIndexOf(u8, base, probe_name).?;
- const prefix = base[0..cut];
- const suffix = base[cut + probe_name.len ..];
- var dir_buf: [server.path_max:0]u8 = undefined;
- const dir = std.fs.path.dirname(probe) orelse "";
- if (dir.len == 0 or dir.len >= dir_buf.len) return .none;
- @memcpy(dir_buf[0..dir.len], dir);
- dir_buf[dir.len] = 0;
- const d = libc.opendir(dir_buf[0..dir.len :0]) orelse return .none;
- defer _ = libc.closedir(d);
- var found: usize = 0;
- var len: usize = 0;
- while (libc.readdir(d)) |ent| {
- const entry = std.mem.sliceTo(&ent.name, 0);
- if (entry.len <= prefix.len + suffix.len) continue;
- if (!std.mem.startsWith(u8, entry, prefix) or !std.mem.endsWith(u8, entry, suffix)) continue;
- const name = entry[prefix.len .. entry.len - suffix.len];
- if (name.len > buf.len) continue;
- found += 1;
- @memcpy(buf[0..name.len], name);
- len = name.len;
- }
- // A socket file whose session is gone still counts here: the sweep that
- // unlinks corpses runs when the NEXT session binds (server.zig `sweep`),
- // and probing every candidate with a connect would put a phantom frontend
- // into a live session's slot table just to count it. One stale file
- // therefore fails at `open` with "no such session", which is the truth.
- if (found != 1) return if (found == 0) .none else .{ .ambiguous = found };
- return .{ .name = buf[0..len] };
-}
-
-// Input arrives through frontend queues, so attached clients bound socket waits to half a frame.
-pub const poll_ms: u32 = 8;
-
-/// One round of waiting for the greeting, and how many of them. The COUNT is
-/// derived from `server.greet_deadline_default_ms` rather than written down
-/// again, so the two ends of the handshake give each other the same grace out
-/// of one number instead of two that can drift apart.
-///
-/// Rounds rather than a clock, and that is sound rather than lazy: the only
-/// message a session may legally send before its `welcome` is a `refuse`.
-/// Everything else is refused by `next` as `Ungreeted` — a frame because it
-/// would be drawing for a connection that was never accepted, and the three
-/// display effects because a peer whose version nobody has checked does not get
-/// to open a URI or read a clipboard. So a peer that is silent costs one whole
-/// timeout per round, which makes the round count a real wall-clock bound; and
-/// a peer that is NOISY but ungreeted fails on its first message rather than
-/// spending the budget.
-const greet_round_ms: u32 = 250;
-const greet_rounds: u32 = server.greet_deadline_default_ms / greet_round_ms;
-
-/// What came of trying to attach. A VALUE and not an error union, because four
-/// of the six outcomes are ordinary answers a human needs different words for,
-/// and because the two frontends report them by different mechanisms — a
-/// terminal prints a sentence and exits, a window logs and unwinds. `resolve`
-/// above returns a union for the same reason.
-pub const Attempt = union(enum) {
- /// Resolved, connected, AND greeted. The caller owns it.
- greeted: Client,
- /// No socket of that name, or nothing detached at all. The caller knows
- /// which it asked for, so the wording is the caller's.
- no_session,
- /// Several are listening and choosing is not ours to do.
- ambiguous: usize,
- /// The session said no, and said why.
- refused: wire.Refusal,
- /// It accepted and then never greeted us inside the deadline.
- silent,
- /// Everything else, already reported by the errno it came from.
- lost: anyerror,
-};
-
-/// Wait for welcome before the caller replaces its session; connect alone can
-/// still lead to a version refusal. Every non-greeted result owns no resources.
-pub fn attempt(gpa: std.mem.Allocator, requested: []const u8, cols: u16, rows: u16) Attempt {
- var buf: [server.path_max]u8 = undefined;
- const name = switch (resolve(&buf, requested)) {
- .name => |n| n,
- .none => return .no_session,
- .ambiguous => |n| return .{ .ambiguous = n },
- };
- var c = Client.open(gpa, name, cols, rows) catch |err| return switch (err) {
- // `open`'s own two ways of saying "there is nothing there" collapse
- // into the one the caller has wording for.
- error.NoSession, error.NoSessionPath => .no_session,
- else => .{ .lost = err },
- };
- var rounds: u32 = 0;
- while (rounds < greet_rounds) : (rounds += 1) {
- c.wait(greet_round_ms) catch |err| return give(&c, err);
- // Drain whatever landed. `next` is what applies the welcome, so the
- // loop below is not discarding anything it needs — the state it wants
- // is in `c` afterwards.
- while (true) {
- const msg = c.next() catch |err| return give(&c, err);
- if (msg == null) break;
- }
- if (c.attached()) return .{ .greeted = c };
- if (c.refusal) |why| {
- c.deinit();
- return .{ .refused = why };
- }
- }
- c.deinit();
- return .silent;
-}
-
-/// Close, and say what the failure actually was. A session that refuses us
-/// writes its reason and closes in the same pass (server.zig `refuseFd`), so a
-/// read error here is usually the far side hanging up on a refusal we have
-/// already decoded — reporting that as a lost connection would throw away the
-/// one sentence worth telling the human.
-fn give(c: *Client, err: anyerror) Attempt {
- const why = c.refusal;
- c.deinit();
- if (why) |w| return .{ .refused = w };
- return .{ .lost = err };
-}
-
-// ---------------------------------------------------------------------------
-// tests
-// ---------------------------------------------------------------------------
-//
-// One real core, one real unix socket, real frontends. The harness runs the
-// server's vtable in the order `Pardes.pump` runs it, so what these exercise is
-// the transport as the core actually drives it rather than a mock of it.
-
-const testing = std.testing;
-
-extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
-extern "c" fn unsetenv(name: [*:0]const u8) c_int;
-
-/// A session on a socket of its own under `.zig-cache/tmp`, so a test never
-/// collides with a real session in `$XDG_RUNTIME_DIR` and never depends on that
-/// variable being set at all. It is process-wide, so it is saved and restored.
-const Harness = struct {
- tmp: std.testing.TmpDir,
- saved: ?[:0]const u8,
- saved_buf: [4096:0]u8 = undefined,
- core: *pardes.Pardes,
- session: server.Session,
- arena: std.heap.ArenaAllocator,
- name_buf: [32]u8 = undefined,
- name: []const u8 = &.{},
-
- fn init(h: *Harness, cols: u16, rows: u16) !void {
- h.tmp = std.testing.tmpDir(.{});
- errdefer h.tmp.cleanup();
- h.saved = if (libc.getenv("XDG_RUNTIME_DIR")) |v|
- try std.fmt.bufPrintSentinel(&h.saved_buf, "{s}", .{std.mem.span(v)}, 0)
- else
- null;
- errdefer h.restoreEnv();
- var dir_buf: [4096:0]u8 = undefined;
- const dir = try std.fmt.bufPrintSentinel(&dir_buf, ".zig-cache/tmp/{s}", .{h.tmp.sub_path}, 0);
- // `ensureSocketDir` refuses anything with a bit granted to group or
- // other, which is the whole point of it; a tmpDir arrives 0755.
- try testing.expectEqual(@as(c_int, 0), libc.chmod(dir, 0o700));
- _ = setenv("XDG_RUNTIME_DIR", dir.ptr, 1);
- h.core = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = cols, .rows = rows });
- errdefer h.core.deinit();
- h.arena = .init(testing.allocator);
- errdefer h.arena.deinit();
- // `io` is not optional on `Session`: the daemon does the file watching
- // and the theme scan itself now, and both of those take a `std.Io`.
- h.session = .{
- .gpa = testing.allocator,
- .worker_gpa = testing.allocator,
- .io = std.testing.io,
- .core = h.core,
- .cols = cols,
- .rows = rows,
- };
- try h.session.initAsync();
- errdefer h.session.deinit();
- h.name = "s";
- try testing.expect(h.session.listen(h.name));
- // The pre-loop drain tty.zig has, for its reason: the startup spawns are
- // already queued and a session must not open its socket with panes that
- // have not been created. These now fork IN THIS PROCESS, because the
- // daemon is the thing that owns pane shells — which is exactly the
- // property under test, and the reason no frontend below is ever asked
- // to fork anything.
- h.core.host = h.session.host();
- while (h.core.nextEffect()) |e| h.core.perform(e);
- }
-
- fn restoreEnv(h: *Harness) void {
- if (h.saved) |v| {
- _ = setenv("XDG_RUNTIME_DIR", v.ptr, 1);
- } else _ = unsetenv("XDG_RUNTIME_DIR");
- }
-
- fn deinit(h: *Harness) void {
- h.session.deinit();
- h.core.deinit();
- h.arena.deinit();
- h.restoreEnv();
- h.tmp.cleanup();
- }
-
- /// `Pardes.pump`, with the one substitution a single-threaded test needs: a
- /// bounded wait, so a frontend that says nothing cannot hang the suite
- /// where the real session would sleep until it spoke. The queued-input
- /// drain `pump` does between the two is absent because this host has no
- /// queue: it calls `update` directly (borrowed bytes), and `postEvent` is
- /// for hosts whose worker threads post from off the loop.
- fn pump(h: *Harness) !void {
- const host = h.session.host();
- host.vtable.wait_input.?(host.ctx, 20);
- while (h.core.nextEffect()) |e| h.core.perform(e);
- if (h.core.quit) return;
- _ = h.arena.reset(.retain_capacity);
- const surface = try h.core.render(h.arena.allocator());
- host.vtable.present.?(host.ctx, surface);
- }
-
- /// The round budget every `pumpUntil*` below shares. A round moves at most
- /// one socket buffer, because nothing here is concurrent: the session
- /// flushes until `EAGAIN`, and only then does the client read. That buffer
- /// is 8 KiB on darwin (`net.local.stream.sendspace`) against linux's 208
- /// KiB, which is the same asymmetry the slow-frontend test at the bottom of
- /// this file already had to say out loud — and a full frame of the largest
- /// grid the protocol carries is near a megabyte, so 64 rounds is a linux-
- /// only number. High enough for that frame on the smaller buffer, and still
- /// a bound: a broken transport fails a test rather than hanging the suite.
- const rounds = 256;
-
- /// Pump until this client has the message we are waiting for.
- fn pumpUntil(h: *Harness, c: *Client, comptime want: std.meta.Tag(wire.ServerMsg)) !wire.ServerMsg {
- for (0..rounds) |_| {
- try h.pump();
- try c.wait(5);
- while (try c.next()) |msg| if (std.meta.activeTag(msg) == want) return msg;
- }
- return error.NeverArrived;
- }
-
- /// Pump until this client is sent a frame that CHANGES something. The first
- /// frame after an input is not always the one carrying it — an effect the
- /// input queued (a `Look` on a directory emits a spawn) lands a frame
- /// later, and the frame in between legitimately says nothing.
- fn pumpUntilChange(h: *Harness, c: *Client) !wire.Frame {
- for (0..rounds) |_| {
- const msg = try h.pumpUntil(c, .frame);
- if (msg.frame.nruns > 0) return msg.frame;
- }
- return error.NothingChanged;
- }
-
- /// Pump until this client's grid is this shape, draining everything that
- /// arrives. A test waits for the STATE rather than for the n-th message
- /// because a resize is announced when the session settles it, which may be
- /// one empty frame after the pump that caused it.
- fn pumpUntilGrid(h: *Harness, c: *Client, cols: u16, rows: u16) !void {
- for (0..rounds) |_| {
- try h.pump();
- try c.wait(5);
- while (try c.next()) |_| {}
- if (c.cols == cols and c.rows == rows) return;
- }
- return error.NeverResized;
- }
-
- /// Pump until two frontends are showing the same screen, draining both on
- /// every pass. One pump sends every attached frontend a frame, so a test
- /// that drains only one of them is comparing two different instants — and
- /// what a shared session promises is that they CONVERGE, which is what this
- /// waits for.
- fn pumpUntilSameScreen(h: *Harness, a: *Client, b: *Client) !void {
- for (0..rounds) |_| {
- try h.pump();
- try a.wait(5);
- try b.wait(5);
- while (try a.next()) |_| {}
- while (try b.next()) |_| {}
- if (sameScreen(a.grid.items, b.grid.items)) return;
- }
- return error.NeverConverged;
- }
-
- /// Pump until THIS frontend is showing the core's own screen, draining
- /// everything that arrives on every pass. `pumpUntilSameScreen`'s reason,
- /// with one frontend instead of two, and a second reason of its own:
- /// `pumpUntil` returns the instant it decodes the message it was waiting
- /// for and leaves the rest of that burst in the socket, so a client can sit
- /// one whole frame behind for the rest of a test. Comparing once against
- /// that grid compares the core's NOW with the frontend's THEN — which is
- /// nothing at all until the pane shell's prompt lands in the frame nobody
- /// read, and then it is a cell that differs.
- ///
- /// Checked BEFORE the first pump, so a test already in sync spends nothing
- /// and no extra frame is manufactured to make one appear. Out of rounds it
- /// hands the last comparison to `expectSameScreen`, which names the cell:
- /// a transport that really does drop one must fail as a wrong screen, not
- /// as a timeout.
- fn pumpUntilShowsCore(h: *Harness, c: *Client) !void {
- for (0..rounds) |_| {
- _ = h.arena.reset(.retain_capacity);
- if (sameScreen((try h.core.render(h.arena.allocator())).cells, c.grid.items)) return;
- try h.pump();
- try c.wait(5);
- while (try c.next()) |_| {}
- }
- _ = h.arena.reset(.retain_capacity);
- return expectSameScreen((try h.core.render(h.arena.allocator())).cells, c.grid.items);
- }
-
- /// Attach a frontend and get it greeted: `open` writes the hello into the
- /// listener's backlog, one pump accepts and answers it. Nothing blocks,
- /// which is the whole reason the handshake is not a blocking call.
- fn attach(h: *Harness, cols: u16, rows: u16) !Client {
- var c = try Client.open(testing.allocator, h.name, cols, rows);
- errdefer c.deinit();
- _ = try h.pumpUntil(&c, .welcome);
- return c;
- }
-};
-
-test "detached session: a frontend attaches, is greeted, and is sent the screen" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
-
- var c = try h.attach(60, 16);
- defer c.deinit();
- try testing.expectEqual(@as(u8, 0), c.slot);
- try testing.expectEqual(@as(u16, 60), c.cols);
- try testing.expectEqual(@as(u16, 16), c.rows);
-
- const frame = (try h.pumpUntil(&c, .frame)).frame;
- // The first frame a frontend gets must be full: it has nothing to diff
- // against.
- try testing.expectEqual(wire.FrameKind.full, frame.kind);
- try testing.expectEqual(@as(usize, 60 * 16), c.grid.items.len);
- // ...and it must be the core's own frame, cell for cell. This is the whole
- // claim of the transport — asserted once the frontend has read everything
- // the session sent, which `pumpUntil` above deliberately did not do.
- try h.pumpUntilShowsCore(&c);
-}
-
-test "detached session: input from a frontend reaches the core and comes back as a diff" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- var c = try h.attach(60, 16);
- defer c.deinit();
- _ = try h.pumpUntil(&c, .frame);
-
- // A builtin line is the cheapest input with a guaranteed visible effect,
- // and it travels the same `Event` path a keystroke does.
- try c.send(.{ .event = .{ .command = "Look /" } });
- const frame = try h.pumpUntilChange(&c);
- // The change arrived as a DIFF: this frontend was already in sync, so
- // nothing it already had was re-sent.
- try testing.expectEqual(wire.FrameKind.diff, frame.kind);
- try h.pumpUntilShowsCore(&c);
-}
-
-test "detached Restore keeps attached frontends and follows queued frames with a full replacement" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- _ = try h.core.setTestFile("saved body\n");
- var c = try h.attach(60, 16);
- defer c.deinit();
- _ = try h.pumpUntil(&c, .frame);
- try h.pumpUntilShowsCore(&c);
-
- const before = h.core;
- const fd = h.session.clients[c.slot].fd;
- try testing.expectError(error.BadDumpMagic, h.session.restore(
- ".{ .magic = \"not-a-pardes-dump\", .theme = \"dark\", .screen = .{ .cols = 60, .rows = 16 } }",
- "test",
- ));
- try testing.expectEqual(before, h.session.core);
- try testing.expectEqual(fd, h.session.clients[c.slot].fd);
- try testing.expect(h.session.clients[c.slot].attached);
-
- try dump.dumpState(h.core);
- const saved = try testing.allocator.dupe(u8, h.core.dump_out.?);
- defer testing.allocator.free(saved);
- while (h.core.nextEffect()) |_| {}
- _ = try h.core.setTestFile("changed after dump\n");
- try h.session.restore(saved, "test");
- h.core = h.session.core;
- try testing.expect(h.core != before);
- try testing.expectEqual(fd, h.session.clients[c.slot].fd);
- try testing.expect(h.session.clients[c.slot].attached);
- try testing.expectEqualStrings("saved body\n", h.core.panes[0].?.file.?.content);
- try testing.expect(h.session.clients[c.slot].need_full);
- var wake = [_]libc.pollfd{.{ .fd = h.session.wake[0], .events = poll_in, .revents = 0 }};
- try testing.expectEqual(@as(c_int, 1), libc.poll(&wake, wake.len, 0));
- for (0..Harness.rounds) |_| {
- if ((try h.pumpUntil(&c, .frame)).frame.kind == .full) break;
- } else return error.NoFullReplacement;
- try h.pumpUntilShowsCore(&c);
-}
-
-test "detached selection pipe runs off the loop and returns through the attached frontend" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- const pane = try h.core.setTestFile("one\ntwo\n");
- pane.body.cur_row = 0;
- pane.body.cur_col = 2;
- pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
- var client = try h.attach(60, 16);
- defer client.deinit();
- _ = try h.pumpUntil(&client, .frame);
-
- try client.send(.{ .event = .{ .key = .{ .cp = '|' } } });
- try client.send(.{ .event = .{ .key = .{ .cp = 't', .text = "tr a-z A-Z" } } });
- try client.send(.{ .event = .{ .key = .{ .cp = pardes.Key.enter } } });
- for (0..Harness.rounds) |_| {
- try h.pump();
- try client.wait(5);
- while (try client.next()) |_| {}
- if (std.mem.eql(u8, pane.file.?.content, "ONE\ntwo\n")) break;
- } else return error.PipeDidNotComplete;
- try testing.expect(h.core.pipe.wait == null);
- try testing.expectEqual(@as(usize, 0), h.session.pipe_tasks.len);
- try h.pumpUntilShowsCore(&client);
-}
-
-test "detached session: two frontends share one screen at the smallest common grid" {
- var h: Harness = undefined;
- try h.init(80, 24);
- defer h.deinit();
- var a = try h.attach(80, 24);
- defer a.deinit();
- _ = try h.pumpUntil(&a, .frame);
-
- // A second, smaller frontend. tmux's rule: the session shrinks to what both
- // can show, because two people looking at different screens is the point of
- // a shared session lost.
- var b = try h.attach(50, 12);
- defer b.deinit();
- try testing.expectEqual(@as(u8, 1), b.slot);
- try testing.expectEqual(@as(u16, 50), b.cols);
- try testing.expectEqual(@as(u16, 12), b.rows);
-
- // Both are now on the 50x12 grid — and getting there IS the proof that the
- // reshape was sent as a FULL frame: `next` refuses a diff whose geometry
- // does not match the grid it holds, so a client whose shape moved can only
- // have been reshaped by a full one.
- try h.pumpUntilGrid(&a, 50, 12);
- try h.pumpUntilGrid(&b, 50, 12);
- try testing.expectEqual(@as(usize, 50 * 12), a.grid.items.len);
- // CONVERGENCE, not a snapshot. `pumpUntilGrid(&b, ...)` pumped the session
- // while draining only `b`, and the daemon owns the pane shells now: a
- // prompt arriving on a pty moves the screen between pumps, so `a` can be
- // holding an undrained frame and comparing the two grids here would compare
- // two instants. What a shared session promises is that they agree, which is
- // what this waits for.
- try h.pumpUntilSameScreen(&a, &b);
-
- // ...and input from EITHER moves that one screen. Both are drained on every
- // pump before they are compared: one pump sends every attached frontend a
- // frame, so a test that drains only one is comparing two instants.
- try b.send(.{ .event = .{ .command = "Look /" } });
- _ = try h.pumpUntilChange(&a);
- try h.pumpUntilSameScreen(&a, &b);
-}
-
-test "detached session: a window past the protocol attaches at the largest grid it carries" {
- var h: Harness = undefined;
- try h.init(80, 24);
- defer h.deinit();
-
- // A 4K display at a small font is already past `max_rows`, and until the
- // clamp in `open` that hello was a geometry the session's decoder refused:
- // `apply` answered `BadValue` with `close(.protocol)` and no `refuse`
- // behind it, so a frontend on a big screen was told the session "hung up on
- // the connect" — at a session with every slot free. It attaches now, at the
- // biggest grid the wire has.
- var c = try h.attach(wire.max_cols + 400, wire.max_rows + 70);
- defer c.deinit();
- try testing.expectEqual(wire.max_cols, c.cols);
- try testing.expectEqual(wire.max_rows, c.rows);
-
- // ...and the full frame that follows is the 65536-cell one whose single run
- // does not fit a u16 count (wire.zig `run_max`), which is the half of this
- // the clamp alone would have made universal rather than fixed.
- const frame = (try h.pumpUntil(&c, .frame)).frame;
- try testing.expectEqual(wire.FrameKind.full, frame.kind);
- try testing.expectEqual(@as(usize, @as(usize, wire.max_cols) * wire.max_rows), c.grid.items.len);
- // TWO runs and not one, which is the assertion that fails first if the
- // encoder's bound goes: this grid's full frame is 65536 painted cells and
- // a run counts to 65535.
- try testing.expectEqual(@as(u32, 2), frame.nruns);
- try h.pumpUntilShowsCore(&c);
-}
-
-test "detached session: a frontend that dies takes nothing with it" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- var a = try h.attach(60, 16);
- defer a.deinit();
- var b = try h.attach(60, 16);
- _ = try h.pumpUntil(&a, .frame);
- _ = try h.pumpUntil(&b, .frame);
- try testing.expect(h.session.clients[0].attached);
- try testing.expect(h.session.clients[1].attached);
-
- // Not a `bye`: the socket goes away under the session's feet, which is what
- // a frontend crashing or being killed looks like from here.
- b.deinit();
- _ = try h.pumpUntil(&a, .frame);
- try testing.expect(!h.session.clients[1].attached);
- try testing.expectEqual(@as(c_int, -1), h.session.clients[1].fd);
- // The survivor is still served and the core is still running.
- try testing.expect(h.session.clients[0].attached);
- try testing.expect(!h.core.quit);
- try a.send(.{ .event = .{ .command = "Look /" } });
- try testing.expect((try h.pumpUntilChange(&a)).nruns > 0);
-
- // The freed slot takes the next frontend, and the screen comes with it.
- var d = try h.attach(60, 16);
- defer d.deinit();
- try testing.expectEqual(@as(u8, 1), d.slot);
- try testing.expectEqual(wire.FrameKind.full, (try h.pumpUntil(&d, .frame)).frame.kind);
- // ...and it is the SAME screen the survivor is looking at. Waited for
- // rather than snapshotted, for the reason above: `pumpUntil(&d, ...)`
- // drained only `d`, and pane output means the screen does not stand still
- // between pumps.
- try h.pumpUntilSameScreen(&a, &d);
-}
-
-test "detached session: a frontend speaking another protocol is refused, loudly" {
- // The protocol before this one (v7 carried one-row tags and no regions)
- // and the one after.
- for ([_]u16{ wire.version - 1, wire.version + 1 }) |claimed| try refusedHello(claimed);
-}
-
-fn refusedHello(claimed: u16) !void {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
-
- // A raw socket rather than a `Client`, because the whole point is a peer
- // that does not agree with `wire.version` — and `open` would already have
- // sent a perfectly good hello.
- const fd = try rawConnect(&h);
- defer _ = libc.close(fd);
- var buf: [64]u8 = undefined;
- const hello = try wire.encodeClient(&buf, .{
- .hello = .{ .version = claimed, .cols = 60, .rows = 16 },
- });
- try testing.expectEqual(@as(isize, @intCast(hello.len)), libc.send(fd, hello.ptr, hello.len, nosignal));
-
- // Two pumps: one to accept the connection, one to read the hello and
- // answer it.
- try h.pump();
- try h.pump();
- var got: [64]u8 = undefined;
- const n = libc.read(fd, &got, got.len);
- try testing.expect(n > 0);
- const f = (try wire.framed(got[0..@intCast(n)])).?;
- try testing.expectEqual(wire.Refusal.version, (try wire.decodeServer(f.tag, f.payload)).refuse);
- // Refused means refused: the slot went back and no frame was ever sent.
- for (&h.session.clients) |*slot| try testing.expect(!slot.attached);
- try testing.expect(!h.core.quit);
-}
-
-test "detached frontend: a session speaking another protocol is not attached to" {
- for ([_]u16{ wire.version - 1, wire.version + 1 }) |claimed| {
- var c: Client = .{ .gpa = testing.allocator };
- defer c.deinit();
- var buf: [64]u8 = undefined;
- try c.in.appendSlice(testing.allocator, try wire.encodeServer(&buf, .{ .welcome = .{ .version = claimed, .slot = 0, .cols = 60, .rows = 16 } }));
- try testing.expectError(error.Ungreeted, c.next());
- try testing.expect(!c.attached());
- }
-}
-
-test "detached session: a peer that sends garbage is dropped, not obeyed" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- var c = try h.attach(60, 16);
- defer c.deinit();
- _ = try h.pumpUntil(&c, .frame);
-
- // A well-formed frame around a tag this protocol has never defined. The
- // session must close the connection rather than guess at it.
- const junk = [_]u8{ 0xfe, 0x00, 0x00, 0x00, 0x00 };
- try testing.expectEqual(@as(isize, junk.len), libc.send(c.fd, &junk, junk.len, nosignal));
- for (0..8) |_| {
- try h.pump();
- if (!h.session.clients[0].attached) break;
- }
- try testing.expect(!h.session.clients[0].attached);
- // The session is untouched: a hostile frontend costs a slot, not a session.
- try testing.expect(!h.core.quit);
-}
-
-test "detached session: the session outlives every frontend and keeps its grid" {
- var h: Harness = undefined;
- try h.init(72, 20);
- defer h.deinit();
- {
- var c = try h.attach(40, 10);
- defer c.detach();
- _ = try h.pumpUntil(&c, .frame);
- try testing.expectEqual(@as(u16, 40), h.session.cols);
- }
- // Nobody attached. The grid stays where the last frontend left it rather
- // than collapsing: a detached session is one nobody is looking at, not one
- // of no size.
- try h.pump();
- try testing.expectEqual(@as(u16, 40), h.session.cols);
- try testing.expectEqual(@as(u16, 10), h.session.rows);
- try testing.expect(!h.core.quit);
- // ...and the next frontend takes the grid over: with one attachment the
- // smallest common grid IS that frontend's, so the session follows it up to
- // 90x30 rather than pinning the departed one's 40x10 forever.
- var again = try h.attach(90, 30);
- defer again.deinit();
- try testing.expectEqual(@as(u16, 90), again.cols);
- try testing.expectEqual(@as(u16, 30), again.rows);
- try h.pumpUntilGrid(&again, 90, 30);
- try testing.expectEqual(@as(usize, 90 * 30), again.grid.items.len);
-}
-
-test "detached session: the seam's own routing rules, per surviving effect" {
- var h: Harness = undefined;
- try h.init(60, 16);
- defer h.deinit();
- var a = try h.attach(60, 16);
- defer a.deinit();
- var b = try h.attach(60, 16);
- defer b.deinit();
- _ = try h.pumpUntil(&a, .frame);
- _ = try h.pumpUntil(&b, .frame);
-
- const host = h.session.host();
- // BROADCAST: the yank register is a fact about the session, so every
- // display it is being watched on gets it.
- host.vtable.set_clipboard.?(host.ctx, "yank");
- try expectBoth(&h, &a, &b, .set_clipboard);
-
- // Ask one frontend: two clipboard answers would paste twice.
- h.session.origin = 1;
- host.vtable.read_clipboard.?(host.ctx);
- try expectOnly(&h, &b, &a, .read_clipboard);
- // `open_link` follows the same origin: the browser that opens is the one on
- // the display of the human who clicked, not the oldest attachment's.
- host.vtable.open_link.?(host.ctx, "https://x");
- try expectOnly(&h, &b, &a, .open_link);
- // ...and with no origin it falls back to the primary, which is what a link
- // opened by something other than a keystroke gets.
- h.session.origin = 0;
- host.vtable.open_link.?(host.ctx, "https://y");
- try expectOnly(&h, &a, &b, .open_link);
-}
-
-test "detached session: a frontend is never asked to fork, write, or watch" {
- // THE INVARIANT OF THE WHOLE DETACHED DESIGN, pinned as a property of the
- // protocol rather than of one code path: a frontend is input and screen, so
- // the set of messages that can reach it is exactly the nine below. If a
- // machine-local effect is ever put back on the wire, a frontend becomes the
- // process that owns a pane's shell again — and a pane whose shell belongs to
- // a frontend dies when that frontend leaves, which is the bug this replaced.
- //
- // Adding a name here is meant to be an ARGUMENT, not a formality. The bar is
- // the one `quit` and `detach` clear and `spawn` cannot: it needs this
- // human's screen, keyboard, clipboard or browser, or it is the session
- // telling this frontend about its own membership. Anything that touches a
- // disk or a process table fails that bar by construction.
- const allowed = [_][]const u8{
- // Session control: who this connection is, and whether it is still one.
- // `detach` is this frontend leaving and `quit` is the session ending —
- // opposite meanings, same shape, and neither is an effect.
- "welcome", "refuse", "frame", "quit", "detach",
- // The three that need THIS human's display and cannot be done by a
- // daemon nobody is looking at.
- "set_clipboard", "read_clipboard", "open_link",
- // Display state, like a frame's chrome: the passes this display
- // draws its frames through. A file's SPIR-V arrives compiled, so the
- // frontend still reads no disk and runs no program.
- "post",
- };
-
- // One: the union a frontend decodes into has no other variant. Named
- // rather than counted, so re-adding `spawn` fails with the name in it.
- const fields = @typeInfo(wire.ServerMsg).@"union".field_names;
- inline for (fields) |name| {
- for (allowed) |ok| {
- if (std.mem.eql(u8, name, ok)) break;
- } else {
- std.debug.print("ServerMsg.{s} is not an effect a frontend may perform\n", .{name});
- return error.MachineLocalEffectOnTheWire;
- }
- }
- try testing.expectEqual(allowed.len, fields.len);
-
- // Two: and no TAG BYTE outside them decodes either — the check above is
- // about this build's union, this one is about the bytes on the socket. Every
- // other byte must be `BadTag`, including the eight that used to be defined:
- // a session built before this change cannot talk a frontend into forking.
- var accepted: usize = 0;
- for (0..256) |i| {
- const tag: u8 = @intCast(i);
- // Payloads are deliberately empty: what is asked is whether the TAG is
- // known, and every known tag fails later (`EndOfStream`) or succeeds, but
- // never with `BadTag`.
- if (wire.decodeServer(tag, &.{})) |_| accepted += 1 else |err| switch (err) {
- error.BadTag => continue,
- else => accepted += 1,
- }
- const named = for (allowed) |ok| {
- const want = std.meta.stringToEnum(wire.ServerTag, ok).?;
- if (@backingInt(want) == tag) break true;
- } else false;
- if (!named) {
- std.debug.print("tag 0x{x:0>2} is decodable by a frontend and is not one of the nine\n", .{tag});
- return error.MachineLocalEffectOnTheWire;
- }
- }
- try testing.expectEqual(allowed.len, accepted);
-}
-
-test "detached session: the client table is a refusal, not a queue" {
- // A small grid on purpose: these thirty-two peers never read, and a full
- // frame of 80x24 each would push them into the backlog rule that the next
- // test is about. 20x5 keeps every queue in the kernel's own buffer.
- var h: Harness = undefined;
- try h.init(20, 5);
- defer h.deinit();
-
- var fds: [server.max_clients]c_int = @splat(-1);
- defer for (fds) |fd| if (fd >= 0) {
- _ = libc.close(fd);
- };
- var buf: [64]u8 = undefined;
- const hello = try wire.encodeClient(&buf, .{ .hello = .{ .cols = 20, .rows = 5 } });
- for (&fds) |*fd| {
- fd.* = try rawConnect(&h);
- try testing.expectEqual(@as(isize, @intCast(hello.len)), libc.send(fd.*, hello.ptr, hello.len, nosignal));
- }
- // The listener's backlog is `max_clients` deep, so this takes a few rounds:
- // `accept` drains what is there each time it is woken.
- for (0..16) |_| {
- try h.pump();
- var attached: usize = 0;
- for (&h.session.clients) |*slot| if (slot.attached) {
- attached += 1;
- };
- if (attached == server.max_clients) break;
- }
- for (&h.session.clients) |*slot| try testing.expect(slot.attached);
-
- // The thirty-third is TOLD it does not fit, and told promptly: the
- // alternative — leaving it in the backlog — makes a level-triggered poll
- // report the listener ready forever and spins the core.
- const extra = try rawConnect(&h);
- defer _ = libc.close(extra);
- try testing.expectEqual(@as(isize, @intCast(hello.len)), libc.send(extra, hello.ptr, hello.len, nosignal));
- var got: [64]u8 = undefined;
- const refusal = for (0..8) |_| {
- try h.pump();
- const n = libc.read(extra, &got, got.len);
- if (n > 0) break got[0..@intCast(n)];
- } else return error.NeverRefused;
- const f = (try wire.framed(refusal)).?;
- try testing.expectEqual(wire.Refusal.full, (try wire.decodeServer(f.tag, f.payload)).refuse);
- // ...and the thirty-two it does serve are untouched.
- for (&h.session.clients) |*slot| try testing.expect(slot.attached);
- try testing.expect(!h.core.quit);
-}
-
-test "detached session: a frontend that stops reading is dropped, not waited for" {
- var h: Harness = undefined;
- try h.init(40, 10);
- defer h.deinit();
- var good = try h.attach(40, 10);
- defer good.deinit();
-
- // A peer that says hello and then never reads a byte again — a frontend
- // stopped in a debugger, or one whose terminal is blocked.
- const mute = try rawConnect(&h);
- defer _ = libc.close(mute);
- var buf: [64]u8 = undefined;
- const hello = try wire.encodeClient(&buf, .{ .hello = .{ .cols = 40, .rows = 10 } });
- try testing.expectEqual(@as(isize, @intCast(hello.len)), libc.send(mute, hello.ptr, hello.len, nosignal));
- for (0..8) |_| {
- try h.pump();
- if (h.session.clients[1].attached) break;
- }
- try testing.expect(h.session.clients[1].attached);
-
- // Clipboard updates broadcast to every frontend.
- const text = try testing.allocator.alloc(u8, 256 * 1024);
- defer testing.allocator.free(text);
- @memset(text, 'y');
- const host = h.session.host();
- for (0..24) |_| {
- if (!h.session.clients[1].attached) break;
- host.vtable.set_clipboard.?(host.ctx, text);
- // Read `good` back to EMPTY before the next mirror, rather than
- // pumping once and taking whatever one write fitted. One pump moves at
- // most one socket buffer, and that buffer is 8 KiB here
- // (`net.local.stream.sendspace` on Darwin) against Linux's 208 KiB —
- // so a single pump per 256 KiB mirror leaves the READING frontend
- // falling behind by a quarter megabyte a round and closes it for a
- // backlog it never caused. The claim under test is that a frontend
- // that reads survives, so it has to actually finish reading.
- for (0..256) |_| {
- try h.pump();
- try good.wait(5);
- while (try good.next()) |_| {}
- if (h.session.clients[0].out.items.len == 0) break;
- }
- }
- // Dropped rather than queued without bound, and rather than the core
- // blocking on it.
- try testing.expect(!h.session.clients[1].attached);
- try testing.expectEqual(@as(c_int, -1), h.session.clients[1].fd);
- // The frontend that WAS reading is still attached and still being drawn
- // for, which is the whole claim: one slow peer costs its own slot.
- try testing.expect(h.session.clients[0].attached);
- try testing.expect(!h.core.quit);
- // A message is a tagline band now, not a grid run, so "still being drawn
- // for" is checked on the layers the frontend decoded rather than on nruns.
- try good.send(.{ .event = .{ .command = "Msg still here" } });
- try testing.expect(try pumpUntilNotice(&h, &good, "still here"));
-}
-
-/// Pump until this client has a notice band carrying `want`.
-fn pumpUntilNotice(h: *Harness, c: *Client, want: []const u8) !bool {
- var line: [256]u8 = undefined;
- for (0..Harness.rounds) |_| {
- try h.pump();
- try c.wait(5);
- while (try c.next()) |_| {}
- for (&c.tag_layers) |*layer| {
- if (layer.rows == 0 or layer.kind != .notice) continue;
- var n: usize = 0;
- for (layer.cells[0..layer.cols]) |cell| {
- const g = cell.grapheme();
- if (n + g.len > line.len) break;
- @memcpy(line[n..][0..g.len], g);
- n += g.len;
- }
- if (std.mem.indexOf(u8, line[0..n], want) != null) return true;
- }
- }
- return false;
-}
-
-/// A connected socket with nothing said on it yet, for the tests whose peer is
-/// deliberately not a `Client`: one that speaks another protocol, thirty-two
-/// that fill the table, one that never reads.
-fn rawConnect(h: *Harness) !c_int {
- var path_buf: [server.path_max]u8 = undefined;
- const path = server.sessionPath(&path_buf, h.name).?;
- var addr: libc.sockaddr.un = .{ .path = @splat(0) };
- @memcpy(addr.path[0 .. path.len + 1], path[0 .. path.len + 1]);
- const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM, 0);
- if (fd < 0) return error.NoSocket;
- errdefer _ = libc.close(fd);
- if (libc.connect(fd, @ptrCast(&addr), @sizeOf(@TypeOf(addr))) != 0) return error.NoSession;
- return fd;
-}
-
-/// `want` reached `to` and nothing reached `other`.
-fn expectOnly(
- h: *Harness,
- to: *Client,
- other: *Client,
- comptime want: std.meta.Tag(wire.ServerMsg),
-) !void {
- _ = try h.pumpUntil(to, want);
- try other.wait(5);
- while (try other.next()) |msg| if (std.meta.activeTag(msg) == want) {
- std.debug.print("{t} reached a frontend it was not routed to\n", .{want});
- return error.Misrouted;
- };
-}
-
-fn expectBoth(
- h: *Harness,
- a: *Client,
- b: *Client,
- comptime want: std.meta.Tag(wire.ServerMsg),
-) !void {
- _ = try h.pumpUntil(a, want);
- _ = try h.pumpUntil(b, want);
-}
-
-/// Are these two grids showing the same thing? `visuallyEqual` and not
-/// `std.meta.eql`, because `Cell.text` past `len` is scratch the decoder does
-/// not invent — pardes.zig says in as many words that it must never
-/// manufacture a difference.
-fn sameScreen(want: []const pardes.Cell, have: []const pardes.Cell) bool {
- if (want.len != have.len) return false;
- for (want, have) |*x, *y| if (!x.visuallyEqual(y)) return false;
- return true;
-}
-
-fn expectSameScreen(want: []const pardes.Cell, have: []const pardes.Cell) !void {
- try testing.expectEqual(want.len, have.len);
- for (want, have, 0..) |*x, *y, i| if (!x.visuallyEqual(y)) {
- std.debug.print("cell {d} differs\n", .{i});
- return error.CellMismatch;
- };
-}
diff --git a/src/detached/server.zig b/src/detached/server.zig
deleted file mode 100644
index d7dda6ba..00000000
--- a/src/detached/server.zig
+++ /dev/null
@@ -1,1478 +0,0 @@
-const filesystem = @import("../fs.zig");
-const std = @import("std");
-const builtin = @import("builtin");
-const libc = std.c;
-const posix = std.posix;
-const pardes = @import("../pardes.zig");
-const dump = @import("../dump.zig");
-const wire = @import("wire.zig");
-
-const host_io = @import("../host_io.zig");
-const selection_pipe = @import("../selection_pipe.zig");
-
-const file_watch = @import("../file_watch.zig");
-const ShaderBuild = @import("../ShaderBuild.zig");
-
-const ninep_io = @import("../9p_io.zig");
-
-const look = @import("../look.zig");
-
-const message = pardes.Messages.Message;
-
-const TIOCSWINSZ: c_int = @bitCast(@as(u32, if (@hasDecl(posix.T, "IOCSWINSZ")) posix.T.IOCSWINSZ else 0x80087467));
-
-const log = std.log.scoped(.detached);
-
-pub const darwin = ninep_io.darwin;
-
-const supported = ninep_io.supported;
-
-const sun_path_len = ninep_io.sun_path_len;
-
-pub const max_clients = 32;
-
-const out_backlog = 1 << 20;
-
-const read_chunk = 16 * 1024;
-
-const pty_chunk = 64 * 1024;
-
-const poll_slots = 2 + max_clients + pardes.MAX_PANES + 2 + @as(usize, @intFromBool(ninep_io.quic_enabled));
-
-const reload_retries = 4;
-
-const session_backlog = 2 * @as(usize, wire.max_payload);
-
-const pty_backlog = 1 << 20;
-
-pub const greet_deadline_default_ms: u32 = 5_000;
-
-const idle_retain = read_chunk;
-
-const accept_pause_ms = 100;
-
-const Closed = enum { bye, peer, protocol, backlog, silent, write, read, oom, refused, quitting };
-
-const Client = struct {
- fd: c_int = -1,
- attached: bool = false,
- greet: bool = false,
- cols: u16 = 0,
- rows: u16 = 0,
- in: std.ArrayListUnmanaged(u8) = .empty,
- out: std.ArrayListUnmanaged(u8) = .empty,
- mirror: std.ArrayListUnmanaged(pardes.Cell) = .empty,
- need_full: bool = true,
- accepted_ms: i64 = 0,
- /// The post chain last sent (Session.sendPost); null: none yet.
- post_sent: ?u64 = null,
-};
-
-const Pty = struct {
- fd: c_int = -1,
- pid: posix.pid_t = 0,
- kill_at: i64 = 0,
- out: std.ArrayListUnmanaged(u8) = .empty,
- /// A command pane's child, watched to its exit (host_io.watchExit);
- /// the pty stays open, unpolled after its end of file, until both its
- /// end of file and its exit.
- cmd: host_io.CommandWatch = .{},
-};
-
-/// A watched child exited, or a worker finished: wake the loop.
-fn wakeForExit(ctx: ?*anyopaque) void {
- Session.signal(@ptrCast(@alignCast(ctx.?)));
-}
-
-const RetiredShell = struct { pid: posix.pid_t = 0, kill_at: i64 = 0 };
-
-const Source = union(enum) {
- listener,
- completion,
- client: u8,
- pty: u8,
- inotify,
- ninep_quic,
-};
-
-pub const Session = struct {
- gpa: std.mem.Allocator,
- worker_gpa: std.mem.Allocator,
- io: std.Io,
- core: *pardes.Pardes,
- /// PARDES_TEST_CLOCK's virtual time (host_io.testClock).
- test_clock: ?u64 = null,
- listener: c_int = -1,
- path_buf: [sun_path_len]u8 = undefined,
- path_len: usize = 0,
- clients: [max_clients]Client = @splat(.{}),
- cols: u16,
- rows: u16,
- origin: ?u8 = null,
- scratch: std.ArrayListUnmanaged(u8) = .empty,
- ptys: [pardes.MAX_PANES]Pty = @splat(.{}),
- retired_shells: [pardes.MAX_PANES]RetiredShell = @splat(.{}),
- /// The workers' answers (initAsync sets it up); `wake` is what wakes
- /// the loop's poll for them, and for a watched child's exit.
- inbox: host_io.Inbox = undefined,
- wake: [2]c_int = .{ -1, -1 },
- pipe_tasks: selection_pipe.Tasks = .{},
- prompt_rcs: host_io.Shell.PromptFiles = .{},
- inotify_fd: c_int = -1,
- ninep: ?*ninep_io.Listener = null,
- ninep_pending: bool = false,
- /// A 9P request changed the core since the wake byte was last drained:
- /// the next poll returns at once, to draw it.
- ninep_wake: std.atomic.Value(bool) = .init(false),
- watches: file_watch.Table = @splat(null),
- /// The post chain's files, compiled here for the GUIs attached.
- shaders: ShaderBuild = .{},
- check_files: bool = false,
- in_loop: bool = false,
- greet_deadline_ms: u32 = greet_deadline_default_ms,
- accept_paused_ms: i64 = 0,
-
- pub fn initAsync(s: *Session) !void {
- var pair: [2]c_int = undefined;
- if (libc.socketpair(libc.AF.UNIX, libc.SOCK.STREAM, 0, &pair) != 0) return error.SocketFailed;
- errdefer for (pair) |fd| {
- _ = libc.close(fd);
- };
- for (pair) |fd| {
- if (libc.fcntl(fd, libc.F.SETFD, @as(c_int, 1)) < 0) return error.SocketOptionFailed;
- if (!setNonblock(fd)) return error.SocketOptionFailed;
- if (comptime darwin) {
- const on: c_int = 1;
- if (libc.setsockopt(fd, libc.SOL.SOCKET, libc.SO.NOSIGPIPE, &on, @sizeOf(c_int)) != 0)
- return error.SocketOptionFailed;
- }
- }
- s.wake = pair;
- s.inbox = .{ .gpa = s.worker_gpa, .lsp_allocator = s.worker_gpa, .io = s.io, .wake_fn = wakeForExit, .wake_ctx = s };
- pardes.lsp.setStatusSink(&s.inbox, host_io.Inbox.lspStatus);
- host_io.setExitWake(s, wakeForExit);
- }
-
- fn signal(s: *Session) void {
- while (libc.send(s.wake[1], "w", 1, nosignal) < 0) {
- if (libc.errno(-1) != .INTR) break;
- }
- }
-
- fn cancelWorkers(s: *Session) void {
- if (s.wake[0] < 0) return; // no initAsync: no workers
- if (s.inbox.lsp_task) |*task| {
- task.future.cancel(s.io);
- s.inbox.lsp_task = null;
- }
- s.pipe_tasks.cancelAll(s.io);
- // Its worker may be waiting on the inbox for room.
- s.core.stream.cancelTask();
- _ = s.drainCompletions(false);
- }
-
- fn drainCompletions(s: *Session, apply_results: bool) bool {
- var bytes: [128]u8 = undefined;
- while (libc.recv(s.wake[0], &bytes, bytes.len, 0) > 0) {}
- var batch = s.inbox.take();
- for (batch.slice()) |msg| {
- defer msg.deinit(s.worker_gpa, s.worker_gpa);
- if (!apply_results) continue;
- switch (msg) {
- .lsp => |result| {
- s.core.update(.{ .lsp_resp = .{ .id = result.id, .rows = result.rows } });
- if (s.inbox.lsp_task) |*task| if (task.id == result.id) {
- task.future.await(s.io);
- s.inbox.lsp_task = null;
- };
- },
- .pipe => |result| {
- s.core.update(.{ .pipe_resp = .{
- .id = result.id,
- .success = result.success,
- .outputs = result.outputs,
- .failure = result.failure,
- } });
- s.pipe_tasks.finish(s.io, result.id);
- },
- .lsp_status => |status| {
- var buf: [256]u8 = undefined;
- s.core.setStatus(s.core.active, message.stamp(&buf, "lsp", status));
- },
- .search => |b| s.core.update(.{ .search = b }),
- // Ptys are read in the loop's own poll, not through the inbox.
- // No hand_over host entry here (a session with no window): none comes.
- .output, .eof, .files_changed, .fs_ready, .handed => {},
- }
- }
- return batch.len != 0;
- }
-
- pub fn restore(s: *Session, bytes: []const u8, from: []const u8) !void {
- const replacement = try dump.restore(s.core, bytes, from);
- s.cancelWorkers();
- for (0..s.ptys.len) |pane| s.closePty(@intCast(pane));
- s.harvest();
- for (0..pardes.MAX_PANES) |pane|
- file_watch.watchPane(s.inotify_fd, &s.watches, @intCast(pane), null, 0, .{ .text = 0 });
- _ = file_watch.applyThemeEffect(s.core, s.gpa, s.inotify_fd, &s.watches, 0, false, false);
- // The new core's chain generations are its own.
- s.shaders.generation = null;
- s.check_files = false;
- if (s.ninep) |listener| listener.reset(replacement);
- s.ninep_pending = false;
- replacement.host = s.host();
- s.core.deinit();
- s.core = replacement;
- for (&s.clients) |*client| if (client.attached) {
- client.need_full = true;
- };
- s.signal();
- }
-
- pub fn deinit(s: *Session) void {
- // First: its compile thread wakes the loop, whose socket closes below.
- s.shaders.deinit(s.gpa, s.inotify_fd, &s.watches);
- if (s.wake[0] >= 0) pardes.lsp.setStatusSink(null, null);
- if (s.wake[0] >= 0) host_io.setExitWake(null, null);
- s.cancelWorkers();
- if (s.wake[0] >= 0) s.inbox.close();
- for (s.wake) |fd| if (fd >= 0) {
- _ = libc.close(fd);
- };
- s.wake = .{ -1, -1 };
- if (s.ninep) |l| {
- l.deinit(s.gpa);
- s.ninep = null;
- }
- for (&s.clients) |*c| if (c.attached) s.send(c, .quit);
- for (&s.clients) |*c| if (c.fd >= 0) s.close(c, .quitting);
- s.unlisten();
- s.scratch.deinit(s.gpa);
- for (0..s.ptys.len) |pane| s.closePty(@intCast(pane));
- for (s.retired_shells) |shell| if (shell.pid > 0) {
- _ = libc.kill(shell.pid, libc.SIG.KILL);
- };
- for (s.ptys) |pty| if (pty.pid > 0) {
- _ = libc.kill(pty.pid, libc.SIG.KILL);
- };
- for (&s.retired_shells) |*shell| if (shell.pid > 0) {
- while (libc.waitpid(shell.pid, null, 0) < 0 and libc.errno(-1) == .INTR) {}
- shell.* = .{};
- };
- for (&s.ptys) |*pty| if (pty.pid > 0) {
- while (libc.waitpid(pty.pid, null, 0) < 0 and libc.errno(-1) == .INTR) {}
- pty.pid = 0;
- };
- if (s.inotify_fd >= 0) {
- _ = libc.close(s.inotify_fd);
- s.inotify_fd = -1;
- }
- s.prompt_rcs.deinit();
- }
-
- pub fn listen(s: *Session, name: []const u8) bool {
- if (comptime !supported) return false;
- var dir_buf: [sun_path_len:0]u8 = undefined;
- const dir = ninep_io.socketDir(&dir_buf) orelse return false;
- if (!ninep_io.ensureSocketDir(dir)) return false;
- sweep(dir);
- const path = socketPath(&s.path_buf, dir, name) orelse return false;
- var addr: libc.sockaddr.un = .{ .path = @splat(0) };
- @memcpy(addr.path[0 .. path.len + 1], path[0 .. path.len + 1]);
- const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM, 0);
- if (fd < 0) return false;
- ninep_io.setCloexec(fd);
- if (libc.bind(fd, @ptrCast(&addr), @sizeOf(@TypeOf(addr))) != 0) {
- if (alive(path)) {
- log.debug("a detached session is already listening on {s}", .{path});
- _ = libc.close(fd);
- return false;
- }
- _ = libc.unlink(path);
- if (libc.bind(fd, @ptrCast(&addr), @sizeOf(@TypeOf(addr))) != 0) {
- _ = libc.close(fd);
- return false;
- }
- }
- _ = libc.chmod(path, 0o600);
- if (libc.listen(fd, max_clients) != 0) {
- _ = libc.close(fd);
- return false;
- }
- _ = setNonblock(fd);
- s.listener = fd;
- s.path_len = path.len;
- return true;
- }
-
- fn unlisten(s: *Session) void {
- if (s.listener < 0) return;
- _ = libc.close(s.listener);
- s.listener = -1;
- var z: [sun_path_len:0]u8 = undefined;
- @memcpy(z[0..s.path_len], s.path_buf[0..s.path_len]);
- z[s.path_len] = 0;
- _ = libc.unlink(z[0..s.path_len :0]);
- }
-
- pub fn host(s: *Session) host_io.Host {
- return .{ .ctx = s, .vtable = &vtable };
- }
-
- fn of(ctx: ?*anyopaque) *Session {
- return @ptrCast(@alignCast(ctx.?));
- }
-
- fn clockNow(ctx: ?*anyopaque) u64 {
- const s = of(ctx);
- return s.test_clock orelse @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
- }
-
- const vtable: host_io.Host.VTable = .{
- .wait_input = waitInput,
- .now = clockNow,
- .present = present,
- .poll_frame = pollFrame,
- .watched = watched,
- .spawn = spawn,
- .pty_write = ptyWrite,
- .pty_resize = ptyResize,
- .pty_signal = ptySignal,
- .close_pty = closePaneShell,
- .tty_taken = ttyTaken,
- .fg_name = fgName,
- .kill_job = killJob,
- .write_file = writeFile,
- .write_dump = writeDump,
- .watch_file = watchFile,
- .watch_theme = watchTheme,
- .dump_themes = dumpThemes,
- .set_clipboard = setClipboard,
- .read_clipboard = readClipboard,
- .open_link = openLink,
- .detach = detach,
- .lsp = lspRequest,
- .pipe = pipeRequest,
- .search = searchRequest,
- };
-
- fn searchRequest(ctx: ?*anyopaque, gen: u32) void {
- const s = of(ctx);
- if (s.wake[0] < 0) return pardes.Stream.runHere(s.core, gen);
- pardes.Stream.start(s.io, s.worker_gpa, s.core, gen, &s.inbox, host_io.Inbox.pushSearch);
- }
-
- fn lspRequest(ctx: ?*anyopaque, request: host_io.Lsp.Request) void {
- const s = of(ctx);
- _ = s.drainCompletions(true);
- s.inbox.startLsp(s.core, request);
- }
-
- fn pipeRequest(ctx: ?*anyopaque, id: u32) void {
- const s = of(ctx);
- _ = s.drainCompletions(true);
- selection_pipe.start(s.io, s.worker_gpa, s.core, &s.pipe_tasks, id, &s.inbox, host_io.Inbox.pushPipe);
- }
-
- fn primary(s: *Session) ?*Client {
- for (&s.clients) |*c| if (c.attached) return c;
- return null;
- }
-
- fn origins(s: *Session) ?*Client {
- if (s.origin) |i| {
- const c = &s.clients[i];
- if (c.attached) return c;
- }
- return s.primary();
- }
-
- fn slotOf(s: *Session, c: *const Client) u8 {
- return @intCast(@divExact(@intFromPtr(c) - @intFromPtr(&s.clients[0]), @sizeOf(Client)));
- }
-
- fn broadcast(s: *Session, msg: wire.ServerMsg) void {
- for (&s.clients) |*c| if (c.attached) s.send(c, msg);
- }
-
- fn spawn(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
- const s = of(ctx);
- if (pane >= s.ptys.len) return; // the core indexes its own panes
- s.harvest();
- // The new shell starts before a running one goes: one that cannot
- // start leaves the running one be (pty/ctl's exec).
- const running = s.ptys[pane].fd >= 0;
- if (!running and s.ptys[pane].pid != 0) return s.core.reportError(pane, "shell", error.ShellClosing);
- for (s.retired_shells) |shell| {
- if (shell.pid == 0) break;
- } else return s.core.reportError(pane, "shell", error.ShellClosing);
- const child = host_io.forkShell(
- s.core,
- pane,
- &s.prompt_rcs,
- s.core.shellBin(),
- cwd,
- s.core.screen_h,
- s.core.screen_w,
- s.ninep,
- ) catch |err| {
- if (running) return s.core.restartFailed(pane, err);
- return s.core.shellFailed(pane, err);
- };
- s.closePty(pane);
- s.harvest();
- if (s.ptys[pane].pid != 0) {
- _ = libc.close(child.file.handle);
- host_io.retireShell(child.pid);
- return s.core.reportError(pane, "shell", error.ShellClosing);
- }
- const command = if (s.core.panes[pane]) |pn| pn.command != null else false;
- s.ptys[pane] = .{ .fd = child.file.handle, .pid = child.pid, .cmd = .{ .watched = command and host_io.watchExit(child.pid), .fd = child.file.handle } };
- _ = setNonblock(child.file.handle);
- var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
- // Only a shell given no directory is asked where it is: one given a
- // directory is named by it already (newShell), and asked now, before
- // its chdir, it would answer this process's, a rename to undo.
- if (cwd.len == 0) if (host_io.shellCwd(child.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
- }
-
- fn ptyWrite(ctx: ?*anyopaque, pane: u8, bytes: []const u8) void {
- const s = of(ctx);
- if (pane >= s.ptys.len) return;
- const pt = &s.ptys[pane];
- if (pt.fd < 0) return;
- // The bound holds with this write in: queued and new together.
- if (pt.out.items.len + bytes.len > pty_backlog) {
- var mbuf: [256]u8 = undefined;
- const text = std.fmt.bufPrint(
- &mbuf,
- "input refused: pane not reading ({d} bytes queued)",
- .{pt.out.items.len},
- ) catch "input refused: pane not reading";
- return s.core.setMessage(pane, text);
- }
- pt.out.appendSlice(s.gpa, bytes) catch {
- return s.core.setMessage(pane, "input refused: out of memory");
- };
- s.flushPty(pane);
- }
-
- fn ptyResize(ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void {
- const s = of(ctx);
- if (pane >= s.ptys.len) return;
- const fd = s.ptys[pane].fd;
- if (fd < 0) return;
- // In pixels too, at the last frontend's cell size (8x16 before
- // one attached): a program sizes its kitty graphics by them.
- const ws = host_io.ptyWinsize(s.core, cols, rows);
- _ = posix.system.ioctl(fd, TIOCSWINSZ, @intFromPtr(&ws));
- }
-
- fn ptySignal(ctx: ?*anyopaque, pane: u8, sig: pardes.PtySignal) void {
- const s = of(ctx);
- if (pane >= s.ptys.len) return;
- const pt = s.ptys[pane];
- // A command whose exit is recorded is reaped: its group may be another's.
- if (pt.fd < 0 or pt.cmd.exited) return;
- host_io.signalTty(pt.pid, pt.fd, sig, pt.cmd.watched);
- }
-
- fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
- const s = of(ctx);
- if (pane >= s.ptys.len) return false;
- const pt = s.ptys[pane];
- if (pt.fd < 0) return false;
- return host_io.ttyTaken(pt.pid, pt.fd);
- }
-
- fn fgName(ctx: ?*anyopaque, pane: u8, buf: []u8) ?[]const u8 {
- const s = of(ctx);
- if (pane >= s.ptys.len) return null;
- const pt = s.ptys[pane];
- if (pt.fd < 0) return null;
- return host_io.foregroundName(pt.pid, pt.fd, buf);
- }
-
- fn killJob(ctx: ?*anyopaque, pane: u8) bool {
- const s = of(ctx);
- if (pane >= s.ptys.len) return false;
- const pt = s.ptys[pane];
- if (pt.fd < 0) return false;
- return host_io.killJob(pt.pid, pt.fd);
- }
-
- fn writeFile(ctx: ?*anyopaque, pane: u8, path: []const u8, bytes: []const u8) void {
- const s = of(ctx);
- host_io.writeFile(s.core, &s.watches, pane, path, bytes);
- }
-
- fn writeDump(ctx: ?*anyopaque, bytes: []const u8) void {
- host_io.writeDump(of(ctx).core, bytes);
- }
-
- fn watchFile(ctx: ?*anyopaque, pane: u8, _: []const u8, on: bool, mode: pardes.WatchMode) void {
- const s = of(ctx);
- if (file_watch.applyEffect(s.core, s.io, s.inotify(), &s.watches, pane, on, mode))
- s.check_files = true;
- }
-
- fn watchTheme(ctx: ?*anyopaque, generation: u32, on: bool) void {
- const s = of(ctx);
- if (file_watch.applyThemeEffect(s.core, s.gpa, s.inotify(), &s.watches, generation, on, s.in_loop))
- s.check_files = true;
- }
-
- fn dumpThemes(ctx: ?*anyopaque, pane: u8) void {
- const s = of(ctx);
- host_io.dumpThemes(s.core, s.io, s.gpa, pane);
- }
-
- fn setClipboard(ctx: ?*anyopaque, text: []const u8) void {
- const s = of(ctx);
- s.core.fallback.setClipboard(text);
- s.broadcast(.{ .set_clipboard = text });
- }
-
- fn readClipboard(ctx: ?*anyopaque) void {
- const s = of(ctx);
- if (s.origins()) |c| return s.send(c, .read_clipboard);
- s.core.update(.{ .paste = s.core.fallback.clipboard.items });
- }
-
- fn openLink(ctx: ?*anyopaque, url: []const u8) void {
- const s = of(ctx);
- if (s.origins()) |c| return s.send(c, .{ .open_link = url });
- // No frontend: the session's own desktop is nobody's to open a
- // browser on. Kept, and said, so a script sees the look land.
- s.core.fallback.setLink(url);
- var said: [320]u8 = undefined;
- s.core.setMessage(s.core.active, std.fmt.bufPrint(&said, "look: {s}: no frontend attached to open it in a browser", .{url}) catch "look: no frontend attached to open a link");
- }
-
- fn detach(ctx: ?*anyopaque) void {
- const s = of(ctx);
- if (s.origins()) |c| s.send(c, .detach);
- }
-
- /// A 9P request changed the core: wake the poll loop to draw it.
- fn wakeNinep(ctx: ?*anyopaque) void {
- const s = of(ctx);
- s.ninep_wake.store(true, .release);
- s.signal();
- }
-
- fn watched(ctx: ?*anyopaque) bool {
- const s = of(ctx);
- for (&s.clients) |*c| if (c.attached) return true;
- return false;
- }
-
- fn pollFrame(ctx: ?*anyopaque) void {
- const s = of(ctx);
- if (s.ninep) |l| s.ninep_pending = l.tick().pending;
- for (&s.ptys, 0..) |*pt, pane| {
- if (pt.fd < 0) continue;
- var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
- if (host_io.ttyCwd(pt.pid, pt.fd, s.core.settings.shell.effective.get(), &lbuf)) |cwd| s.core.setCwd(pane, cwd);
- }
- }
-
- fn closePaneShell(ctx: ?*anyopaque, pane: u8) void {
- const s = of(ctx);
- if (pane < s.ptys.len) s.closePty(pane);
- }
-
- fn closePty(s: *Session, pane: u8) void {
- const pt = &s.ptys[pane];
- if (pt.fd < 0) return;
- _ = libc.close(pt.fd);
- pt.fd = -1;
- pt.out.deinit(s.gpa);
- pt.out = .empty;
- if (pt.pid == 0) return;
- _ = libc.kill(pt.pid, libc.SIG.HUP);
- pt.kill_at = std.Io.Clock.awake.now(s.io).toMilliseconds() + 100;
- s.harvest();
- if (pt.pid == 0) return;
- for (&s.retired_shells) |*shell| if (shell.pid == 0) {
- shell.* = .{ .pid = pt.pid, .kill_at = pt.kill_at };
- pt.pid = 0;
- pt.kill_at = 0;
- return;
- };
- }
-
- fn flushPty(s: *Session, pane: u8) void {
- const pt = &s.ptys[pane];
- var off: usize = 0;
- while (off < pt.out.items.len) {
- const n = libc.write(pt.fd, pt.out.items.ptr + off, pt.out.items.len - off);
- if (n < 0) switch (libc.errno(n)) {
- .INTR => continue,
- .AGAIN => break,
- else => {
- s.readPty(pane);
- if (s.ptys[pane].fd >= 0) s.paneEof(pane);
- return;
- },
- };
- if (n == 0) break;
- off += @intCast(n);
- }
- if (off == 0) return;
- if (off == pt.out.items.len) {
- pt.out.clearRetainingCapacity();
- return retire(s.gpa, &pt.out);
- }
- std.mem.copyForwards(u8, pt.out.items, pt.out.items[off..]);
- pt.out.items.len -= off;
- }
-
- fn readPty(s: *Session, pane: u8) void {
- var buf: [pty_chunk]u8 = undefined;
- const got = libc.read(s.ptys[pane].fd, &buf, buf.len);
- if (got == 0) return s.paneEof(pane);
- if (got < 0) return switch (libc.errno(got)) {
- .INTR, .AGAIN => {},
- else => s.paneEof(pane),
- };
- s.core.update(.{ .output = .{ .pane = pane, .bytes = buf[0..@intCast(got)] } });
- }
-
- fn paneEof(s: *Session, pane: u8) void {
- const pt = &s.ptys[pane];
- // A command's pty stays open until its child has exited: closing
- // it would hang up one that runs on without it.
- // Its exit, if it came first, is told now its output is in.
- if (pt.cmd.watched) return host_io.commandEof(s.core, &s.ptys, pane, s, closeWatched);
- // Unwatched, a command's exit is read here, as its end, and a
- // shell's, for a run waiting on it and the log.
- const unwatched = if (s.core.panes[pane]) |pn| pn.command != null else false;
- const status = host_io.exitStatus(pt.pid, 100);
- if (status != null) pt.pid = 0; // reaped: no shell to retire
- s.closePty(pane);
- s.harvest();
- if (unwatched or status != null) s.core.update(.{ .exited = .{ .pane = pane, .status = status } });
- s.core.update(.{ .eof = .{ .pane = pane } });
- }
-
- /// The command panes' exits, told once their output is in (host_io).
- fn takeExits(s: *Session) void {
- host_io.takeExits(s.core, &s.ptys, s, closeWatched);
- }
-
- fn closeWatched(s: *Session, id: usize) void {
- s.closePty(@intCast(id));
- }
-
- fn harvest(s: *Session) void {
- const now = std.Io.Clock.awake.now(s.io).toMilliseconds();
- for (&s.retired_shells) |*shell| host_io.reapRetired(&shell.pid, &shell.kill_at, now);
- for (&s.ptys) |*pty| if (pty.fd < 0) host_io.reapRetired(&pty.pid, &pty.kill_at, now);
- }
-
- fn inotify(s: *Session) c_int {
- if (s.inotify_fd >= 0) return s.inotify_fd;
- s.inotify_fd = file_watch.init(true);
- return s.inotify_fd;
- }
-
- fn drainInotify(s: *Session) void {
- if (file_watch.drain(s.inotify_fd)) s.check_files = true;
- }
-
- fn reloadWatched(s: *Session) void {
- if (!s.check_files) return;
- s.check_files = false;
- s.shaders.recheck();
- for (0..reload_retries) |_| {
- if (!file_watch.reloadChanged(s.core, s.io, s.gpa, &s.watches)) return;
- }
- }
-
- fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
- const s = of(ctx);
- for (&s.clients) |*c| {
- if (!c.attached) continue;
- if (c.out.items.len != 0) continue;
- s.sendFrame(c, surface);
- }
- }
-
- fn sendFrame(s: *Session, c: *Client, surface: *const pardes.Surface) void {
- const cells = surface.cells;
- const want = wire.frameBound(surface.cols, surface.rows) + wire.layersBound(&surface.body_layers, &surface.tag_layers, surface.regionList());
- s.scratch.ensureTotalCapacity(s.gpa, want) catch return s.close(c, .oom);
- const prev: []const pardes.Cell = if (c.need_full or c.mirror.items.len != cells.len)
- &.{}
- else
- c.mirror.items;
- const cursor: ?wire.Cursor = if (surface.cursor) |cur|
- .{ .x = cur.x, .y = cur.y, .bar = cur.bar }
- else
- null;
- const bytes = wire.encodeFrameLayers(
- s.scratch.allocatedSlice()[0..want],
- surface.cols,
- surface.rows,
- cursor,
- surface.pointer_shape,
- cells,
- prev,
- &surface.body_layers,
- &surface.tag_layers,
- surface.regionList(),
- surface.chrome,
- ) catch |err| {
- log.debug("frame {d}x{d} not encodable: {t}", .{ surface.cols, surface.rows, err });
- return;
- };
- s.queue(c, bytes);
- if (c.fd < 0) return; // the queue closed it; the mirror went with it
- c.mirror.resize(s.gpa, cells.len) catch return s.close(c, .oom);
- @memcpy(c.mirror.items, cells);
- c.need_full = false;
- }
-
- fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
- const s = of(ctx);
- // Both before the poll: a wake that landed since the last frame has
- // had its byte drained here and must not be waited for again.
- const drained = s.drainCompletions(true);
- const completed = s.ninep_wake.swap(false, .acq_rel) or drained;
- for (&s.clients) |*c| if (c.fd >= 0) s.flush(c);
- const regridded = s.reconcile();
- // After the greeting reconcile sends: a chain before it is refused.
- const compiled = s.sendPost();
- // Nobody attached, nobody to dismiss a message: the loop expires
- // them itself, between the editor's steps (expireUnattended).
- s.core.unattended = s.primary() == null;
- pardes.Messages.expireUnattended(s.core);
-
- const now = std.Io.Clock.awake.now(s.io).toMilliseconds();
- var fds: [poll_slots]libc.pollfd = undefined;
- var src: [poll_slots]Source = undefined;
- var n: usize = 0;
- if (s.wake[0] >= 0) {
- fds[n] = .{ .fd = s.wake[0], .events = poll_in, .revents = 0 };
- src[n] = .completion;
- n += 1;
- }
- const watching_listener = s.listener >= 0 and now >= s.accept_paused_ms;
- if (watching_listener) {
- fds[n] = .{ .fd = s.listener, .events = poll_in, .revents = 0 };
- src[n] = .listener;
- n += 1;
- }
- for (&s.clients, 0..) |*c, i| {
- if (c.fd < 0) continue;
- fds[n] = .{
- .fd = c.fd,
- .events = if (c.out.items.len != 0) poll_in | poll_out else poll_in,
- .revents = 0,
- };
- src[n] = .{ .client = @intCast(i) };
- n += 1;
- }
- for (&s.ptys, 0..) |*pt, pane| {
- if (pt.fd < 0 or pt.cmd.eof) continue;
- fds[n] = .{
- .fd = pt.fd,
- .events = if (pt.out.items.len != 0) poll_in | poll_out else poll_in,
- .revents = 0,
- };
- src[n] = .{ .pty = @intCast(pane) };
- n += 1;
- }
- if (s.inotify_fd >= 0) {
- fds[n] = .{ .fd = s.inotify_fd, .events = poll_in, .revents = 0 };
- src[n] = .inotify;
- n += 1;
- }
- if (s.ninep) |l| {
- // Unix and TCP connections run on cloud9's runner, which wakes
- // this loop through `wake`; only QUIC is polled here.
- if (comptime ninep_io.quic_enabled) {
- if (l.quic) |*listener| {
- fds[n] = listener.poll();
- src[n] = .ninep_quic;
- n += 1;
- }
- }
- }
- // The wait is the 9P connections' turn with the core.
- if (n == 0) {
- pardes.turn.rest();
- s.io.sleep(.fromMilliseconds(if (timeout_ms == 0) 16 else timeout_ms), .awake) catch {};
- pardes.turn.wake();
- if (timeout_ms != 0) if (s.test_clock) |*virtual| {
- virtual.* = @max(virtual.*, s.core.nextWake() orelse virtual.*);
- };
- return;
- }
- var timeout: c_int = if (timeout_ms == 0) -1 else @intCast(@min(timeout_ms, std.math.maxInt(c_int)));
- if (s.nextWake(now)) |due| timeout = if (timeout < 0) due else @min(timeout, due);
- if (completed or compiled or s.check_files or regridded or s.ninep_pending) timeout = 0;
- pardes.turn.rest();
- const ready = libc.poll(&fds, @intCast(n), timeout);
- pardes.turn.wake();
- if (ready > 0) s.dispatch(fds[0..n], src[0..n]);
- // The core's wake ran out; the pump advances it from `now`.
- if (timeout_ms != 0 and std.Io.Clock.awake.now(s.io).toMilliseconds() -| now >= timeout_ms) if (s.test_clock) |*virtual| {
- virtual.* = @max(virtual.*, s.core.nextWake() orelse virtual.*);
- };
- _ = s.drainCompletions(true);
- s.takeExits();
- s.expire(std.Io.Clock.awake.now(s.io).toMilliseconds());
- s.harvest();
- s.reloadWatched();
- _ = s.reconcile();
- }
-
- fn dispatch(s: *Session, fds: []const libc.pollfd, src: []const Source) void {
- for (fds, src) |pfd, source| switch (source) {
- .listener => if (pfd.revents != 0) s.accept(),
- .completion => {},
- .client => |i| {
- const c = &s.clients[i];
- if (c.fd < 0) continue;
- if (pfd.revents & poll_out != 0) s.flush(c);
- if (c.fd < 0) continue;
- if (pfd.revents & poll_in != 0) {
- s.receive(c, i);
- } else if (pfd.revents & (poll_hup | poll_err | poll_nval) != 0) {
- s.close(c, .peer);
- }
- },
- .pty => |pane| {
- if (s.ptys[pane].fd < 0) continue;
- if (pfd.revents & poll_out != 0) s.flushPty(pane);
- if (s.ptys[pane].fd < 0) continue;
- if (pfd.revents & poll_in != 0) {
- s.readPty(pane);
- } else if (pfd.revents & (poll_hup | poll_err | poll_nval) != 0) {
- s.paneEof(pane);
- }
- },
- .inotify => if (pfd.revents & poll_in != 0) s.drainInotify(),
- .ninep_quic => {},
- };
- }
-
- fn nextWake(s: *const Session, now: i64) ?c_int {
- var due: ?i64 = null;
- for (s.retired_shells) |shell| if (shell.pid != 0) {
- due = now + 10;
- break;
- };
- for (s.ptys) |pty| if (pty.fd < 0 and pty.pid != 0) {
- due = now + 10;
- break;
- };
- for (&s.clients) |*c| {
- if (c.fd < 0 or c.attached) continue;
- const at = c.accepted_ms + @as(i64, s.greet_deadline_ms);
- due = if (due) |d| @min(d, at) else at;
- }
- if (s.listener >= 0 and s.accept_paused_ms > now)
- due = if (due) |d| @min(d, s.accept_paused_ms) else s.accept_paused_ms;
- if (s.ninep) |l| {
- if (l.nextDue()) |ms| {
- const at9 = now + ms;
- due = if (due) |d| @min(d, at9) else at9;
- }
- }
- // Unattended messages go on the clock: look again in a while.
- if (s.core.unattended) for (s.core.panes) |slot| if (slot) |pane| if (pane.msg_len > 0) {
- due = if (due) |d| @min(d, now + 100) else now + 100;
- break;
- };
- const at = due orelse return null;
- return @intCast(@max(0, @min(at - now, std.math.maxInt(c_int))));
- }
-
- fn expire(s: *Session, now: i64) void {
- if (now == 0) return; // no clock: enforce nothing rather than everything
- for (&s.clients) |*c| {
- if (c.fd < 0 or c.attached) continue;
- if (now - c.accepted_ms >= s.greet_deadline_ms) s.close(c, .silent);
- }
- }
-
- fn accept(s: *Session) void {
- for (0..max_clients + 1) |_| {
- const fd = libc.accept(s.listener, null, null);
- if (fd < 0) {
- switch (libc.errno(fd)) {
- .AGAIN, .INTR, .CONNABORTED => return,
- else => {
- s.accept_paused_ms = std.Io.Clock.awake.now(s.io).toMilliseconds() + accept_pause_ms;
- return;
- },
- }
- }
- ninep_io.setCloexec(fd);
- _ = setNonblock(fd);
- if (comptime darwin) {
- const on: c_int = 1;
- _ = libc.setsockopt(fd, libc.SOL.SOCKET, libc.SO.NOSIGPIPE, &on, @sizeOf(c_int));
- }
- const slot = for (&s.clients, 0..) |*c, i| {
- if (c.fd < 0) break i;
- } else {
- s.refuseFd(fd, .full);
- _ = libc.close(fd);
- continue;
- };
- s.clients[slot] = .{ .fd = fd, .accepted_ms = std.Io.Clock.awake.now(s.io).toMilliseconds() };
- }
- }
-
- fn receive(s: *Session, c: *Client, slot: u8) void {
- var buf: [read_chunk]u8 = undefined;
- const got = libc.read(c.fd, &buf, buf.len);
- if (got == 0) return s.close(c, .peer); // clean EOF: the frontend left
- if (got < 0) return switch (libc.errno(got)) {
- .INTR, .AGAIN => {},
- else => s.close(c, .read),
- };
- c.in.appendSlice(s.gpa, buf[0..@intCast(got)]) catch return s.close(c, .oom);
- s.account();
- if (c.fd < 0) return; // it was this one
- s.consume(c, slot);
- }
-
- fn consume(s: *Session, c: *Client, slot: u8) void {
- var off: usize = 0;
- while (true) {
- const found = wire.framed(c.in.items[off..]) catch return s.close(c, .protocol);
- const msg = found orelse break;
- s.apply(c, slot, msg.tag, msg.payload) catch return s.close(c, .protocol);
- if (c.fd < 0) return; // apply closed it, buffers and all
- off += msg.total;
- }
- if (off == 0) return;
- if (off == c.in.items.len) {
- c.in.clearRetainingCapacity();
- return retire(s.gpa, &c.in);
- }
- std.mem.copyForwards(u8, c.in.items, c.in.items[off..]);
- c.in.items.len -= off;
- }
-
- fn apply(s: *Session, c: *Client, slot: u8, tag: u8, payload: []const u8) wire.Error!void {
- if (tag == @backingInt(wire.ClientTag.hello)) {
- if (c.attached) return error.BadValue;
- const claimed = try wire.helloVersion(payload);
- if (claimed != wire.version) {
- log.debug("frontend speaks protocol {d}, this session speaks {d}", .{ claimed, wire.version });
- return s.refuse(c, .version);
- }
- }
- switch (try wire.decodeClient(tag, payload)) {
- .hello => |h| {
- if (s.core.quit) return s.refuse(c, .quitting);
- c.cols = h.cols;
- c.rows = h.rows;
- c.attached = true;
- c.need_full = true;
- c.greet = true;
- // Unwatched until now, it may have drawn nothing: a frame
- // for the one attaching (watched).
- s.core.needs_frame = true;
- },
- .bye => s.close(c, .bye),
- .event => |ev| {
- if (!c.attached) return error.BadValue;
- switch (ev) {
- .resize => |r| {
- c.cols = r.cols;
- c.rows = r.rows;
- if (r.row_metrics) |metrics| s.core.row_metrics = metrics;
- },
- else => {
- s.origin = slot;
- s.core.update(ev);
- },
- }
- },
- }
- }
-
- fn reconcile(s: *Session) bool {
- var cols: u16 = 0;
- var rows: u16 = 0;
- for (&s.clients) |*c| {
- if (!c.attached) continue;
- cols = if (cols == 0) c.cols else @min(cols, c.cols);
- rows = if (rows == 0) c.rows else @min(rows, c.rows);
- }
- var regridded = false;
- // Against the core's size too: a root ctl `size` may have set it
- // while nobody was attached.
- if (cols != 0 and (cols != s.cols or rows != s.rows or cols != s.core.screen_w or rows != s.core.screen_h)) {
- s.cols = cols;
- s.rows = rows;
- for (&s.clients) |*c| c.need_full = true;
- s.core.update(.{ .resize = .{ .cols = cols, .rows = rows } });
- regridded = true;
- }
- for (&s.clients, 0..) |*c, i| {
- if (!c.greet) continue;
- c.greet = false;
- s.send(c, .{ .welcome = .{ .slot = @intCast(i), .cols = s.cols, .rows = s.rows } });
- }
- return regridded;
- }
-
- /// Compiles the post chain's files (a finished compile wakes the loop
- /// through `wake`) and sends each attached frontend the chain it
- /// has not seen: on attach, and when it or a file's SPIR-V changes. True
- /// when a compile was taken in, so the loop draws what it said.
- /// ponytail: a terminal frontend is sent it too and drops it; a hello
- /// saying which frontend it is would spare those bytes.
- fn sendPost(s: *Session) bool {
- const files = for (s.core.settings.post.list()) |entry| {
- if (entry.scene == null) break true;
- } else false;
- const compiled = s.shaders.sync(s.gpa, s.io, s.core, if (files) s.inotify() else s.inotify_fd, &s.watches, .{ .ctx = s, .call = wakeForExit });
- const key = @as(u64, s.shaders.revision) << 8 | @backingInt(s.core.settings.shader_animation);
- var chain: wire.Post = .{ .animation = s.core.settings.shader_animation, .len = s.core.settings.post.len };
- _ = s.shaders.view(&s.core.settings.post, &chain.passes);
- for (&s.clients) |*c| {
- if (!c.attached or c.greet or c.post_sent == key) continue;
- c.post_sent = key;
- s.send(c, .{ .post = chain });
- }
- return compiled;
- }
-
- fn send(s: *Session, c: *Client, msg: wire.ServerMsg) void {
- const want = wire.serverBound(msg);
- s.scratch.ensureTotalCapacity(s.gpa, want) catch return s.close(c, .oom);
- const bytes = wire.encodeServer(s.scratch.allocatedSlice()[0..want], msg) catch |err| {
- log.debug("message {t} not encodable: {t}", .{ msg, err });
- return;
- };
- s.queue(c, bytes);
- }
-
- /// A client's queued output is at most `out_backlog + wire.max_payload`:
- /// past the backlog it is closed, and one frame lands on top of it first
- /// (a frame bigger than the backlog must still go out whole).
- fn queue(s: *Session, c: *Client, bytes: []const u8) void {
- if (c.out.items.len > out_backlog) return s.close(c, .backlog);
- s.account();
- if (c.fd < 0) return; // the fattest peer was this one
- c.out.appendSlice(s.gpa, bytes) catch return s.close(c, .oom);
- s.flush(c);
- }
-
- fn account(s: *Session) void {
- var total: usize = 0;
- var worst: ?*Client = null;
- var worst_bytes: usize = 0;
- for (&s.clients) |*c| {
- if (c.fd < 0) continue;
- const held = c.in.items.len + c.out.items.len;
- total += held;
- if (held > worst_bytes) {
- worst_bytes = held;
- worst = c;
- }
- }
- if (total <= session_backlog) return;
- if (worst) |c| s.close(c, .backlog);
- }
-
- fn flush(s: *Session, c: *Client) void {
- var off: usize = 0;
- while (off < c.out.items.len) {
- const n = libc.send(c.fd, c.out.items.ptr + off, c.out.items.len - off, nosignal);
- if (n < 0) switch (libc.errno(n)) {
- .INTR => continue,
- .AGAIN => break,
- else => return s.close(c, .write),
- };
- if (n == 0) break;
- off += @intCast(n);
- }
- if (off == 0) return;
- if (off == c.out.items.len) {
- c.out.clearRetainingCapacity();
- return retire(s.gpa, &c.out);
- }
- std.mem.copyForwards(u8, c.out.items, c.out.items[off..]);
- c.out.items.len -= off;
- }
-
- fn refuse(s: *Session, c: *Client, why: wire.Refusal) void {
- s.refuseFd(c.fd, why);
- s.close(c, .refused);
- }
-
- fn refuseFd(_: *Session, fd: c_int, why: wire.Refusal) void {
- var buf: [wire.header_len + 1]u8 = undefined;
- // unreachable: a refusal is a header and one byte, which buf is sized to
- const bytes = wire.encodeServer(&buf, .{ .refuse = why }) catch unreachable;
- var off: usize = 0;
- while (off < bytes.len) {
- const n = libc.send(fd, bytes.ptr + off, bytes.len - off, nosignal);
- if (n < 0 and libc.errno(n) == .INTR) continue;
- if (n <= 0) break; // it left before hearing why; nothing to do
- off += @intCast(n);
- }
- }
-
- fn close(s: *Session, c: *Client, why: Closed) void {
- if (c.fd < 0) return;
- log.debug("frontend detached: {t}", .{why});
- _ = libc.close(c.fd);
- c.in.deinit(s.gpa);
- c.out.deinit(s.gpa);
- c.mirror.deinit(s.gpa);
- const gone = s.slotOf(c);
- if (s.origin) |i| if (i == gone) {
- s.origin = null;
- };
- c.* = .{};
- }
-};
-
-/// SIGTERM, SIGINT or SIGHUP: quit as Exit does, through the loop, so its
-/// sockets are unlinked on the way out rather than left for the next
-/// session to trip on. The handler only sets the flag and wakes the loop.
-var quit_signalled = std.atomic.Value(bool).init(false);
-var quit_wake: c_int = -1;
-
-fn onQuitSignal(_: std.posix.SIG) callconv(.c) void {
- quit_signalled.store(true, .release);
- if (quit_wake >= 0) _ = libc.send(quit_wake, "q", 1, nosignal);
-}
-
-/// The screen of a detached session no frontend has sized.
-pub const detached_cols = 160;
-pub const detached_rows = 50;
-
-pub fn run(init: std.process.Init, opts: pardes.Options, name: []const u8) !void {
- // A name a live session holds: said, exit 1, before anything is made
- // (no error trace, no second session racing the first for the socket).
- if (comptime supported) {
- var path_buf: [path_max]u8 = undefined;
- if (sessionPath(&path_buf, name)) |path| if (ninep_io.statNoFollow(path) != null and alive(path)) {
- var said: [path_max + 64]u8 = undefined;
- const text = std.fmt.bufPrint(&said, "pardes: a session named {s} is already running\n", .{name}) catch "pardes: a session of that name is already running\n";
- std.Io.File.stderr().writeStreamingAll(init.io, text) catch {};
- std.process.exit(1);
- };
- }
- const gpa = init.gpa;
- const allocs = pardes.memory.init(gpa);
- defer pardes.memory.deinit();
- var options = opts;
- // No frontend yet, so no size to take: one roomy enough for a script's
- // panes (80x24 left pane/new refused after a few); `size` sets another,
- // and an attaching frontend its own.
- options.cols = detached_cols;
- options.rows = detached_rows;
- options.detached_session = true;
- options.image_allocator = allocs.image;
- options.pdf_allocator = allocs.pdf;
- options.tree_sitter_allocator = allocs.tree_sitter;
- options.frame_allocator = allocs.frame;
-
- pardes.image.start(init.io, allocs.image);
- if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
- pardes.syntax.start(allocs.tree_sitter);
- defer {
- pardes.image.stop();
- if (comptime pardes.pdf_enabled) pardes.pdf.stop();
- pardes.syntax.stop();
- }
-
- const core = if (options.load_path) |lp| blk: {
- const bytes = try filesystem.readFile(gpa, lp);
- defer gpa.free(bytes);
- break :blk try pardes.dump.initFromDump(allocs.pardes, options, bytes);
- } else try pardes.Pardes.init(allocs.pardes, options);
- var session: Session = .{
- .gpa = gpa,
- .worker_gpa = allocs.lsp,
- .io = init.io,
- .core = core,
- .cols = options.cols,
- .rows = options.rows,
- .prompt_rcs = host_io.Shell.prepare(),
- .test_clock = host_io.testClock(),
- };
- defer session.core.deinit();
- defer session.deinit();
- try session.initAsync();
- if (!session.listen(name)) {
- try std.Io.File.stderr().writeStreamingAll(init.io, "pardes: could not bind a detached session socket\n");
- std.process.exit(1);
- }
-
- session.ninep = ninep_io.listen(init.io, gpa, core, opts.ninep_name, name, opts.ninep_tcp, opts.ninep_quic);
- if (session.ninep == null) return error.ListenFailed;
- session.ninep.?.wake_ctx = &session;
- session.ninep.?.wake = Session.wakeNinep;
-
- const h = session.host();
- core.host = h;
- while (core.nextEffect()) |effect| core.perform(effect);
- session.in_loop = true;
- quit_wake = session.wake[1];
- const on_quit: std.posix.Sigaction = .{ .handler = .{ .handler = onQuitSignal }, .mask = std.posix.sigemptyset(), .flags = 0 };
- for ([_]std.posix.SIG{ .HUP, .INT, .TERM }) |sig| std.posix.sigaction(sig, &on_quit, null);
- defer quit_wake = -1;
- while (!session.core.quit and !quit_signalled.load(.acquire)) {
- pardes.turn.bump(&pardes.turn.restores);
- try session.core.pump(h);
- if (session.core.quit) break;
- if (session.core.takeRestore()) |path| restore: {
- const bytes = filesystem.readRestore(gpa, path, session.core.settings.dump_dir.get()) catch |err| {
- session.core.reportError(session.core.active, "Restore", err);
- break :restore;
- };
- defer gpa.free(bytes);
- session.restore(bytes, path) catch |err| session.core.reportError(session.core.active, "Restore", err);
- }
- }
-}
-
-test "a link looked at with no frontend attached opens no browser, and says so" {
- const gpa = std.testing.allocator;
- var s: Session = .{
- .gpa = gpa,
- .worker_gpa = gpa,
- .io = std.testing.io,
- .core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }),
- .cols = 40,
- .rows = 12,
- };
- defer s.core.deinit();
- defer s.deinit();
- Session.openLink(&s, "https://example.com/x");
- try std.testing.expectEqualStrings("https://example.com/x", s.core.fallback.link.items);
- const pane = s.core.panes[s.core.active].?;
- try std.testing.expectEqualStrings("look: https://example.com/x: no frontend attached to open it in a browser", pane.msg[0..pane.msg_len]);
-}
-
-test "detached queued results preserve current requests and are discarded before Restore" {
- const gpa = std.testing.allocator;
- var s: Session = .{
- .gpa = gpa,
- .worker_gpa = gpa,
- .io = std.testing.io,
- .core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }),
- .cols = 40,
- .rows = 12,
- };
- defer s.core.deinit();
- defer s.deinit();
- try s.initAsync();
- while (s.core.nextEffect()) |_| {}
- _ = try s.core.setTestFile("saved body\n");
- s.core.lspRequest(0, .status, "");
- const old_id = s.core.lsp_wait.?.id;
- s.core.lspRequest(0, .status, "");
- const current_id = s.core.lsp_wait.?.id;
- s.inbox.lsp_id = current_id;
- s.inbox.lsp_task = .{ .id = current_id, .future = .{ .any_future = null, .result = {} } };
- // The inbox turns the superseded answer away.
- s.inbox.push(.{ .lsp = .{ .id = old_id, .rows = try gpa.dupe(u8, "old result\n") } });
- try std.testing.expectEqual(@as(usize, 0), s.inbox.completion_len);
- _ = s.drainCompletions(true);
- try std.testing.expectEqual(current_id, s.inbox.lsp_task.?.id);
- try std.testing.expectEqual(current_id, s.core.lsp_wait.?.id);
-
- try dump.dumpState(s.core);
- const saved = try gpa.dupe(u8, s.core.dump_out.?);
- defer gpa.free(saved);
- while (s.core.nextEffect()) |_| {}
- s.inbox.push(.{ .lsp = .{ .id = current_id, .rows = try gpa.dupe(u8, "queued before restore\n") } });
- const outputs = try gpa.alloc([]u8, 1);
- outputs[0] = try gpa.dupe(u8, "old filter output\n");
- try std.testing.expect(s.pipe_tasks.add(.{ .id = 77, .future = .{ .any_future = null, .result = {} } }));
- s.inbox.push(.{ .pipe = .{ .id = 77, .success = true, .outputs = outputs } });
- host_io.Inbox.lspStatus(&s.inbox, "old status");
- try s.restore(saved, "test");
- try std.testing.expect(s.inbox.lsp_task == null);
- try std.testing.expectEqual(@as(usize, 0), s.pipe_tasks.len);
- try std.testing.expect(!s.drainCompletions(true));
- try std.testing.expectEqualStrings("saved body\n", s.core.panes[0].?.file.?.content);
-
- s.core.lspRequest(0, .status, "");
- const restored_id = s.core.lsp_wait.?.id;
- try std.testing.expect(restored_id > current_id);
- s.inbox.lsp_id = restored_id;
- s.inbox.lsp_task = .{ .id = restored_id, .future = .{ .any_future = null, .result = {} } };
- s.inbox.push(.{ .lsp = .{ .id = current_id, .rows = try gpa.dupe(u8, "late old result\n") } });
- _ = s.drainCompletions(true);
- try std.testing.expectEqual(restored_id, s.inbox.lsp_task.?.id);
- try std.testing.expectEqual(restored_id, s.core.lsp_wait.?.id);
- s.inbox.push(.{ .lsp = .{ .id = restored_id, .rows = &.{} } });
- const host = s.host();
- host.vtable.wait_input.?(host.ctx, 1);
- try std.testing.expect(s.inbox.lsp_task == null);
- try std.testing.expect(s.core.lsp_wait == null);
-}
-
-test "a detached session's terminal pane takes its shell with it when it closes" {
- const gpa = std.testing.allocator;
- var s: Session = .{
- .gpa = gpa,
- .worker_gpa = gpa,
- .io = std.testing.io,
- .core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }),
- .cols = 40,
- .rows = 12,
- };
- defer s.core.deinit();
- defer s.deinit();
- // A stand-in shell: it waits for a signal, and a hangup ends it.
- const pid = libc.fork();
- if (pid == 0) while (true) {
- _ = libc.poll(&[0]libc.pollfd{}, 0, -1);
- };
- try std.testing.expect(pid > 0);
- var fds: [2]c_int = undefined;
- try std.testing.expectEqual(@as(c_int, 0), libc.pipe(&fds));
- defer _ = libc.close(fds[1]);
- s.ptys[3] = .{ .fd = fds[0], .pid = pid };
- const host = s.host();
- host.vtable.close_pty.?(host.ctx, 3);
- try std.testing.expect(s.ptys[3].fd < 0);
- const deadline = std.Io.Clock.awake.now(std.testing.io).toMilliseconds() + 2000;
- while (std.Io.Clock.awake.now(std.testing.io).toMilliseconds() < deadline) {
- s.harvest();
- const running = s.ptys[3].pid != 0 or for (s.retired_shells) |shell| {
- if (shell.pid == pid) break true;
- } else false;
- if (!running) break;
- _ = libc.poll(&[0]libc.pollfd{}, 0, 5);
- }
- try std.testing.expect(s.ptys[3].pid == 0);
- for (s.retired_shells) |shell| try std.testing.expect(shell.pid != pid);
-}
-
-test "detached worker setup failure completes requests without changing document bytes" {
- const gpa = std.testing.allocator;
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- var s: Session = .{
- .gpa = gpa,
- .worker_gpa = failing.allocator(),
- .io = std.testing.io,
- .core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }),
- .cols = 40,
- .rows = 12,
- };
- defer s.core.deinit();
- defer s.deinit();
- try s.initAsync();
- while (s.core.nextEffect()) |_| {}
- const pane = try s.core.setTestFile("one\n");
- s.core.host = s.host();
- s.core.lspRequest(0, .status, "");
- while (s.core.nextEffect()) |effect| s.core.perform(effect);
- try std.testing.expect(s.core.lsp_wait == null);
- try std.testing.expect(s.inbox.lsp_task == null);
-
- pane.body.cur_col = 2;
- pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
- s.core.update(.{ .key = .{ .cp = '|' } });
- s.core.update(.{ .key = .{ .cp = 't', .text = "tr a-z A-Z" } });
- s.core.update(.{ .key = .{ .cp = pardes.Key.enter } });
- try std.testing.expect(s.core.pipe.wait != null);
- while (s.core.nextEffect()) |effect| s.core.perform(effect);
- try std.testing.expect(s.core.pipe.wait == null);
- try std.testing.expectEqual(@as(usize, 0), s.pipe_tasks.len);
- try std.testing.expectEqualStrings("one\n", pane.file.?.content);
- try std.testing.expect(failing.has_induced_failure);
-}
-
-pub const setCloexec = ninep_io.setCloexec;
-
-pub fn setNonblock(fd: c_int) bool {
- const flags = libc.fcntl(fd, libc.F.GETFL, @as(c_int, 0));
- if (flags < 0) return false;
- var o: libc.O = @bitCast(@as(u32, @bitCast(flags)));
- o.NONBLOCK = true;
- return libc.fcntl(fd, libc.F.SETFL, @as(c_int, @bitCast(@as(u32, @bitCast(o))))) >= 0;
-}
-
-pub const nosignal: u32 = if (darwin) 0 else libc.MSG.NOSIGNAL;
-
-pub const poll_in: i16 = @intCast(libc.POLL.IN);
-pub const poll_out: i16 = @intCast(libc.POLL.OUT);
-pub const poll_hup: i16 = @intCast(libc.POLL.HUP);
-pub const poll_err: i16 = @intCast(libc.POLL.ERR);
-pub const poll_nval: i16 = @intCast(libc.POLL.NVAL);
-
-fn retire(gpa: std.mem.Allocator, list: *std.ArrayListUnmanaged(u8)) void {
- if (list.items.len != 0 or list.capacity <= idle_retain) return;
- list.clearAndFree(gpa);
-}
-
-pub fn socketPath(buf: *[sun_path_len]u8, dir: []const u8, name: []const u8) ?[:0]const u8 {
- if (name.len == 0) return null;
- if (std.mem.indexOfAny(u8, name, "/\x00") != null) return null;
- return std.fmt.bufPrintSentinel(buf, "{s}/" ++ prefix ++ "{s}.sock", .{ dir, name }, 0) catch null;
-}
-
-const prefix = "pardes-detached-";
-
-pub const path_max = sun_path_len;
-
-pub fn sessionPath(buf: *[path_max]u8, name: []const u8) ?[:0]const u8 {
- if (comptime !supported) return null;
- var dir_buf: [sun_path_len:0]u8 = undefined;
- const dir = ninep_io.socketDir(&dir_buf) orelse return null;
- return socketPath(buf, dir, name);
-}
-
-pub fn vetted(path: [:0]const u8) bool {
- if (comptime !supported) return false;
- var dir_buf: [sun_path_len:0]u8 = undefined;
- const dir = ninep_io.socketDir(&dir_buf) orelse return false;
- if (!ours(ninep_io.statNoFollow(dir) orelse return false, s_ifdir)) return false;
- return ours(ninep_io.statNoFollow(path) orelse return false, s_ifsock);
-}
-
-const s_ifmt: u32 = 0o170000;
-const s_ifdir: u32 = 0o040000;
-const s_ifsock: u32 = 0o140000;
-
-fn ours(st: ninep_io.FileFacts, kind: u32) bool {
- if (st.mode & s_ifmt != kind) return false;
- if (st.uid != libc.getuid()) return false;
- return st.mode & 0o077 == 0;
-}
-
-fn alive(path: [:0]const u8) bool {
- var addr: libc.sockaddr.un = .{ .path = @splat(0) };
- if (path.len + 1 > addr.path.len) return true;
- @memcpy(addr.path[0 .. path.len + 1], path[0 .. path.len + 1]);
- const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM, 0);
- if (fd < 0) return true;
- defer _ = libc.close(fd);
- ninep_io.setCloexec(fd);
- _ = setNonblock(fd);
- const rc = libc.connect(fd, @ptrCast(&addr), @sizeOf(@TypeOf(addr)));
- if (rc == 0) return true;
- return libc.errno(rc) != .CONNREFUSED;
-}
-
-fn sweep(dir: [:0]const u8) void {
- const d = libc.opendir(dir) orelse return;
- defer _ = libc.closedir(d);
- while (libc.readdir(d)) |ent| {
- const name = std.mem.sliceTo(&ent.name, 0);
- if (!std.mem.startsWith(u8, name, prefix) or !std.mem.endsWith(u8, name, ".sock")) continue;
- var path_buf: [sun_path_len:0]u8 = undefined;
- const path = std.fmt.bufPrintSentinel(&path_buf, "{s}/{s}", .{ dir, name }, 0) catch continue;
- if (!alive(path)) _ = libc.unlink(path);
- }
-}
diff --git a/src/detached/wire.zig b/src/detached/wire.zig
index 0e141686..20d75274 100644
--- a/src/detached/wire.zig
+++ b/src/detached/wire.zig
@@ -1,32 +1,13 @@
-//! Detached input and frames use fixed-width little-endian fields and explicit tags.
-//! Native struct layout never reaches the wire.
+//! The framed stream a remote client will speak (docs/next-daemon.md,
+//! phase 5): fixed-width little-endian fields and explicit tags, the hello
+//! and its version, and the input Events. Native struct layout never reaches
+//! the wire. The cell frames that went the other way, and the frontends that
+//! drew them, went with phase 3.
const std = @import("std");
const pardes = @import("../pardes.zig");
-const limits = @import("../memory.zig").limits;
-const ShaderBuild = @import("../ShaderBuild.zig");
-const Scene = pardes.config.Runtime.Scene;
-const ShaderAnimation = pardes.config.Runtime.ShaderAnimation;
-/// 7: tag layers gained the `.notice` kind, so a frame can carry a tag value
-/// an older frontend would reject mid-session. The greeting is where that has
-/// to be refused, which is what this number is for.
-/// 8: one layer type: a tag band carries all its rows (not a layer per
-/// line), and a frame carries the core's placed regions after its layers.
-pub const version: u16 = 12;
-
-/// The Chrome palette is carried field by field as its declaration lists
-/// them, so any change to it changes the wire: bump `version`, then this.
-const chrome_layout: u64 = 0xbe608bed776ff502;
-comptime {
- @setEvalBranchQuota(10_000);
- var hash = std.hash.Fnv1a_64.init();
- const info = @typeInfo(pardes.Chrome).@"struct";
- for (info.field_names, info.field_types) |name, T| {
- hash.update(name);
- hash.update(@typeName(T));
- }
- if (hash.final() != chrome_layout) @compileError(std.fmt.comptimePrint("pardes.Chrome changed (layout 0x{x}): bump wire.version, then chrome_layout", .{hash.final()}));
-}
+/// 13: the frames, and every message a session sent, are gone (phase 3).
+pub const version: u16 = 13;
/// EndOfStream: the message ends early; WriteFailed: no room for it.
/// ReadFailed is in only because std.Io.Reader says so: a fixed one never
@@ -38,16 +19,6 @@ pub const max_rows: u16 = 128;
pub const max_payload: u32 = 16 << 20;
pub const header_len = 5; // tag:u8, payload length:u32le
-const cell_max = 1 + 1 + 7 + 4 + 4 + 1 + 1 + 1;
-const run_header = 4 + 2; // start:u32, count:u16
-const run_max = std.math.maxInt(u16);
-const frame_head = 1 + 2 + 2 + 6 + 4 + 4;
-
-// Worst case: every cell changed, each in its own run.
-pub fn frameBound(cols: u16, rows: u16) usize {
- return header_len + frame_head + @as(usize, cols) * @as(usize, rows) * (run_header + cell_max);
-}
-
// Stable wire numbers; gaps are retired tags. Unknown tags are rejected by the decoder.
pub const ClientTag = enum(u8) {
hello = 0x01,
@@ -65,43 +36,6 @@ pub const ClientTag = enum(u8) {
focus = 0x1e,
};
-// Session control precedes display-local effects.
-pub const ServerTag = enum(u8) {
- welcome = 0x01,
- refuse = 0x02,
- frame = 0x03,
- quit = 0x04,
- /// One frontend is done, and the session is NOT over. The `Detach` word,
- /// routed back to the frontend whose keystroke ran it (server.zig ORIGIN,
- /// ELSE PRIMARY, the same rule `read_clipboard` takes and for the same
- /// reason). Every other frontend, the core and the pane shells are
- /// untouched, so leaving is success rather than a failure to report.
- detach = 0x05,
-
- set_clipboard = 0x10,
- read_clipboard = 0x11,
- open_link = 0x12,
- /// The post chain this frontend draws its frames through: sent on
- /// attach and whenever it or a file's SPIR-V changes.
- post = 0x13,
-};
-
-/// Why the server hung up on a connect. Sent as a `refuse` and followed by a
-/// close, so a frontend can say something specific instead of "connection
-/// closed".
-pub const Refusal = enum(u8) {
- /// `Hello.version` is not `version`. The frontend and the core are two
- /// builds of pardes.
- version = 0x01,
- /// Every client slot is taken (see server.zig `max_clients`).
- full = 0x02,
- /// The core has already quit; this session is ending.
- quitting = 0x03,
-};
-
-const ColorTag = enum(u8) { default = 0x00, index = 0x01, rgb = 0x02 };
-const UlTag = enum(u8) { off = 0x00, single = 0x01, double = 0x02, curly = 0x03, dotted = 0x04, dashed = 0x05 };
-const FontTag = enum(u8) { body = 0x00, tagline = 0x01 };
const ButtonTag = enum(u8) {
left = 0x00,
middle = 0x01,
@@ -116,24 +50,6 @@ const ButtonTag = enum(u8) {
};
const KindTag = enum(u8) { press = 0x00, release = 0x01, motion = 0x02, drag = 0x03 };
-/// A full frame resets the receiver's grid to unpainted cells and then applies
-/// its runs; a diff applies its runs on top of what is already there. One bit
-/// of semantics and one code path, and it is what makes a full frame of a
-/// mostly-empty grid cheap.
-pub const FrameKind = enum(u8) { full = 0x01, diff = 0x02 };
-const FrameHeader = enum(u8) { full = 0x01, diff = 0x02, full_link = 0x03, diff_link = 0x04 };
-
-/// Bit per `CellStyle` bool, packed into one byte. Bit 7 is unassigned and a
-/// set bit 7 is a decode error: it is a byte this protocol cannot mean.
-const attr_bold: u8 = 1 << 0;
-const attr_dim: u8 = 1 << 1;
-const attr_italic: u8 = 1 << 2;
-const attr_blink: u8 = 1 << 3;
-const attr_reverse: u8 = 1 << 4;
-const attr_invisible: u8 = 1 << 5;
-const attr_strikethrough: u8 = 1 << 6;
-const attr_reserved: u8 = 1 << 7;
-
// ---------------------------------------------------------------------------
// messages
// ---------------------------------------------------------------------------
@@ -143,8 +59,8 @@ const attr_reserved: u8 = 1 << 7;
/// when the rest of the layout is the part that changed.
pub const Hello = struct {
version: u16 = version,
- /// This frontend's grid. Never zero — see `Cursor` for why zero is refused
- /// rather than clamped.
+ /// This client's grid. Never zero: a client not sized yet must not
+ /// collapse a shared session (getCols).
cols: u16,
rows: u16,
};
@@ -166,182 +82,6 @@ pub fn helloVersion(payload: []const u8) Error!u16 {
return r.takeInt(u16, .little);
}
-pub const Welcome = struct {
- version: u16 = version,
- /// Which client slot this connection got. Carried because it is what the
- /// server's own diagnostics name, so both sides say the same number.
- slot: u8,
- /// The session's grid as of this attach — the smallest common one, which
- /// may be smaller than the `Hello` asked for. See server.zig `geometry`.
- cols: u16,
- rows: u16,
-};
-
-pub const Cursor = struct { x: u16, y: u16, bar: bool };
-
-/// One frame, head decoded and runs left encoded. The runs are NOT expanded
-/// into a slice of cells here: a frame of the largest grid is 1.6 MiB, this
-/// union is passed by value, and the receiver already owns the grid the runs
-/// belong in. `apply` is the bounds-checked walk.
-pub const Frame = struct {
- layers: []const u8 = &.{},
- pointer_shape: pardes.Surface.PointerShape = .arrow,
- kind: FrameKind,
- cols: u16,
- rows: u16,
- cursor: ?Cursor,
- nruns: u32,
- runs: []const u8,
-
- pub fn applyLayers(f: Frame, gpa: std.mem.Allocator, layers: *[pardes.MAX_PANES]pardes.Layer, tags: *[pardes.MAX_TAG_LAYERS]pardes.Layer, regions: *std.ArrayListUnmanaged(pardes.Region), chrome: *pardes.Chrome) !void {
- regions.clearRetainingCapacity();
- chrome.* = .{};
- for (layers) |*layer| {
- gpa.free(layer.cells);
- layer.* = .{};
- }
- for (tags) |*layer| {
- gpa.free(layer.cells);
- layer.* = .{};
- }
- errdefer {
- for (layers) |*layer| {
- gpa.free(layer.cells);
- layer.* = .{};
- }
- for (tags) |*layer| {
- gpa.free(layer.cells);
- layer.* = .{};
- }
- regions.clearRetainingCapacity();
- chrome.* = .{};
- }
- if (f.layers.len == 0) return;
- var r: std.Io.Reader = .fixed(f.layers);
- const count = try r.takeInt(u16, .little);
- if (count > layers.len) return error.Overlong;
- for (layers[0..count]) |*layer| {
- layer.kind = .body;
- layer.id = try r.takeInt(u16, .little);
- layer.serial = try r.takeInt(u32, .little);
- layer.viewport = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) };
- layer.cols = try r.takeInt(u16, .little);
- layer.rows = try r.takeInt(u16, .little);
- layer.context_rows = try r.takeInt(u16, .little);
- if (layer.id >= pardes.MAX_PANES or layer.cols == 0 or layer.cols > f.cols or
- layer.rows == 0 or layer.rows > 2 * max_rows or layer.context_rows > layer.rows or layer.context_rows > limits.wrap_rows or
- layer.viewport.x > f.cols or layer.viewport.w > f.cols - layer.viewport.x or
- layer.viewport.y > f.rows or layer.viewport.h > f.rows - layer.viewport.y) return error.BadValue;
- for (0..layer.context_rows) |row| {
- if (try getBool(&r)) layer.context_separators.set(row);
- }
- const cursor = try getCursor(&r, layer.cols, layer.rows);
- layer.cursor = if (cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null;
- layer.cells = try gpa.alloc(pardes.Cell, @as(usize, layer.cols) * layer.rows);
- for (layer.cells) |*cell| cell.* = try decodeCell(&r);
- }
- const tag_count = try r.takeInt(u16, .little);
- if (tag_count > tags.len) return error.Overlong;
- for (tags[0..tag_count]) |*layer| {
- layer.kind = try getTag(&r, pardes.TagKind);
- layer.id = try r.takeInt(u16, .little);
- layer.serial = try r.takeInt(u32, .little);
- layer.viewport = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) };
- layer.cols = try r.takeInt(u16, .little);
- layer.rows = try r.takeInt(u16, .little);
- for (&layer.bg) |*channel| channel.* = try r.takeByte();
- if (layer.cols == 0 or layer.viewport.w == 0 or layer.rows == 0 or layer.rows > pardes.MAX_TAG_ROWS or
- layer.viewport.h != layer.rows or
- layer.viewport.x > f.cols or layer.viewport.w > f.cols - layer.viewport.x or
- layer.viewport.y >= f.rows or layer.viewport.h > f.rows - layer.viewport.y or (switch (layer.kind) {
- .workspace => layer.id != 0,
- .column => layer.id >= pardes.MAX_COLS,
- .pane, .notice => layer.id >= pardes.MAX_PANES,
- .body => true,
- })) return error.BadValue;
- const cursor = try getCursor(&r, layer.cols, layer.rows);
- layer.cursor = if (cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null;
- layer.cells = try gpa.alloc(pardes.Cell, @as(usize, layer.cols) * layer.rows);
- for (layer.cells) |*cell| cell.* = try decodeCell(&r);
- }
- const region_count = try r.takeInt(u16, .little);
- if (region_count > pardes.MAX_REGIONS) return error.Overlong;
- try regions.ensureTotalCapacity(gpa, region_count);
- for (0..region_count) |_| {
- var region: pardes.Region = .{ .kind = try getTag(&r, pardes.Region.Kind), .rect = undefined };
- region.owner = try r.takeByte();
- region.serial = try r.takeInt(u32, .little);
- region.rect = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) };
- const flags = try r.takeByte();
- if (flags > 3) return error.BadValue;
- region.active = flags & 1 != 0;
- region.dirty = flags & 2 != 0;
- region.thumb_y = try r.takeInt(u16, .little);
- region.thumb_h = try r.takeInt(u16, .little);
- region.notice = try r.takeByte();
- region.clip = try r.takeInt(u16, .little);
- region.lift = @bitCast(try r.takeInt(u32, .little));
- region.line = @bitCast(try r.takeInt(u32, .little));
- // A springy flavour overshoots, and a wind-up dips below.
- if (!(region.lift >= -1 and region.lift <= 2)) return error.BadValue;
- if (region.rect.x > f.cols or region.rect.w > f.cols - region.rect.x or
- region.rect.y > f.rows or region.rect.h > f.rows - region.rect.y or
- region.clip > region.rect.w or region.thumb_y > region.rect.h or region.thumb_h > region.rect.h - region.thumb_y) return error.BadValue;
- regions.appendAssumeCapacity(region);
- }
- const info = @typeInfo(pardes.Chrome).@"struct";
- inline for (info.field_names, info.field_types) |name, T| {
- const rgb = &@field(chrome, name);
- if (T == ?[3]u8) {
- if (try getBool(&r)) {
- rgb.* = .{ 0, 0, 0 };
- for (&rgb.*.?) |*channel| channel.* = try r.takeByte();
- }
- } else if (T == u8) {
- rgb.* = try r.takeByte();
- } else if (T == u32) {
- rgb.* = try r.takeInt(u32, .little);
- } else if (T == f32) {
- rgb.* = @bitCast(try r.takeInt(u32, .little));
- if (!std.math.isFinite(rgb.*)) return error.BadValue;
- } else if (T == [8]f32) {
- for (rgb) |*value| {
- value.* = @bitCast(try r.takeInt(u32, .little));
- if (!std.math.isFinite(value.*)) return error.BadValue;
- }
- } else for (rgb) |*channel| channel.* = try r.takeByte();
- }
- try end(&r);
- }
-
- /// Paint this frame into `grid`, which must be exactly `cols * rows` cells
- /// — the receiver resizes on a geometry change before applying, and a grid
- /// of the wrong size is a receiver bug, not a wire condition.
- ///
- /// Every run is range-checked against the grid before a single cell is
- /// written, so a run claiming to start past the end writes nothing.
- pub fn apply(f: Frame, grid: []pardes.Cell) Error!void {
- if (grid.len != @as(usize, f.cols) * @as(usize, f.rows)) return error.BadValue;
- if (f.kind == .full) @memset(grid, .{});
- var r: std.Io.Reader = .fixed(f.runs);
- var i: u32 = 0;
- while (i < f.nruns) : (i += 1) {
- const start = try r.takeInt(u32, .little);
- const count = try r.takeInt(u16, .little);
- // A zero-length run is not something `encodeFrameLayers` emits, and
- // accepting one would let a peer spend the run budget saying
- // nothing.
- if (count == 0) return error.BadValue;
- // THE bounds check. Written as `count > len - start` rather than
- // `start + count > len` because the sum of two attacker-chosen
- // 32-bit numbers is the classic way this check is bypassed.
- if (start > grid.len or count > grid.len - start) return error.Overlong;
- for (grid[start..][0..count]) |*c| c.* = try decodeCell(&r);
- }
- try end(&r);
- }
-};
-
/// Frontend -> core, decoded. The `Event`'s slices BORROW the payload buffer,
/// exactly like the pty chunks the tty host hands to `update`: valid for that
/// one call and no longer.
@@ -351,38 +91,6 @@ pub const ClientMsg = union(enum) {
event: pardes.Event,
};
-/// Core -> frontend, decoded. Slices borrow the payload buffer the same way.
-pub const ServerMsg = union(enum) {
- welcome: Welcome,
- refuse: Refusal,
- frame: Frame,
- /// The session is over. Sent before the listener closes so a frontend can
- /// exit rather than report a broken pipe.
- quit,
- /// One frontend is done, and the session is NOT over — see `ServerTag`.
- detach,
-
- set_clipboard: []const u8,
- read_clipboard,
- open_link: []const u8,
- post: Post,
-};
-
-/// The session's post chain, as a GUI attached to it draws it: its passes in
-/// order, each a bundled scene at its level or a Shadertoy file's SPIR-V
-/// (compiled by the session, ShaderBuild.zig: a frontend reads no disk and
-/// runs no program), and when it animates on its own. Slices borrow the
-/// payload.
-pub const Post = struct {
- animation: ShaderAnimation = .on,
- passes: [ShaderBuild.max]ShaderBuild.Pass = @splat(.{}),
- len: u8 = 0,
-
- pub fn list(p: *const Post) []const ShaderBuild.Pass {
- return p.passes[0..p.len];
- }
-};
-
// ---------------------------------------------------------------------------
// primitives
// ---------------------------------------------------------------------------
@@ -491,367 +199,12 @@ pub fn framed(buf: []const u8) Error!?Framed {
}
// ---------------------------------------------------------------------------
-// cells
-// ---------------------------------------------------------------------------
-
-fn putColor(w: *std.Io.Writer, c: pardes.Color) Error!void {
- switch (c) {
- .default => try w.writeByte(@backingInt(ColorTag.default)),
- .index => |i| {
- try w.writeByte(@backingInt(ColorTag.index));
- try w.writeByte(i);
- },
- .rgb => |v| {
- try w.writeByte(@backingInt(ColorTag.rgb));
- try w.writeAll(&v);
- },
- }
-}
-
-fn getColor(r: *std.Io.Reader) Error!pardes.Color {
- return switch (try getTag(r, ColorTag)) {
- .default => .default,
- .index => .{ .index = try r.takeByte() },
- .rgb => .{ .rgb = (try r.take(3))[0..3].* },
- };
-}
-
-const Ul = @FieldType(pardes.CellStyle, "ul");
-
-/// The four enum mappings — underline, font role, mouse button, mouse kind —
-/// and `clientTag`/`serverTag` further down all have one shape: the WIRE
-/// member of the same NAME. So the byte on the socket is still `@intFromEnum`
-/// of an explicitly numbered enum in THIS file and never of a core type —
-/// reordering `CellStyle.ul` changes nothing — and adding a variant to the
-/// core without adding one here does not compile:
-///
-/// error: enum 'wire.UlTag' has no member named 'wavy'
-///
-/// which is the whole property the six hand-written switches this replaced
-/// existed for, in a form that cannot fall out of step. A variant that has to
-/// travel under a DIFFERENT name than the core's gets an arm of its own before
-/// the `inline else`, exactly as `clientTag` keeps the machine-local reports.
-fn putUl(w: *std.Io.Writer, u: Ul) Error!void {
- try w.writeByte(switch (u) {
- inline else => |t| @backingInt(@field(UlTag, @tagName(t))),
- });
-}
-
-fn getUl(r: *std.Io.Reader) Error!Ul {
- return switch (try getTag(r, UlTag)) {
- inline else => |t| @field(Ul, @tagName(t)),
- };
-}
-
-fn putFont(w: *std.Io.Writer, f: pardes.FontRole) Error!void {
- try w.writeByte(switch (f) {
- inline else => |t| @backingInt(@field(FontTag, @tagName(t))),
- });
-}
-
-fn getFont(r: *std.Io.Reader) Error!pardes.FontRole {
- return switch (try getTag(r, FontTag)) {
- inline else => |t| @field(pardes.FontRole, @tagName(t)),
- };
-}
-
-/// How many bytes `putCell` will write. Exact, because `encodeFrameLayers` weighs it
-/// against `run_header` to decide whether to coalesce a run across it.
-fn cellSize(c: *const pardes.Cell) usize {
- if (c.default) return 1;
- return 1 + 1 + c.len + colorSize(c.style.fg) + colorSize(c.style.bg) + 1 + 1 + 1;
-}
-
-fn colorSize(c: pardes.Color) usize {
- return switch (c) {
- .default => 1,
- .index => 2,
- .rgb => 4,
- };
-}
-
-/// An unpainted cell is ONE byte: `default` means "the shell renders the
-/// terminal's default cell" (surface.zig `Cell`), so its text and style are not
-/// merely equal to the defaults, they are not part of the frame at all.
-fn putCell(w: *std.Io.Writer, c: *const pardes.Cell) Error!void {
- try w.writeByte(@intFromBool(c.default));
- if (c.default) return;
- try w.writeByte(c.len);
- try w.writeAll(c.grapheme());
- const s = c.style;
- try putColor(w, s.fg);
- try putColor(w, s.bg);
- var attrs: u8 = 0;
- if (s.bold) attrs |= attr_bold;
- if (s.dim) attrs |= attr_dim;
- if (s.italic) attrs |= attr_italic;
- if (s.blink) attrs |= attr_blink;
- if (s.reverse) attrs |= attr_reverse;
- if (s.invisible) attrs |= attr_invisible;
- if (s.strikethrough) attrs |= attr_strikethrough;
- try w.writeByte(attrs);
- try putUl(w, s.ul);
- try putFont(w, s.font_role);
-}
-
-fn decodeCell(r: *std.Io.Reader) Error!pardes.Cell {
- if (try getBool(r)) return .{};
- var c: pardes.Cell = .{ .default = false };
- const len = try r.takeByte();
- // `Cell.text` is 7 bytes and `grapheme()` slices to `len`. A zero-length
- // grapheme is a cell with nothing to draw and no way to advance a column.
- if (len == 0 or len > c.text.len) return error.BadValue;
- c.len = len;
- @memcpy(c.text[0..len], try r.take(len));
- c.style.fg = try getColor(r);
- c.style.bg = try getColor(r);
- const attrs = try r.takeByte();
- if (attrs & attr_reserved != 0) return error.BadValue;
- c.style.bold = attrs & attr_bold != 0;
- c.style.dim = attrs & attr_dim != 0;
- c.style.italic = attrs & attr_italic != 0;
- c.style.blink = attrs & attr_blink != 0;
- c.style.reverse = attrs & attr_reverse != 0;
- c.style.invisible = attrs & attr_invisible != 0;
- c.style.strikethrough = attrs & attr_strikethrough != 0;
- c.style.ul = try getUl(r);
- c.style.font_role = try getFont(r);
- return c;
-}
-
-// ---------------------------------------------------------------------------
-// frames
-// ---------------------------------------------------------------------------
-
-fn putCursor(w: *std.Io.Writer, cursor: ?Cursor, cols: u16, rows: u16) Error!void {
- // Fixed six bytes whether or not there is a cursor. An optional field
- // would save five bytes on a message that is already hundreds, and cost a
- // branch on both sides of the wire.
- try w.writeByte(@intFromBool(cursor != null));
- const c = cursor orelse Cursor{ .x = 0, .y = 0, .bar = false };
- // Refused here as well as on decode, so this side cannot build a frame its
- // own decoder rejects: a dropped frame (sendFrame logs it) leaves a stale
- // screen, and a refused one takes the frontend's connection with it.
- if (c.x >= cols or c.y >= rows) return error.BadValue;
- try w.writeInt(u16, c.x, .little);
- try w.writeInt(u16, c.y, .little);
- try w.writeByte(@intFromBool(c.bar));
-}
-
-fn getCursor(r: *std.Io.Reader, cols: u16, rows: u16) Error!?Cursor {
- const present = try getBool(r);
- const c: Cursor = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .bar = try getBool(r) };
- // THE cursor bounds check. Every other field of a frame is checked against
- // the grid and these two were not, and they are the two a frontend indexes
- // with directly — `Surface.at(cursor.x, cursor.y)` on a grid this frame
- // says is 4x2 is an out-of-bounds write in EVERY frontend, not a wrong
- // glyph. Checked whether or not the cursor is present, because the absent
- // case is six bytes of padding this encoder writes as zero and a peer that
- // fills them with anything else is not speaking this protocol.
- if (c.x >= cols or c.y >= rows) return error.BadValue;
- return if (present) c else null;
-}
-
-pub fn layersBound(layers: []const pardes.Layer, tags: []const pardes.Layer, regions: []const pardes.Region) usize {
- var n: usize = 6;
- for (layers) |layer| if (layer.rows != 0) {
- n += 26 + layer.context_rows + layer.cells.len * cell_max;
- };
- for (tags) |layer| if (layer.rows != 0) {
- n += 28 + layer.cells.len * cell_max;
- };
- return n + regions.len * region_len + chrome_len;
-}
-
-const region_len = 1 + 1 + 4 + 8 + 1 + 2 + 2 + 1 + 2 + 4 + 4;
-/// The palette: each colour three bytes, a theme's optional ones a flag
-/// before them.
-const chrome_len = @typeInfo(pardes.Chrome).@"struct".field_names.len * 4 + 8 * 4;
-
-/// Encode one frame of `cells`, as a DIFF against `prev` when `prev` is the
-/// same grid this receiver last acknowledged, and as a FULL frame otherwise.
-///
-/// A late joiner and a resize are the same case and are handled by the same
-/// test: nothing on the far side is comparable to this grid, so `prev` is
-/// empty or a different length and the frame becomes full.
-///
-/// Why a diff at all. Measured against a real `pardes --detach` at 80x24 with
-/// the default theme, which paints every cell and gives most of them an rgb
-/// pair (14 bytes a cell rather than the 8 an uncoloured one costs):
-/// * a full frame is 21965-26699 bytes, depending on what is on screen,
-/// * a frame that changes nothing is 20 — the head, and no runs at all,
-/// * a one-row change (`Msg hi`) is 54 bytes in one run, and a wordier one
-/// 166,
-/// * and an IDLE session sends nothing whatever, because the core is asleep
-/// in `poll(2)` and produces no frame until something happens.
-/// So the diff is worth roughly 500x on the traffic a session actually
-/// generates. The byte-count test below asserts the arithmetic on the board's
-/// own 56x14 grid with uncoloured cells, where it is exact: 6298 against 56.
-/// This transport exists for a frontend on the far end of a slow link, and
-/// shipping the Surface every frame would be 3 MiB/s at the animation tick.
-pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, pointer_shape: pardes.Surface.PointerShape, cells: []const pardes.Cell, prev: []const pardes.Cell, layers: []const pardes.Layer, tags: []const pardes.Layer, regions: []const pardes.Region, chrome: pardes.Chrome) Error![]const u8 {
- // The protocol's ceiling, enforced by the ENCODER too, and BEFORE the
- // assert below so a caller can be told rather than tripped. `max_payload`
- // is derived from these two, so a larger grid is a frame this decoder
- // refuses as Overlong — and sendFrame's log line already claims that this
- // is the error it is catching, which was true of nothing until here.
- if (cols == 0 or cols > max_cols or rows == 0 or rows > max_rows) return error.Overlong;
- std.debug.assert(cells.len == @as(usize, cols) * @as(usize, rows));
- const full = prev.len != cells.len;
- var w: std.Io.Writer = .fixed(out);
- const at = try beginMessage(&w, @backingInt(ServerTag.frame));
- const header: FrameHeader = if (pointer_shape == .link)
- (if (full) .full_link else .diff_link)
- else
- (if (full) .full else .diff);
- try w.writeByte(@backingInt(header));
- try w.writeInt(u16, cols, .little);
- try w.writeInt(u16, rows, .little);
- try putCursor(&w, cursor, cols, rows);
- const layers_len_at = w.end;
- try w.writeInt(u32, 0, .little);
- const layers_start = w.end;
- if (layers.len != 0 or tags.len != 0 or regions.len != 0) {
- var count: u16 = 0;
- for (layers) |layer| if (layer.rows != 0) {
- count += 1;
- };
- try w.writeInt(u16, count, .little);
- for (layers) |layer| {
- if (layer.rows == 0) continue;
- if (layer.context_rows > limits.wrap_rows or layer.context_rows > layer.rows) return error.BadValue;
- try w.writeInt(u16, layer.id, .little);
- try w.writeInt(u32, layer.serial, .little);
- try w.writeInt(u16, layer.viewport.x, .little);
- try w.writeInt(u16, layer.viewport.y, .little);
- try w.writeInt(u16, layer.viewport.w, .little);
- try w.writeInt(u16, layer.viewport.h, .little);
- try w.writeInt(u16, layer.cols, .little);
- try w.writeInt(u16, layer.rows, .little);
- try w.writeInt(u16, layer.context_rows, .little);
- for (0..layer.context_rows) |row| try w.writeByte(@intFromBool(layer.context_separators.isSet(row)));
- try putCursor(&w, if (layer.cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null, layer.cols, layer.rows);
- for (layer.cells) |*cell| try putCell(&w, cell);
- }
- var tag_count: u16 = 0;
- for (tags) |layer| if (layer.rows != 0) {
- tag_count += 1;
- };
- try w.writeInt(u16, tag_count, .little);
- for (tags) |layer| {
- if (layer.rows == 0) continue;
- if (layer.cells.len != @as(usize, layer.cols) * layer.rows) return error.BadValue;
- try w.writeByte(@backingInt(layer.kind));
- try w.writeInt(u16, layer.id, .little);
- try w.writeInt(u32, layer.serial, .little);
- try w.writeInt(u16, layer.viewport.x, .little);
- try w.writeInt(u16, layer.viewport.y, .little);
- try w.writeInt(u16, layer.viewport.w, .little);
- try w.writeInt(u16, layer.viewport.h, .little);
- try w.writeInt(u16, layer.cols, .little);
- try w.writeInt(u16, layer.rows, .little);
- for (layer.bg) |channel| try w.writeByte(channel);
- try putCursor(&w, if (layer.cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null, layer.cols, layer.rows);
- for (layer.cells) |*cell| try putCell(&w, cell);
- }
- try w.writeInt(u16, @intCast(regions.len), .little);
- for (regions) |region| {
- try w.writeByte(@backingInt(region.kind));
- try w.writeByte(region.owner);
- try w.writeInt(u32, region.serial, .little);
- try w.writeInt(u16, region.rect.x, .little);
- try w.writeInt(u16, region.rect.y, .little);
- try w.writeInt(u16, region.rect.w, .little);
- try w.writeInt(u16, region.rect.h, .little);
- try w.writeByte(@as(u8, @intFromBool(region.active)) | @as(u8, @intFromBool(region.dirty)) << 1);
- try w.writeInt(u16, region.thumb_y, .little);
- try w.writeInt(u16, region.thumb_h, .little);
- try w.writeByte(region.notice);
- try w.writeInt(u16, region.clip, .little);
- try w.writeInt(u32, @bitCast(region.lift), .little);
- try w.writeInt(u32, @bitCast(region.line), .little);
- }
- const info = @typeInfo(pardes.Chrome).@"struct";
- inline for (info.field_names, info.field_types) |name, T| {
- const rgb = @field(chrome, name);
- if (T == ?[3]u8) {
- try w.writeByte(@intFromBool(rgb != null));
- if (rgb) |value| for (value) |channel| try w.writeByte(channel);
- } else if (T == u8) {
- try w.writeByte(rgb);
- } else if (T == u32) {
- try w.writeInt(u32, rgb, .little);
- } else if (T == f32) {
- try w.writeInt(u32, @bitCast(rgb), .little);
- } else if (T == [8]f32) {
- for (rgb) |value| try w.writeInt(u32, @bitCast(value), .little);
- } else for (rgb) |channel| try w.writeByte(channel);
- }
- }
- std.mem.writeInt(u32, w.buffer[layers_len_at..][0..4], @intCast(w.end - layers_start), .little);
- const nruns_at = w.end;
- try w.writeInt(u32, 0, .little);
-
- var nruns: u32 = 0;
- var i: usize = 0;
- while (i < cells.len) {
- if (!sendCell(cells, prev, full, i)) {
- i += 1;
- continue;
- }
- const start = i;
- var run_end = i + 1;
- i += 1;
- // `i - start` and not `run_end - start`, because the gap lookahead
- // below moves `i` ahead of `run_end` by up to `run_header - 1` before
- // the next iteration adopts it: bounding the cursor bounds the run,
- // and bounding the run afterwards would not.
- while (i < cells.len and i - start < run_max) {
- if (sendCell(cells, prev, full, i)) {
- run_end = i + 1;
- i += 1;
- continue;
- }
- // A gap. Re-sending cells the far side already has is cheaper than
- // a second run header whenever their encoded size adds up to less
- // than one — true for short stretches of unpainted cells at a byte
- // each, and false as soon as one painted cell (eight bytes at its
- // smallest) is in the way. So the lookahead can never need to pass
- // `run_header - 1` cells.
- var gap: usize = 0;
- var j = i;
- while (j < cells.len and gap < run_header) : (j += 1) {
- if (sendCell(cells, prev, full, j)) break;
- gap += cellSize(&cells[j]);
- }
- if (j >= cells.len or gap >= run_header) break;
- i = j;
- }
- try w.writeInt(u32, @intCast(start), .little);
- try w.writeInt(u16, @intCast(run_end - start), .little);
- for (cells[start..run_end]) |*c| try putCell(&w, c);
- nruns += 1;
- i = run_end;
- }
- std.mem.writeInt(u32, w.buffer[nruns_at..][0..4], nruns, .little);
- try finishMessage(&w, at);
- return w.buffered();
-}
-
-fn sendCell(cells: []const pardes.Cell, prev: []const pardes.Cell, full: bool, i: usize) bool {
- // Full: the receiver reset the grid, so unpainted cells are already right.
- // Diff: anything the receiver cannot already be showing.
- if (full) return !cells[i].default;
- return !cells[i].visuallyEqual(&prev[i]);
-}
-
-// ---------------------------------------------------------------------------
// frontend -> core
// ---------------------------------------------------------------------------
/// Which tag a message travels under: the `ClientTag` of the same NAME, so a
-/// new `Event` variant does not compile until it has a number here. See
-/// `putUl` for the error it produces and why this is not a written-out table.
+/// new `Event` variant does not compile until it has a number here, rather
+/// than a written-out table that can drift.
fn clientTag(msg: ClientMsg) ClientTag {
return switch (msg) {
.event => |ev| switch (ev) {
@@ -1054,81 +407,12 @@ pub fn decodeClient(tag: u8, payload: []const u8) Error!ClientMsg {
return msg;
}
-// ---------------------------------------------------------------------------
-// core -> frontend
-// ---------------------------------------------------------------------------
-
-/// ...and the same rule in the same shape: the `ServerTag` of the same name.
-fn serverTag(msg: ServerMsg) ServerTag {
- return switch (msg) {
- inline else => |_, t| @field(ServerTag, @tagName(t)),
- };
-}
-
-/// Every server message EXCEPT a frame, which has its own encoder because its
-/// payload is a walk of two grids rather than a value (see `encodeFrameLayers`).
-pub fn encodeServer(out: []u8, msg: ServerMsg) Error![]const u8 {
- var w: std.Io.Writer = .fixed(out);
- const at = try beginMessage(&w, @backingInt(serverTag(msg)));
- switch (msg) {
- .welcome => |v| {
- try w.writeInt(u16, v.version, .little);
- try w.writeByte(v.slot);
- try w.writeInt(u16, v.cols, .little);
- try w.writeInt(u16, v.rows, .little);
- },
- .refuse => |why| try w.writeByte(@backingInt(why)),
- // A frame's runs are not a value this union can hold; the server calls
- // encodeFrameLayers directly and this arm exists so the switch stays
- // exhaustive over ServerMsg.
- .frame => return error.BadValue,
- .quit, .detach => {},
- .set_clipboard => |t| try putSlice32(&w, t),
- .read_clipboard => {},
- .open_link => |u| try putSlice16(&w, u),
- .post => |p| {
- try w.writeByte(@backingInt(p.animation));
- try w.writeByte(p.len);
- for (p.list()) |pass| {
- // 0 a file, else a bundled scene and one.
- try w.writeByte(if (pass.scene) |scene| @as(u8, @backingInt(scene)) + 1 else 0);
- try w.writeByte(pass.level);
- try w.writeByte(@intFromBool(pass.animated));
- try w.writeInt(u32, pass.revision, .little);
- try putSlice16(&w, pass.path);
- try putSlice32(&w, pass.spirv);
- }
- },
- }
- try finishMessage(&w, at);
- return w.buffered();
-}
-
/// Slack over a message's variable payload, covering every fixed field any
-/// message here has plus its own header. One loose constant rather than a
-/// field-by-field count: a bound that is 32 bytes generous costs one `memcpy`
-/// worth of nothing, and a bound that is one byte tight is a bug that only
-/// shows up on the message nobody tested.
+/// message here has plus its own header.
const msg_slack = header_len + 64;
-/// An upper bound on `encodeServer`'s output, so a caller sizes its buffer
+/// An upper bound on `encodeClient`'s output, so a caller sizes its buffer
/// once instead of guessing and retrying.
-pub fn serverBound(msg: ServerMsg) usize {
- return msg_slack + switch (msg) {
- .welcome, .refuse, .quit, .detach, .read_clipboard => 0,
- // A frame is bounded by its grid, not by this: see `frameBound`.
- .frame => |f| frameBound(f.cols, f.rows),
- .set_clipboard => |t| t.len,
- .open_link => |u| u.len,
- .post => |p| blk: {
- var n: usize = 0;
- for (p.list()) |pass| n += 13 + pass.path.len + pass.spirv.len;
- break :blk n;
- },
- };
-}
-
-/// ...and the same for the frontend's side of the wire.
pub fn clientBound(msg: ClientMsg) usize {
return msg_slack + switch (msg) {
.hello, .bye => 0,
@@ -1143,76 +427,6 @@ pub fn clientBound(msg: ClientMsg) usize {
};
}
-pub fn decodeServer(tag: u8, payload: []const u8) Error!ServerMsg {
- var r: std.Io.Reader = .fixed(payload);
- const msg: ServerMsg = switch (std.enums.fromInt(ServerTag, tag) orelse return error.BadTag) {
- .welcome => .{ .welcome = .{
- .version = try r.takeInt(u16, .little),
- .slot = try r.takeByte(),
- .cols = try getCols(&r),
- .rows = try getRows(&r),
- } },
- .refuse => .{ .refuse = try getTag(&r, Refusal) },
- .frame => blk: {
- const header = try getTag(&r, FrameHeader);
- const kind: FrameKind = switch (header) {
- .full, .full_link => .full,
- .diff, .diff_link => .diff,
- };
- const cols = try getCols(&r);
- const rows = try getRows(&r);
- const cursor = try getCursor(&r, cols, rows);
- const layers = try getSlice32(&r);
- const nruns = try r.takeInt(u32, .little);
- // One run per cell is the worst an encoder emits, so a bigger
- // count cannot be describing this grid. Checked HERE rather than
- // in `apply`'s loop so the number is refused before it is used to
- // bound anything.
- if (nruns > @as(u32, cols) * @as(u32, rows)) return error.Overlong;
- const runs = r.buffered();
- r.tossBuffered();
- break :blk .{ .frame = .{
- .layers = layers,
- .kind = kind,
- .pointer_shape = if (header == .full_link or header == .diff_link) .link else .arrow,
- .cols = cols,
- .rows = rows,
- .cursor = cursor,
- .nruns = nruns,
- .runs = runs,
- } };
- },
- .quit => .quit,
- .detach => .detach,
- .set_clipboard => .{ .set_clipboard = try getSlice32(&r) },
- .read_clipboard => .read_clipboard,
- .open_link => .{ .open_link = try r.take(try r.takeInt(u16, .little)) },
- .post => blk: {
- var p: Post = .{ .animation = try getTag(&r, ShaderAnimation) };
- p.len = try r.takeByte();
- if (p.len > ShaderBuild.max) return error.Overlong;
- for (p.passes[0..p.len]) |*pass| {
- const kind = try r.takeByte();
- pass.* = .{
- .scene = if (kind == 0) null else std.enums.fromInt(Scene, kind - 1) orelse return error.BadValue,
- .level = try r.takeByte(),
- .animated = switch (try r.takeByte()) {
- 0 => false,
- 1 => true,
- else => return error.BadValue,
- },
- .revision = try r.takeInt(u32, .little),
- .path = try r.take(try r.takeInt(u16, .little)),
- .spirv = try getSlice32(&r),
- };
- }
- break :blk .{ .post = p };
- },
- };
- try end(&r);
- return msg;
-}
-
// ---------------------------------------------------------------------------
// tests
// ---------------------------------------------------------------------------
@@ -1233,13 +447,6 @@ fn roundClient(buf: []u8, msg: ClientMsg) !ClientMsg {
return decodeClient(f.tag, f.payload);
}
-fn roundServer(buf: []u8, msg: ServerMsg) !ServerMsg {
- const bytes = try encodeServer(buf, msg);
- const f = (try framed(bytes)).?;
- try testing.expectEqual(bytes.len, f.total);
- return decodeServer(f.tag, f.payload);
-}
-
test "detached wire: every Event variant round-trips" {
var buf: [4096]u8 = undefined;
@@ -1311,50 +518,6 @@ test "detached wire: every Event variant round-trips" {
);
}
-test "detached wire: every server message round-trips" {
- var buf: [4096]u8 = undefined;
-
- {
- const got = (try roundServer(&buf, .{ .welcome = .{ .slot = 2, .cols = 56, .rows = 14 } })).welcome;
- try testing.expectEqual(version, got.version);
- try testing.expectEqual(@as(u8, 2), got.slot);
- try testing.expectEqual(@as(u16, 56), got.cols);
- try testing.expectEqual(@as(u16, 14), got.rows);
- }
- for (std.enums.values(Refusal)) |why|
- try testing.expectEqual(why, (try roundServer(&buf, .{ .refuse = why })).refuse);
- try testing.expectEqual(ServerMsg.quit, try roundServer(&buf, .quit));
- try testing.expectEqual(ServerMsg.detach, try roundServer(&buf, .detach));
- try testing.expectEqualStrings("yank", (try roundServer(&buf, .{ .set_clipboard = "yank" })).set_clipboard);
- try testing.expectEqual(ServerMsg.read_clipboard, try roundServer(&buf, .read_clipboard));
- try testing.expectEqualStrings("https://x", (try roundServer(&buf, .{ .open_link = "https://x" })).open_link);
- var chain: Post = .{ .animation = .always, .len = 2 };
- chain.passes[0] = .{ .scene = .bloom, .level = 3 };
- chain.passes[1] = .{ .path = "~/wave.glsl", .spirv = "\x03\x02\x23\x07spirv", .revision = 7, .animated = true };
- const back = (try roundServer(&buf, .{ .post = chain })).post;
- try testing.expectEqual(ShaderAnimation.always, back.animation);
- try testing.expectEqual(@as(u8, 2), back.len);
- try testing.expectEqual(Scene.bloom, back.passes[0].scene.?);
- try testing.expectEqual(@as(u8, 3), back.passes[0].level);
- try testing.expect(back.passes[1].scene == null);
- try testing.expectEqualStrings("~/wave.glsl", back.passes[1].path);
- try testing.expectEqualStrings("\x03\x02\x23\x07spirv", back.passes[1].spirv);
- try testing.expectEqual(@as(u32, 7), back.passes[1].revision);
- try testing.expect(back.passes[1].animated and !back.passes[0].animated);
-}
-
-test "detached wire: only the display's own effects are on the wire" {
- // Two guards, because the mistake has two directions. The exhaustive
- // switch fails to COMPILE if a machine-local effect is added back, which
- // is the direction that matters: it would hand a frontend work that must
- // outlive it. The count fails if one of the three is dropped, which would
- // silently leave a clipboard or a link unanswered on every frontend.
- try testing.expectEqual(@as(usize, 9), std.enums.values(ServerTag).len);
- for (std.enums.values(ServerTag)) |t| switch (t) {
- .welcome, .refuse, .frame, .quit, .detach, .set_clipboard, .read_clipboard, .open_link, .post => {},
- };
-}
-
test "detached wire: a session is never told to do a frontend's remembering" {
// The mirror of the test above, and of client.zig's "a frontend is never
// asked to fork, write, or watch". That one pins what may reach a FRONTEND;
@@ -1422,223 +585,7 @@ test "detached wire: a session is never told to do a frontend's remembering" {
try testing.expectEqual(allowed.len, accepted);
}
-/// A grid with something in every corner: a default cell, a plain ASCII cell,
-/// an indexed pair, an rgb pair with every attribute on, and a multi-byte
-/// grapheme — the five shapes `putCell` branches on.
-fn sampleGrid(cells: []pardes.Cell) void {
- @memset(cells, .{});
- cells[0] = .{ .text = "x".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[1] = .{
- .text = "y".* ++ @as([6]u8, @splat(0)),
- .len = 1,
- .default = false,
- .style = .{ .fg = .{ .index = 3 }, .bg = .{ .index = 250 }, .bold = true, .ul = .curly },
- };
- cells[2] = .{
- .text = "→".* ++ @as([4]u8, @splat(0)),
- .len = 3,
- .default = false,
- .style = .{
- .fg = .{ .rgb = .{ 1, 2, 3 } },
- .bg = .{ .rgb = .{ 250, 251, 252 } },
- .bold = true,
- .dim = true,
- .italic = true,
- .blink = true,
- .reverse = true,
- .invisible = true,
- .strikethrough = true,
- .ul = .dashed,
- .font_role = .tagline,
- },
- };
- cells[cells.len - 1] = .{ .text = "z".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
-}
-
-fn expectGridEqual(want: []const pardes.Cell, have: []const pardes.Cell) !void {
- try testing.expectEqual(want.len, have.len);
- // `visuallyEqual` and not `std.meta.eql`: `Cell.text` past `len` is
- // scratch left by an earlier grapheme, the decoder does not invent it, and
- // pardes.zig says in as many words that it must never manufacture a diff.
- for (want, have, 0..) |*a, *b, i| if (!a.visuallyEqual(b)) {
- std.debug.print("cell {d} differs: {any} vs {any}\n", .{ i, a.*, b.* });
- return error.CellMismatch;
- };
-}
-
-test "detached wire: a full frame carries the grid, a diff carries the change" {
- const cols: u16 = 56;
- const rows: u16 = 14;
- const n = @as(usize, cols) * rows;
- const gpa = testing.allocator;
-
- const cells = try gpa.alloc(pardes.Cell, n);
- defer gpa.free(cells);
- const mirror = try gpa.alloc(pardes.Cell, n);
- defer gpa.free(mirror);
- const buf = try gpa.alloc(u8, frameBound(cols, rows));
- defer gpa.free(buf);
-
- sampleGrid(cells);
- @memset(mirror, .{});
-
- // FULL: nothing on the far side is comparable, which is the late joiner
- // and the resize both.
- const full_bytes = try encodeFrameLayers(buf, cols, rows, .{ .x = 3, .y = 4, .bar = true }, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{});
- {
- const f = (try framed(full_bytes)).?;
- const msg = (try decodeServer(f.tag, f.payload)).frame;
- try testing.expectEqual(FrameKind.full, msg.kind);
- try testing.expectEqual(cols, msg.cols);
- try testing.expectEqual(rows, msg.rows);
- try testing.expectEqual(@as(u16, 3), msg.cursor.?.x);
- try testing.expectEqual(@as(u16, 4), msg.cursor.?.y);
- try testing.expect(msg.cursor.?.bar);
- try msg.apply(mirror);
- try expectGridEqual(cells, mirror);
- }
-
- // DIFF: two cells move. The mirror is already in sync, so this is what a
- // steady-state frame looks like.
- const before = try gpa.dupe(pardes.Cell, cells);
- defer gpa.free(before);
- cells[100] = .{ .text = "q".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[0] = .{}; // ...and one goes back to unpainted, which a diff must say
- const diff_bytes = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, before, &.{}, &.{}, &.{}, .{});
- {
- const f = (try framed(diff_bytes)).?;
- const msg = (try decodeServer(f.tag, f.payload)).frame;
- try testing.expectEqual(FrameKind.diff, msg.kind);
- try testing.expectEqual(@as(?Cursor, null), msg.cursor);
- try testing.expectEqual(@as(u32, 2), msg.nruns);
- try msg.apply(mirror);
- try expectGridEqual(cells, mirror);
- }
-
- // An unchanged frame is the head and nothing else: no runs, and the
- // receiver keeps what it has. This is what makes an idle session silent.
- {
- const idle = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, cells, &.{}, &.{}, &.{}, .{});
- try testing.expectEqual(@as(usize, header_len + frame_head), idle.len);
- const f = (try framed(idle)).?;
- const msg = (try decodeServer(f.tag, f.payload)).frame;
- try testing.expectEqual(@as(u32, 0), msg.nruns);
- try msg.apply(mirror);
- try expectGridEqual(cells, mirror);
- }
-}
-
-test "detached wire: the largest grid is one cell past a run, and survives it" {
- // `max_cols * max_rows` is 65536 and a run's `count` is a u16, so THE ONE
- // grid this protocol calls legal at both bounds is the one grid whose full
- // frame cannot be described by a single run. It reached nobody while a
- // frontend sent its window raw — a display that big had its hello refused
- // before any frame was composed — and it is the ordinary case now that a
- // frontend clamps to exactly this. In a safe build the `@intCast` panicked
- // and took the session down; in a fast one it wrote a zero-length run the
- // frontend answered with `BadValue`.
- const cols = max_cols;
- const rows = max_rows;
- const n = @as(usize, cols) * rows;
- const gpa = testing.allocator;
-
- const cells = try gpa.alloc(pardes.Cell, n);
- defer gpa.free(cells);
- const mirror = try gpa.alloc(pardes.Cell, n);
- defer gpa.free(mirror);
- const buf = try gpa.alloc(u8, frameBound(cols, rows));
- defer gpa.free(buf);
-
- // Every cell painted, which is what `render` produces and therefore what a
- // full frame always is: one run, if a run could be that long.
- for (cells) |*c| c.* = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- @memset(mirror, .{});
-
- const bytes = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{});
- const f = (try framed(bytes)).?;
- const msg = (try decodeServer(f.tag, f.payload)).frame;
- try testing.expectEqual(FrameKind.full, msg.kind);
- // Split, and split as late as it can be: 65535 cells then 1.
- try testing.expectEqual(@as(u32, 2), msg.nruns);
- try msg.apply(mirror);
- try expectGridEqual(cells, mirror);
- // ...at exactly the two headers the split costs and not one byte more.
- // `bytes.len <= frameBound(...)` would prove nothing here — the buffer IS
- // `frameBound` bytes, so an over-run is `WriteFailed` above, not a false
- // assertion here — and what wants pinning is that the second run is the
- // whole of the cost.
- try testing.expectEqual(
- @as(usize, header_len + frame_head + 2 * run_header + n * 8),
- bytes.len,
- );
-}
-
-test "detached wire: the diff is worth having, in bytes, on the board's grid" {
- // The numbers quoted in `encodeFrameLayers`'s comment, asserted so the claim
- // cannot rot. 56x14 is the ESP32-P4 board's default grid (esp32p4.zig).
- const cols: u16 = 56;
- const rows: u16 = 14;
- const n = @as(usize, cols) * rows;
- const gpa = testing.allocator;
-
- const cells = try gpa.alloc(pardes.Cell, n);
- defer gpa.free(cells);
- const buf = try gpa.alloc(u8, frameBound(cols, rows));
- defer gpa.free(buf);
-
- // Every cell painted with a plain ASCII glyph and default colors, which is
- // what a pardes frame overwhelmingly is: eight bytes a cell.
- for (cells) |*c| c.* = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- const full = (try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{})).len;
- try testing.expectEqual(@as(usize, header_len + frame_head + run_header + n * 8), full);
- try testing.expectEqual(@as(usize, 6302), full);
-
- const before = try gpa.dupe(pardes.Cell, cells);
- defer gpa.free(before);
- // A keystroke: one glyph replaced, and the cursor's old and new cells
- // repainted. Three cells, adjacent enough to coalesce into two runs.
- cells[300] = .{ .text = "b".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[301] = .{ .text = "c".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[500] = .{ .text = "d".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- const diff = (try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, before, &.{}, &.{}, &.{}, .{})).len;
- try testing.expectEqual(@as(usize, header_len + frame_head + 2 * run_header + 3 * 8), diff);
- try testing.expectEqual(@as(usize, 60), diff);
- // The whole reason this codec exists rather than shipping the Surface.
- try testing.expect(full / diff > 100);
-}
-
-test "detached wire: a run is coalesced across a gap only when that is cheaper" {
- const cols: u16 = 8;
- const rows: u16 = 1;
- var cells: [8]pardes.Cell = @splat(.{});
- var prev: [8]pardes.Cell = @splat(.{});
- var buf: [512]u8 = undefined;
-
- // Two changes with three UNPAINTED cells between them. Re-sending those is
- // three bytes; a second run header is six. One run.
- cells[0] = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[4] = .{ .text = "b".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- {
- const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?;
- try testing.expectEqual(@as(u32, 1), (try decodeServer(f.tag, f.payload)).frame.nruns);
- }
- // Now put a PAINTED cell in the gap that both sides already agree about.
- // Eight bytes to re-send against six for a header: two runs.
- const painted: pardes.Cell = .{ .text = "-".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
- cells[2] = painted;
- prev[2] = painted;
- {
- const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?;
- try testing.expectEqual(@as(u32, 2), (try decodeServer(f.tag, f.payload)).frame.nruns);
- }
- // Whichever it chose, the receiver ends up with the same grid.
- var mirror: [8]pardes.Cell = prev;
- const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?;
- try (try decodeServer(f.tag, f.payload)).frame.apply(&mirror);
- try expectGridEqual(&cells, &mirror);
-}
-
-test "detached wire: a truncated frame is refused at every length" {
+test "detached wire: a truncated message is refused at every length" {
var buf: [4096]u8 = undefined;
// Every prefix of a real message. The framing must say "not yet" for the
@@ -1659,7 +606,6 @@ test "detached wire: a truncated frame is refused at every length" {
try testing.expectEqual(@as(?Framed, null), try framed(copy[0..cut]));
// A payload with bytes LEFT OVER is refused too: it is not this message.
try testing.expectError(error.Trailing, decodeClient(@backingInt(ClientTag.pointer_leave), "x"));
- try testing.expectError(error.Trailing, decodeServer(@backingInt(ServerTag.quit), "x"));
}
test "detached wire: an unknown tag is refused, never guessed" {
@@ -1667,11 +613,8 @@ test "detached wire: an unknown tag is refused, never guessed" {
// the session tags and the input tags. All three are the same answer.
for ([_]u8{ 0x00, 0x0f, 0x1f, 0xff }) |tag| {
try testing.expectError(error.BadTag, decodeClient(tag, ""));
- try testing.expectError(error.BadTag, decodeServer(tag, ""));
}
- // A tag NESTED in a payload gets the same treatment: a color, an
- // underline style, a mouse button, a refusal reason.
- try testing.expectError(error.BadTag, decodeServer(@backingInt(ServerTag.refuse), &.{0x7f}));
+ // A tag NESTED in a payload gets the same treatment: a mouse button.
try testing.expectError(error.BadTag, decodeClient(
@backingInt(ClientTag.mouse),
&.{ 0xff, 0x00, 0, 0, 0, 0, 0 },
@@ -1701,140 +644,6 @@ test "detached wire: an over-long length prefix is refused before it is believed
try testing.expectError(error.Overlong, decodeClient(@backingInt(ClientTag.paste), &paste));
}
-test "detached wire: a frame that lies about its runs cannot walk out of the grid" {
- const cols: u16 = 4;
- const rows: u16 = 2;
- var grid: [8]pardes.Cell = @splat(.{});
-
- // start = 6, count = 4 on an 8-cell grid: the check that matters, and the
- // one an `start + count > len` spelling would miss on overflow.
- var runs: [10]u8 = undefined;
- std.mem.writeInt(u32, runs[0..4], 6, .little);
- std.mem.writeInt(u16, runs[4..6], 4, .little);
- runs[6] = 1;
- const f: Frame = .{ .kind = .diff, .cols = cols, .rows = rows, .cursor = null, .nruns = 1, .runs = runs[0..7] };
- try testing.expectError(error.Overlong, f.apply(&grid));
-
- // A start past the end entirely, and the 32-bit wrap.
- std.mem.writeInt(u32, runs[0..4], std.math.maxInt(u32) - 1, .little);
- std.mem.writeInt(u16, runs[4..6], 4, .little);
- try testing.expectError(error.Overlong, (Frame{
- .kind = .diff,
- .cols = cols,
- .rows = rows,
- .cursor = null,
- .nruns = 1,
- .runs = runs[0..7],
- }).apply(&grid));
-
- // A zero-length run says nothing and is not something the encoder emits.
- std.mem.writeInt(u32, runs[0..4], 0, .little);
- std.mem.writeInt(u16, runs[4..6], 0, .little);
- try testing.expectError(error.BadValue, (Frame{
- .kind = .diff,
- .cols = cols,
- .rows = rows,
- .cursor = null,
- .nruns = 1,
- .runs = runs[0..6],
- }).apply(&grid));
-
- // A run count larger than the grid has cells is refused at DECODE, before
- // it is used to bound the walk.
- var head: [frame_head]u8 = undefined;
- var w: std.Io.Writer = .fixed(&head);
- try w.writeByte(@backingInt(FrameKind.diff));
- try w.writeInt(u16, cols, .little);
- try w.writeInt(u16, rows, .little);
- try putCursor(&w, null, cols, rows);
- try w.writeInt(u32, 0, .little); // no body layers
- try w.writeInt(u32, 9, .little);
- try testing.expectError(error.Overlong, decodeServer(@backingInt(ServerTag.frame), w.buffered()));
-
- // ...and a grid of the wrong size is the receiver's own bug, not a frame
- // it should paint half of.
- var small: [4]pardes.Cell = @splat(.{});
- try testing.expectError(error.BadValue, (Frame{
- .kind = .full,
- .cols = cols,
- .rows = rows,
- .cursor = null,
- .nruns = 0,
- .runs = "",
- }).apply(&small));
-}
-
-test "detached wire: link pointer survives full and unchanged grid frames" {
- const cells = [_]pardes.Cell{.{}};
- var buffer: [256]u8 = undefined;
- for ([_]pardes.Surface.PointerShape{ .link, .arrow, .link }) |shape| {
- for ([_]bool{ true, false }) |full| {
- const bytes = try encodeFrameLayers(&buffer, 1, 1, null, shape, &cells, if (full) &.{} else &cells, &.{}, &.{}, &.{}, .{});
- const packet = (try framed(bytes)).?;
- const frame = (try decodeServer(packet.tag, packet.payload)).frame;
- try std.testing.expectEqual(shape, frame.pointer_shape);
- try std.testing.expectEqual(if (full) FrameKind.full else FrameKind.diff, frame.kind);
- if (!full) try std.testing.expectEqual(@as(u32, 0), frame.nruns);
- }
- }
-}
-
-test "detached wire: a cursor outside the grid is refused, not painted" {
- // The one field of a frame a frontend indexes with rather than copies:
- // tty.zig moves the terminal's own cursor to `cursor.x`/`cursor.y`, and
- // the ESP32-P4 panel writes the cell there. A frame that says 4x2 and puts
- // the cursor at (9,0) is an out-of-bounds write in every frontend, so it
- // has to be a decode error and not a clamp — a clamped cursor is a wrong
- // screen that nobody reports.
- const cols: u16 = 4;
- const rows: u16 = 2;
- var head: [frame_head]u8 = undefined;
- for ([_][2]u16{ .{ cols, 0 }, .{ 0, rows }, .{ 0xffff, 0xffff } }) |xy| {
- var w: std.Io.Writer = .fixed(&head);
- try w.writeByte(@backingInt(FrameKind.diff));
- try w.writeInt(u16, cols, .little);
- try w.writeInt(u16, rows, .little);
- // Written by hand: `putCursor` now refuses this too, which is the
- // other half of the same fix and is asserted below.
- try w.writeByte(@intFromBool(true));
- try w.writeInt(u16, xy[0], .little);
- try w.writeInt(u16, xy[1], .little);
- try w.writeByte(@intFromBool(false));
- try w.writeInt(u32, 0, .little);
- try testing.expectError(
- error.BadValue,
- decodeServer(@backingInt(ServerTag.frame), w.buffered()),
- );
- }
- // The last cell IS in the grid, and a frame carrying it decodes.
- {
- var w: std.Io.Writer = .fixed(&head);
- try w.writeByte(@backingInt(FrameKind.diff));
- try w.writeInt(u16, cols, .little);
- try w.writeInt(u16, rows, .little);
- try putCursor(&w, .{ .x = cols - 1, .y = rows - 1, .bar = true }, cols, rows);
- try w.writeInt(u32, 0, .little); // no body layers
- try w.writeInt(u32, 0, .little);
- const got = (try decodeServer(@backingInt(ServerTag.frame), w.buffered())).frame;
- try testing.expectEqual(@as(u16, cols - 1), got.cursor.?.x);
- try testing.expectEqual(@as(u16, rows - 1), got.cursor.?.y);
- }
- // ...and the ENCODER refuses to build one, so a core bug is a dropped
- // frame with a log line rather than a frame every frontend hangs up over.
- var cells: [8]pardes.Cell = @splat(.{});
- var buf: [512]u8 = undefined;
- try testing.expectError(
- error.BadValue,
- encodeFrameLayers(&buf, cols, rows, .{ .x = cols, .y = 0, .bar = false }, .arrow, &cells, &.{}, &.{}, &.{}, &.{}, .{}),
- );
- // A grid past the protocol's own ceiling is refused by the encoder for the
- // same reason: `max_payload` is derived from it, so the decoder would.
- try testing.expectError(
- error.Overlong,
- encodeFrameLayers(&buf, max_cols + 1, 1, null, .arrow, cells[0..0], &.{}, &.{}, &.{}, &.{}, .{}),
- );
-}
-
test "detached wire: values a field cannot mean are refused" {
// A bool is 0 or 1. `2` used to be "true" in every hand-written codec that
// ever silently accepted a corrupt stream.
@@ -1875,28 +684,10 @@ test "detached wire: values a field cannot mean are refused" {
std.mem.writeInt(u32, &pinch, @bitCast(std.math.inf(f32)), .little);
try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.touch_scroll), &pinch));
}
- // A cell with the reserved attribute bit set, and one with an impossible
- // grapheme length. Both are bytes this protocol has no meaning for.
- {
- var grid: [1]pardes.Cell = @splat(.{});
- // default=0, len=1, 'x', fg default, bg default, attrs=0x80, ul, font
- var runs = [_]u8{ 0, 0, 0, 0, 1, 0, 0, 1, 'x', 0, 0, 0x80, 0, 0 };
- const f: Frame = .{ .kind = .diff, .cols = 1, .rows = 1, .cursor = null, .nruns = 1, .runs = &runs };
- try testing.expectError(error.BadValue, f.apply(&grid));
- runs[11] = 0;
- runs[7] = 8; // len past Cell.text
- try testing.expectError(error.BadValue, f.apply(&grid));
- runs[7] = 0; // ...and a grapheme of no bytes at all
- try testing.expectError(error.BadValue, f.apply(&grid));
- }
}
test "detached wire: max_payload bounds every message this protocol can build" {
- // The derivation in `max_payload`'s comment, asserted: the worst frame
- // this protocol admits fits, so a receiver sized for max_payload can
- // always hold one.
- try testing.expect(frameBound(max_cols, max_rows) <= max_payload);
- // ...and a 4 MiB paste, which is the tty frontend's own cap.
+ // A 4 MiB paste, which is the tty's own cap, fits.
try testing.expect((4 << 20) + header_len + 4 <= max_payload);
// A slice past the width of its own length prefix is refused by the
// ENCODER, rather than written and rejected at the far end. A command line
@@ -1914,47 +705,12 @@ test "detached wire: max_payload bounds every message this protocol can build" {
try testing.expectError(error.WriteFailed, encodeClient(&small, .{ .event = .{ .paste = "0123456789" } }));
}
-test "detached wire carries compact body rows and exact pointer metrics" {
- const gpa = std.testing.allocator;
- var cells: [8]pardes.Cell = @splat(.{});
+test "detached wire carries exact pointer metrics" {
var logical: [12]pardes.Cell = @splat(.{});
- logical[10] = .{ .text = "z".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false };
var layer: pardes.Layer = .{ .id = 0, .serial = 42, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 4 }, .cols = 2, .rows = 6, .context_rows = 2, .cells = &logical, .cursor = .{ .x = 0, .y = 5, .bar = true } };
layer.context_separators.set(0);
var tag_cells: [3]pardes.Cell = @splat(.{});
- tag_cells[2] = logical[10];
const tag: pardes.Layer = .{ .kind = .column, .id = 1, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 1 }, .cols = 3, .rows = 1, .bg = .{ 11, 22, 33 }, .cells = &tag_cells, .cursor = .{ .x = 2, .y = 0, .bar = true } };
- const placed = [_]pardes.Region{.{ .kind = .rail, .owner = 3, .serial = 42, .rect = .{ .x = 0, .y = 1, .w = 2, .h = 3 }, .active = true, .dirty = true, .thumb_y = 1, .thumb_h = 2, .clip = 1, .lift = 0.5 }};
- const out = try gpa.alloc(u8, frameBound(2, 4) + layersBound(&.{layer}, &.{tag}, &placed));
- defer gpa.free(out);
- const palette: pardes.Chrome = .{ .page = .{ 1, 2, 3 }, .border = .{ 4, 5, 6 }, .tag_focus_bg = .{ 7, 8, 9 }, .scroll_thumb = .{ 10, 11, 12 }, .rule_px = 3, .tag_rule = .{ 13, 14, 15 }, .rail_px = 12, .grip_border = .{ 16, 17, 18 }, .grip_focus_ring = .{ 19, 20, 21 }, .grip_dirty = .{ 22, 23, 24 }, .lift_style = 2, .cursor_glide = 3, .cursor_alpha = 0.5, .cursor_idle_ms = 1234, .cursor_quad = .{ 1, 2, 3.5, 2, 3.5, 3, 1, 3 } };
- const encoded = try encodeFrameLayers(out, 2, 4, null, .link, &cells, &cells, &.{layer}, &.{tag}, &placed, palette);
- const packet = (try framed(encoded)).?;
- const frame = (try decodeServer(packet.tag, packet.payload)).frame;
- var decoded: [pardes.MAX_PANES]pardes.Layer = @splat(.{});
- var tags: [pardes.MAX_TAG_LAYERS]pardes.Layer = @splat(.{});
- defer for (&tags) |*item| gpa.free(item.cells);
- defer for (&decoded) |*item| gpa.free(item.cells);
- try frame.apply(&cells);
- var regions: std.ArrayListUnmanaged(pardes.Region) = .empty;
- defer regions.deinit(gpa);
- var chrome: pardes.Chrome = .{};
- try frame.applyLayers(gpa, &decoded, &tags, &regions, &chrome);
- try std.testing.expectEqualDeep(placed[0..], regions.items);
- try std.testing.expectEqualDeep(palette, chrome);
- try std.testing.expectEqual(@as(u16, 6), decoded[0].rows);
- try std.testing.expect(decoded[0].context_separators.isSet(0));
- try std.testing.expect(!decoded[0].context_separators.isSet(1));
- try std.testing.expect(decoded[0].hasContextBorderAfter(0));
- try std.testing.expect(decoded[0].hasContextBorderAfter(1));
- try std.testing.expectEqualStrings("z", decoded[0].cells[10].grapheme());
- try std.testing.expectEqual(@as(u16, 5), decoded[0].cursor.?.y);
- try std.testing.expectEqual(tag.kind, tags[0].kind);
- try std.testing.expectEqual(tag.id, tags[0].id);
- try std.testing.expectEqual(tag.bg, tags[0].bg);
- try std.testing.expectEqual(tag.cols, tags[0].cols);
- try std.testing.expectEqual(@as(u16, 2), tags[0].cursor.?.x);
- try std.testing.expectEqualStrings("z", tags[0].cells[2].grapheme());
const pointer = layer.bodyHit(4, 27, 8, 16, 6, 8).?;
const tag_pointer = tag.tagHit(11, 8, 8, 16, 4, 8).?;
const message: ClientMsg = .{ .event = .{ .mouse = .{ .col = 0, .row = 1, .button = .left, .kind = .press, .body_hit = pointer, .tag_hit = tag_pointer } } };
@@ -1965,22 +721,4 @@ test "detached wire carries compact body rows and exact pointer metrics" {
try std.testing.expectEqualDeep(pointer, mouse.body_hit.?);
try std.testing.expectEqualDeep(tag_pointer, mouse.tag_hit.?);
try std.testing.expect(mouse_encoded.len <= clientBound(message));
- var truncated = frame;
- truncated.layers = frame.layers[0 .. frame.layers.len - 1];
- try std.testing.expectError(error.EndOfStream, truncated.applyLayers(gpa, &decoded, &tags, &regions, &chrome));
- for (decoded) |item| {
- try std.testing.expectEqual(@as(u16, 0), item.rows);
- try std.testing.expectEqual(@as(usize, 0), item.cells.len);
- try std.testing.expectEqual(@as(usize, 0), item.context_separators.count());
- }
- for (tags) |item| {
- try std.testing.expectEqual(@as(u16, 0), item.rows);
- try std.testing.expectEqual(@as(usize, 0), item.cells.len);
- }
- try std.testing.expectEqual(@as(usize, 0), regions.items.len);
- const no_layers = try encodeFrameLayers(out, 2, 4, null, .arrow, &cells, &cells, &.{}, &.{}, &.{}, .{});
- const cleared_packet = (try framed(no_layers)).?;
- const cleared = (try decodeServer(cleared_packet.tag, cleared_packet.payload)).frame;
- try cleared.applyLayers(gpa, &decoded, &tags, &regions, &chrome);
- try std.testing.expectEqual(@as(u16, 0), decoded[0].rows);
}