const std = @import("std"); const builtin = @import("builtin"); const pardes = @import("pardes.zig"); const ninep_io = @import("9p_io.zig"); const daemon = @import("daemon.zig"); const is_emscripten = builtin.os.tag == .emscripten; extern "c" fn emscripten_console_error(utf8: [*:0]const u8) void; pub const std_options_debug_threaded_io: ?*std.Io.Threaded = if (is_emscripten) null else std.Io.Threaded.global_single_threaded; pub const std_options_debug_io: std.Io = if (is_emscripten) std.Io.failing else std_options_debug_threaded_io.?.io(); // Every thread's alternate signal stack is a threadlocal that libc zeroes as // the thread starts, so std's 256 KiB made each 9P connection's thread cost // that much resident. A stack-overflow segfault on a thread still printed its // whole symbolized trace from 32 KiB up (16 KiB double-faulted): 64 KiB. // // FreeBSD answers a write to a terminal that is gone with ENXIO, an errno std // does not expect: a Debug build traced it to stderr, that same terminal, // and recursed until the stack ran out (a session whose ssh dropped hung). pub const std_options: std.Options = .{ .logFn = logFn, .signal_stack_size = 64 * 1024, .unexpected_error_tracing = (std.Options{}).unexpected_error_tracing and builtin.os.tag != .freebsd, }; fn logFn( comptime level: std.log.Level, comptime scope: @EnumLiteral(), comptime format: []const u8, args: anytype, ) void { if (scope != .gui and std.c.getenv("PARDES_LOG") == null) return; std.log.defaultLog(level, scope, format, args); } pub const panic = if (is_emscripten) std.debug.FullPanic(std.debug.defaultPanic) else std.debug.FullPanic(struct { fn call(msg: []const u8, ret_addr: ?usize) noreturn { if (!recovering.swap(true, .seq_cst)) @import("vaxis").recover(); @import("crash.zig").record(msg); std.debug.defaultPanic(msg, ret_addr); } }.call); var recovering: std.atomic.Value(bool) = .init(false); pub const debug = if (is_emscripten) struct {} else struct { pub fn handleSegfault(addr: ?usize, name: []const u8, opt_ctx: anytype) noreturn { if (!recovering.swap(true, .seq_cst)) @import("vaxis").recover(); return std.debug.defaultHandleSegfault(addr, name, opt_ctx); } }; const help_text = \\Usage: pardes [options] [file|dir|-] \\ \\With no arguments the shell pane starts in tty mode. A FILE argument \\(optionally file:LINE) opens it alone, filling the window; a DIRECTORY \\argument becomes the cwd shells spawn in. `-` reads stdin into a +Pager \\pane, its colours kept (PagerColor) and every other escape dropped: \\inside a pardes pane the outer session's, returning at once (a \\terminal's PAGER), else a new editor's. \\ \\Options: \\ --tty start as one shell pane already in tty mode \\ -n initial shell panes: 1 (default) or 3 (classic). \\ A FILE argument boots just that file instead. \\ --tty-toggle use Ctrl- to toggle tty/editor mode \\ -l load a dump of another instance (see Dump) \\ -w, --wait inside a pardes pane, hand FILE to the outer \\ session and return only once the pane it opened \\ (or already had) is deleted: 0 then, 1 if the \\ session goes away. For $EDITOR (acme's E): \\ EDITOR='pardes --wait', which GIT_EDITOR follows. \\ Outside pardes a session blocks anyway. \\ --nested run a full session even inside another pardes. \\ Without it, a pardes started inside a pardes \\ hands its FILE argument to the outer one. This \\ session will not serve its own children either. \\ Explicit session configuration starts a new one. \\ --9p= name the default 9P socket. Without this flag, \\ the name is the detached session name or pid. \\ The socket is under $XDG_RUNTIME_DIR, falling \\ back to ~/.local/state/pardes. \\ --9p-tcp= also serve 9P at tcp!!. \\ --9p-quic= also serve at quic!! (-Dquic=true). \\ --mount== mount a 9P session or Unix/TCP/QUIC endpoint under /n/. \\ Repeat for more mounts; os and self are reserved. \\ --detach run this session with no terminal (no window) \\ until one attaches; its panes, shells and files \\ stay. Detach, or a terminal that closes, leaves \\ any session so. One `pardes --daemon` per user \\ keeps them (PARDES_DAEMON=off: none) \\ --detach= ...named rather than this process's pid, \\ as --9p names it. One path component: no '/' \\ and nothing empty \\ --attach show the one detached session here: this \\ terminal for `pardes`, a window again for \\ `pardes-gui`, each of its own kind. Returns when \\ the session detaches or ends \\ --attach= ...the session called (its --9p or \\ --detach name, else its pid) \\ --geometry=WxH[+X+Y] the window's size in points, and where it goes \\ where the display lets a window say (X11) \\ -h, --help show this help and exit \\ --version print the version and exit \\ ; /// `pardes -` inside a session: `text`, stdin as it came, escapes and all, /// into a new +Pager of the directory (/pager): /// written after the directory on that one open, the session parses it /// (pager.zig) and puts it in as one undo step, left clean. A text the /// session would not take is never lost: it goes to stderr, a terminal, /// with why, and the exit is 1. fn pageInto(io: std.Io, gpa: std.mem.Allocator, dial: []const u8, text: []const u8) void { const Fail = struct { fn with(o: std.Io, t: []const u8, what: []const u8, err: anyerror) noreturn { var words_buf: [128]u8 = undefined; const why = if (err == error.Remote) ninep_io.Client.lastSaid() else forwardWords(err, &words_buf); var buf: [512]u8 = undefined; const head = std.fmt.bufPrint(&buf, "pardes: -: {s}: {s}; the text follows\n", .{ what, why }) catch "pardes: -: refused; the text follows\n"; std.Io.File.stderr().writeStreamingAll(o, head) catch {}; std.Io.File.stderr().writeStreamingAll(o, t) catch {}; std.process.exit(1); } }; // The pane's directory: this one, unless its name could not be one line // of a ctl (a newline, a control byte): then the session's. var cwd_buf: [4096]u8 = undefined; const cwd: []const u8 = if (std.c.getcwd(&cwd_buf, cwd_buf.len)) |c| std.mem.span(@as([*:0]u8, @ptrCast(c))) else ""; // ...or the session's when this one may not be written (`git log` in // /usr/src), which /pager refuses: the text is paged all the same. const plain = for (cwd) |c| { if (c < ' ' or c == 0x7f) break false; } else !pardes.filesystem.deniedAbove(cwd); var line_buf: [4200]u8 = undefined; const dir_line = std.fmt.bufPrint(&line_buf, "{s}\n", .{if (plain) cwd else ""}) catch "\n"; // Its serial read back on the open that asked, once the text is in: // another client's exec meanwhile can never send it into that // client's pane. const answer = ninep_io.Client.ask(gpa, dial, "/pager", dir_line, text) catch |err| Fail.with(io, text, "no +Pager pane", err); _ = std.fmt.parseInt(u32, std.mem.trim(u8, answer, " \n"), 10) catch |err| Fail.with(io, text, "no +Pager pane", err); } /// Stdin to its end, as it came (its escapes are the session's to parse, /// pager.zig), at most a file's limit, a longer one cut there and said so /// at its end. fn readStdinText(io: std.Io, gpa: std.mem.Allocator) ![]u8 { const limit = pardes.memory.limits.max_file_bytes; var raw: std.ArrayList(u8) = .empty; var chunk: [64 * 1024]u8 = undefined; var stdin = std.Io.File.stdin().readerStreaming(io, &chunk); // One byte past the limit says there is more. stdin.interface.appendRemaining(gpa, &raw, .limited(limit + 1)) catch |err| switch (err) { error.StreamTooLong => { raw.shrinkRetainingCapacity(limit); // CAN ends an escape the cut left half sent, and SGR 0 its colour, // so the note is never swallowed or tinted. const said = "\x18\x1b[m\n[pardes: the rest of stdin is cut: a pane holds at most a file's limit]\n"; try raw.appendSlice(gpa, said); }, else => |e| return e, }; return raw.toOwnedSlice(gpa); } /// A forwarding failure in words, never an error's name: the ones this /// file raises said outright, any other as its name's words (`NotFound`, /// `not found`), a dial's as Messages says it. fn forwardWords(err: anyerror, buf: []u8) []const u8 { return switch (err) { error.NotOneLine => "a file name is one line, and this one holds a newline", error.NotAFileName => "names a directory, not a file", error.NoWorkingDirectory => "this shell's working directory is gone", error.DirectoryNotWritable => "permission denied: its directory may not be read or written, so it could never be saved", error.NotAPaneAddress => "not a pane address: @p and a pane's number", error.NoSuchPane => "this session has no such pane", else => if (pardes.Messages.dialReason(err)) |why| why else words: { var n: usize = 0; for (@errorName(err), 0..) |c, i| { if (n + 2 > buf.len) break; if (std.ascii.isUpper(c) and i > 0) { buf[n] = ' '; n += 1; } buf[n] = std.ascii.toLower(c); n += 1; } break :words buf[0..n]; }, }; } /// `--wait` after a forwarded look, as plan9port's E reads acme's log: the /// pane `path` landed in (the one it already had, if open), then /log /// followed on one connection until that pane's `del` -- exit 0 -- or the /// connection ends with the session -- exit 1. fn waitForDel(io: std.Io, gpa: std.mem.Allocator, dial: []const u8, path: []const u8, known: ?u32) noreturn { _ = io; // The pane this launch made (a name not there yet), or the one its // look answered, is known by its serial; one the look answered none // for is found by its file. Found by none after the look went there, // it was closed already: that is the end being waited for, not a // failure (a pane closed between the look and this read made `--wait` // exit 1 before). const serial = known orelse found: { const first = ninep_io.Client.read(gpa, dial, "/index", "/index") catch std.process.exit(1); defer gpa.free(first); break :found paneShowing(first, path) orelse std.process.exit(0); }; const Wait = struct { gpa: std.mem.Allocator, dial: []const u8, serial: u32, /// Deleted between the look and the follow: /index, read once the /// follow stands, says so, and a `del` after it is followed. fn gone(w: *const @This()) bool { const index = ninep_io.Client.read(w.gpa, w.dial, "/index", "/index") catch return false; defer w.gpa.free(index); return !hasPane(index, w.serial); } fn deleted(w: *const @This(), bytes: []const u8) bool { return isDel(bytes, w.serial); } }; const w: Wait = .{ .gpa = gpa, .dial = dial, .serial = serial }; ninep_io.Client.follow(gpa, dial, "/log", "follow new", &w, Wait.gone, Wait.deleted) catch std.process.exit(1); std.process.exit(0); } /// Whether log records `bytes` hold `del ...`. fn isDel(bytes: []const u8, serial: u32) bool { var records = std.mem.splitScalar(u8, bytes, '\n'); while (records.next()) |rec| { if (!std.mem.startsWith(u8, rec, "del ")) continue; const word = rec[4 .. std.mem.indexOfScalarPos(u8, rec, 4, ' ') orelse rec.len]; if ((std.fmt.parseInt(u32, word, 10) catch continue) == serial) return true; } return false; } /// The serial of /index's first row named `path` (`serial kind dirty name col`). fn paneShowing(index: []const u8, path: []const u8) ?u32 { var rows = std.mem.splitScalar(u8, index, '\n'); while (rows.next()) |row| { var words = std.mem.splitScalar(u8, row, ' '); const serial = std.fmt.parseInt(u32, words.first(), 10) catch continue; _ = words.next() orelse continue; // kind _ = words.next() orelse continue; // dirty const rest = words.rest(); const end = std.mem.lastIndexOfScalar(u8, rest, ' ') orelse continue; if (std.mem.eql(u8, rest[0..end], path)) return serial; } return null; } fn hasPane(index: []const u8, serial: u32) bool { var rows = std.mem.splitScalar(u8, index, '\n'); while (rows.next()) |row| { const first = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len]; if ((std.fmt.parseInt(u32, first, 10) catch continue) == serial) return true; } return false; } test "--wait finds the pane /index names a file by, spaces and all, and sees it gone" { const index = "1 term 0 /home/u 1\n4 text 1 /tmp/a b.txt 2\n"; try std.testing.expectEqual(@as(?u32, 4), paneShowing(index, "/tmp/a b.txt")); try std.testing.expectEqual(@as(?u32, null), paneShowing(index, "/tmp/a")); try std.testing.expect(hasPane(index, 4) and !hasPane(index, 2)); try std.testing.expect(isDel("new 5 /x\ndel 4 /tmp/a b.txt\n", 4)); try std.testing.expect(!isDel("del 41 /x\n", 4) and !isDel("undel 4\n", 4)); } fn badArgs(io: std.Io, comptime fmt: []const u8, args: anytype) noreturn { var buf: [1024]u8 = undefined; const line = std.fmt.bufPrint(&buf, "pardes: " ++ fmt ++ "\nTry 'pardes --help'.\n", args) catch "pardes: bad arguments\nTry 'pardes --help'.\n"; std.Io.File.stderr().writeStreamingAll(io, line) catch {}; std.process.exit(1); } /// The second line is what a replica's build must share with its session's /// (detached/wire.zig `semantics`). const version_text = (if (pardes.commit) |c| "pardes " ++ pardes.version ++ " (" ++ c ++ ")\n" else "pardes " ++ pardes.version ++ "\n") ++ std.fmt.comptimePrint("semantics {x:0>16}\n", .{@import("detached/wire.zig").semantics}); const nested_text = \\pardes: this shell is already inside pardes, and a pardes inside a pardes \\is spicy. Name a file or a directory and the outer session opens it, or \\pass --nested if you really want a second one in here. \\ ; // The browser runtime calls a C main (exported below); everything else keeps // the std.process.Init entry. pub const main = if (is_emscripten) webMain else nativeMain; comptime { if (is_emscripten) @export(&emscriptenMain, .{ .name = "main" }); } fn emscriptenMain(argc: c_int, argv: [*]?[*:0]u8) callconv(.c) c_int { _ = argc; _ = argv; webMain() catch |err| { var buf: [128]u8 = undefined; const msg = std.fmt.bufPrintSentinel(&buf, "pardes web init failed: {t}", .{err}, 0) catch "pardes web init failed"; emscripten_console_error(msg.ptr); return 1; }; return 0; } // no argv in the browser: options stay default, state comes from the dump, and // there is no session to attach to — a browser tab has no unix socket. fn webMain() !void { try @import("gui/gui.zig").run(.{}, .{}, false); } // init.gpa, what the tty, gui and detached shells allocate from, is their // own fixed arena (memory.host) in a release build, spilling to libc's // malloc, and std.start's DebugAllocator in Debug. Zig 0.17's std.start // gives a safe build a SafeAllocator over the page allocator instead. fn nativeMain(std_init: std.process.Init) !void { var init = std_init; if (builtin.mode != .debug) init.gpa = pardes.memory.host(std.heap.c_allocator); // A recorded session's tape replayed, no session of its own (src/tape.zig). if (init.environ_map.get("PARDES_REPLAY")) |tape| std.process.exit(pardes.tape.replayMain(init.io, tape)); var stderr_probe: [64]u8 = undefined; _ = std.debug.lockStderr(&stderr_probe); std.debug.unlockStderr(); var opts: pardes.Options = .{}; var mounts: [pardes.filesystem.max_mounts]pardes.filesystem.Mount = undefined; var mounts_len: usize = 0; const arena = init.arena.allocator(); const args = try init.minimal.args.toSlice(arena); // The per-user daemon a session started (daemon.zig): nothing else. if (comptime daemon.supported) if (args.len == 2 and std.mem.eql(u8, args[1], "--daemon")) daemon.serve(); var session_only = true; var new_session = false; var explicit_tty = false; var detach: ?[]const u8 = null; var attach: ?[]const u8 = null; var positional: ?[:0]const u8 = null; var wait = false; var i: usize = 1; while (i < args.len) : (i += 1) { const a = args[i]; if (std.mem.eql(u8, a, "--tty")) { explicit_tty = true; } else if (std.mem.startsWith(u8, a, "--tty-toggle=")) { session_only = false; new_session = true; opts.tty_toggle = parseCtrlKey(a["--tty-toggle=".len..]) orelse badArgs(init.io, "--tty-toggle wants one letter, not '{s}'", .{a["--tty-toggle=".len..]}); } else if (std.mem.eql(u8, a, "--tty-toggle")) { session_only = false; new_session = true; i += 1; if (i >= args.len) badArgs(init.io, "--tty-toggle needs a letter after it", .{}); opts.tty_toggle = parseCtrlKey(args[i]) orelse badArgs(init.io, "--tty-toggle wants one letter, not '{s}'", .{args[i]}); } else if (std.mem.eql(u8, a, "-n")) { session_only = false; new_session = true; i += 1; if (i >= args.len) badArgs(init.io, "-n needs a count after it: 1 or 3", .{}); opts.shells = std.fmt.parseInt(u8, args[i], 10) catch badArgs(init.io, "-n takes 1 or 3, not '{s}'", .{args[i]}); } else if (std.mem.eql(u8, a, "-l")) { session_only = false; new_session = true; i += 1; if (i >= args.len) badArgs(init.io, "-l needs the path of a dump to load", .{}); opts.load_path = args[i]; } else if (std.mem.eql(u8, a, "--9p")) { badArgs(init.io, "--9p needs a socket name: --9p=", .{}); } else if (std.mem.startsWith(u8, a, "--9p=")) { new_session = true; const name = a["--9p=".len..]; if (name.len == 0 or std.mem.indexOfAny(u8, name, "/\x00") != null) badArgs(init.io, "invalid 9P socket name: '{s}'", .{name}); opts.ninep_name = name; } else if (std.mem.startsWith(u8, a, "--9p-tcp=")) { new_session = true; const dial = a["--9p-tcp=".len..]; if (!std.mem.startsWith(u8, dial, "tcp!")) badArgs(init.io, "--9p-tcp needs tcp!!", .{}); _ = @import("9p_io.zig").networkAddress(dial, true) catch badArgs(init.io, "--9p-tcp needs tcp!!", .{}); if (opts.ninep_tcp != null) badArgs(init.io, "--9p-tcp was specified twice", .{}); opts.ninep_tcp = dial; } else if (std.mem.eql(u8, a, "--9p-tcp")) { badArgs(init.io, "--9p-tcp needs tcp!!", .{}); } else if (std.mem.startsWith(u8, a, "--9p-quic=")) { new_session = true; const dial = a["--9p-quic=".len..]; if (!std.mem.startsWith(u8, dial, "quic!")) badArgs(init.io, "--9p-quic needs quic!!", .{}); _ = @import("9p_io.zig").networkAddress(dial, true) catch badArgs(init.io, "--9p-quic needs quic!!", .{}); if (opts.ninep_quic != null) badArgs(init.io, "--9p-quic was specified twice", .{}); if (!@import("9p_io.zig").quic_enabled) badArgs(init.io, "QUIC is not included; rebuild with -Dquic=true", .{}); opts.ninep_quic = dial; } else if (std.mem.eql(u8, a, "--9p-quic")) { badArgs(init.io, "--9p-quic needs quic!!", .{}); } else if (std.mem.startsWith(u8, a, "--mount=")) { new_session = true; const mount = a["--mount=".len..]; const split = std.mem.indexOfScalar(u8, mount, '=') orelse badArgs(init.io, "--mount needs name=dial", .{}); const name = mount[0..split]; const dial = mount[split + 1 ..]; if (dial.len == 0 or !@import("fs.zig").validMountName(name)) badArgs(init.io, "invalid mount name or dial: '{s}'", .{mount}); @import("9p_io.zig").Client.validateDial(dial) catch badArgs(init.io, "invalid mount dial: '{s}'", .{dial}); for (mounts[0..mounts_len]) |existing| if (std.mem.eql(u8, existing.name, name)) badArgs(init.io, "duplicate mount name: '{s}'", .{name}); if (mounts_len == mounts.len) badArgs(init.io, "too many mounts (maximum {d})", .{mounts.len}); mounts[mounts_len] = .{ .name = name, .dial = dial }; mounts_len += 1; } else if (std.mem.startsWith(u8, a, "--geometry=")) { opts.geometry = a["--geometry=".len..]; } else if (std.mem.eql(u8, a, "--nested")) { opts.nested = true; } else if (std.mem.eql(u8, a, "-w") or std.mem.eql(u8, a, "--wait")) { wait = true; } else if (std.mem.eql(u8, a, "--detach")) { detach = ""; } else if (std.mem.startsWith(u8, a, "--detach=")) { detach = a["--detach=".len..]; } else if (std.mem.eql(u8, a, "--attach")) { attach = ""; } else if (std.mem.startsWith(u8, a, "--attach=")) { attach = a["--attach=".len..]; } else if (std.mem.eql(u8, a, "-h") or std.mem.eql(u8, a, "--help")) { try std.Io.File.stdout().writeStreamingAll(init.io, help_text); return; } else if (std.mem.eql(u8, a, "--version")) { try std.Io.File.stdout().writeStreamingAll(init.io, version_text); return; } else if (std.mem.eql(u8, a, "--")) { // The end of options: what follows is a name, `-dash.txt` too. for (args[i + 1 ..]) |name| { if (name.len == 0) badArgs(init.io, "an empty argument names nothing", .{}); if (positional != null) badArgs(init.io, "one file or directory at a time, and '{s}' is the second", .{name}); session_only = false; positional = name; } break; } else if (a.len > 0 and (a[0] != '-' or std.mem.eql(u8, a, "-")) and positional == null) { // `-` is stdin, as for cat and vim: a text to show. session_only = false; positional = a; } else if (a.len == 0) { badArgs(init.io, "an empty argument names nothing", .{}); } else if (a[0] == '-') { badArgs(init.io, "no such option: {s}", .{a}); } else { badArgs(init.io, "one file or directory at a time, and '{s}' is the second", .{a}); } } opts.tty_only = explicit_tty or session_only; opts.mounts = mounts[0..mounts_len]; // `zig build run-isolated` with nothing named: something to look at on // arrival, read out of the binary itself. if (pardes.isolated and positional == null) { session_only = false; positional = "src/pardes.zig"; } if (detach != null and attach != null) badArgs(init.io, "--detach and --attach are opposites: one runs the session, the other joins one", .{}); // --wait waits on the pane a FILE opens: with none there is nothing to // wait for (EDITOR=pardes --wait is given the file). if (wait and positional == null) badArgs(init.io, "--wait needs a FILE: it returns when that file's pane is closed", .{}); if (opts.ninep_name.len != 0 and attach != null) badArgs(init.io, "--9p names a session's own socket, and --attach has none of its own", .{}); if (opts.ninep_tcp != null and attach != null) badArgs(init.io, "--9p-tcp opens a session's own listener, and --attach has none of its own", .{}); if (opts.ninep_quic != null and attach != null) badArgs(init.io, "--9p-quic opens a session's own listener, and --attach has none of its own", .{}); if (opts.mounts.len != 0 and attach != null) badArgs(init.io, "--mount configures a session's own core, and --attach has none of its own", .{}); if (!new_session and !opts.nested and detach == null and attach == null) forwarding: { // Am I inside a pardes at all? That is $PARDES_PID and nothing else — // one variable, exported by every session that means to take its // children's Looks, so a session that could not open a socket is still // recognisably the session this shell is inside. A pid naming no live // process is a shell that outlived its editor (a daemon started from a // pane, a stale environment carried into a new terminal), which is not // nested at all. // `--wait` with only $PARDES_9P (a script or agent that talks to a // session from outside its panes, EDITOR='pardes --wait') is asked // of that session too: what it waits on is a pane there. const outside = wait and std.c.getenv("PARDES_PID") == null and std.c.getenv("PARDES_9P") != null; if (!outside) { const owner = std.mem.span(std.c.getenv("PARDES_PID") orelse break :forwarding); const pid = std.fmt.parseInt(std.c.pid_t, owner, 10) catch break :forwarding; if (pid <= 0 or std.c.kill(pid, @fromBackingInt(@intCast(0))) != 0) break :forwarding; } // Can I reach it? That is the other two, and it is a separate answer. const Parent = struct { dial: []const u8, serial: u32 }; const found: ?Parent = reaching: { const dial = std.mem.span(std.c.getenv("PARDES_9P") orelse break :reaching null); ninep_io.Client.validateDial(dial) catch break :reaching null; // No pane of its own (`outside`): the session's root look, 0. const pane_text = std.mem.span(std.c.getenv("PARDES_PANE") orelse if (outside) break :reaching .{ .dial = dial, .serial = 0 } else break :reaching null); for (pane_text) |byte| if (!std.ascii.isDigit(byte)) break :reaching null; const serial = std.fmt.parseInt(u32, pane_text, 10) catch break :reaching null; if (serial == 0) break :reaching null; break :reaching .{ .dial = dial, .serial = serial }; }; // A pid we cannot reach is a session that is not answering: the shell // says it is inside one, but there is nothing there to take the file. // Starting an ordinary editor is what this did before the pid existed // and is the more useful of the two answers -- refusing to start would // leave a stale environment variable able to lock someone out of their // own editor. const parent = found orelse break :forwarding; // Does it answer? One that answers takes the file or says why not, // as acme's B does: from here on never a nested editor, whose // screen would be drawn inside the pane that asked. ninep_io.Client.probe(arena, parent.dial) catch { // `--wait` is someone's EDITOR waiting on that session: a screen // of its own drawn in their terminal is no answer. Said, exit 1. if (wait) { var buf: [4300]u8 = undefined; const text = std.fmt.bufPrint(&buf, "pardes: --wait: the session at {s} does not answer; it is gone\n", .{parent.dial[0..@min(parent.dial.len, 4096)]}) catch "pardes: --wait: the session does not answer\n"; std.Io.File.stderr().writeStreamingAll(init.io, text) catch {}; std.process.exit(1); } break :forwarding; }; const Refuse = struct { fn with(io: std.Io, what: []const u8, err: anyerror) noreturn { var words_buf: [128]u8 = undefined; const why = if (err == error.Remote) ninep_io.Client.lastSaid() else forwardWords(err, &words_buf); var buf: [8192]u8 = undefined; const text = std.fmt.bufPrint(&buf, "pardes: {s}: {s}\n", .{ what[0..@min(what.len, 4096)], why }) catch "pardes: refused\n"; std.Io.File.stderr().writeStreamingAll(io, text) catch {}; std.process.exit(1); } }; // The pane's `look` file: one line, and the line is the clicked text // itself, which is what a right click in that pane would have been. var look_buf: [64]u8 = undefined; const look = if (parent.serial == 0) "/look" else try std.fmt.bufPrint(&look_buf, "/pane/{d}/look", .{parent.serial}); // `pardes -`: stdin read to its end, a +Pager pane of the session // made of it (as acme's `B` has no stdin, through pane/new, a name // and the body), and back at once: the PAGER a pane's shell gets. if (positional) |word| if (std.mem.eql(u8, word, "-")) { const text = readStdinText(init.io, arena) catch |err| Refuse.with(init.io, "stdin", err); // Nothing paged: no pane, and done. if (text.len == 0) return; pageInto(init.io, arena, parent.dial, text); return; }; // From outside the session's panes there is no pane to say it is // nested in: `--wait` with no file opens nothing there. if (parent.serial == 0 and positional == null) break :forwarding; const typed_word = positional orelse { var tag_buf: [64]u8 = undefined; const tag = try std.fmt.bufPrint(&tag_buf, "/pane/{d}/tag", .{parent.serial}); const contents = ninep_io.Client.read(arena, parent.dial, tag, tag) catch |err| Refuse.with(init.io, tag, err); arena.free(contents); try std.Io.File.stderr().writeStreamingAll(init.io, nested_text); std.process.exit(1); }; // Named as it was given, its newline shown `\n`, so the refusal says // which name and why once. if (std.mem.indexOfAny(u8, typed_word, "\r\n") != null) { var shown_buf: [4 * 4096]u8 = undefined; Refuse.with(init.io, pardes.ctlfs.events.shown(typed_word[0..@min(typed_word.len, 4096)], &shown_buf), error.NotOneLine); } // `pardes '~/x'`, quoted so the shell left it: home, as a look's. var home_buf: [4096]u8 = undefined; const word = pardes.filesystem.expandHome(typed_word, &home_buf); const target = @import("look.zig").parsePathLine(word); // `@pN[:addr]` addresses a pane of this session: one it has is // looked at, one it has not is refused, never a file of that name. if (std.mem.startsWith(u8, target.path, pardes.config.pane_addr)) { const digits = word[pardes.config.pane_addr.len .. std.mem.indexOfScalar(u8, word, ':') orelse word.len]; const serial = std.fmt.parseInt(u32, digits, 10) catch Refuse.with(init.io, word, error.NotAPaneAddress); var name_buf: [64]u8 = undefined; const name = try std.fmt.bufPrint(&name_buf, "/pane/{d}/name", .{serial}); const named = ninep_io.Client.read(arena, parent.dial, name, name) catch Refuse.with(init.io, word, error.NoSuchPane); arena.free(named); var command_buf: [4200]u8 = undefined; const command = std.fmt.bufPrint(&command_buf, "{s}\n", .{word}) catch |err| Refuse.with(init.io, word, err); ninep_io.Client.write(arena, parent.dial, look, command) catch |err| Refuse.with(init.io, word, err); return; } var realbuf: [4096]u8 = undefined; var newbuf: [4096]u8 = undefined; const found_path: ?[]const u8 = if (pardes.filesystem.isVirtual(target.path)) target.path else if (pardes.filesystem.resolveOs(target.path, &realbuf)) |r| r.path else null; const path = found_path orelse named: { // A name not there yet, as acme's B takes one: its directory // resolved and the name kept, a pane made for it that Save // creates the file from. const base = std.fs.path.basename(target.path); if (base.len == 0 or std.mem.eql(u8, base, ".") or std.mem.eql(u8, base, "..")) Refuse.with(init.io, word, error.NotAFileName); const dir = pardes.filesystem.resolveOs(std.fs.path.dirname(target.path) orelse ".", &realbuf) orelse { // Its directory not there either: the name made absolute as // written, and the pane's Save makes the directories. var cwd_buf: [4096]u8 = undefined; if (std.c.getcwd(&cwd_buf, cwd_buf.len) == null) Refuse.with(init.io, word, error.NoWorkingDirectory); const cwd = std.mem.sliceTo(&cwd_buf, 0); const absolute = std.fs.path.resolvePosix(arena, &.{ cwd, target.path }) catch |err| Refuse.with(init.io, word, err); // Missing because one above may not be searched or written: // its Save could never make it, so refused now. if (pardes.filesystem.deniedAbove(std.fs.path.dirname(absolute) orelse "/")) Refuse.with(init.io, word, error.DirectoryNotWritable); break :named absolute; }; // A directory that is there but may not be read or written: a // pane for the name could only fail at its Save, so refused now. var dir_z_buf: [4096]u8 = undefined; if (std.fmt.bufPrintSentinel(&dir_z_buf, "{s}", .{dir.path}, 0)) |dir_z| { const R_OK = 4; const W_OK = 2; const X_OK = 1; if (std.c.access(dir_z.ptr, R_OK | W_OK | X_OK) != 0) Refuse.with(init.io, word, error.DirectoryNotWritable); } else |_| {} break :named std.fmt.bufPrint(&newbuf, "{s}/{s}", .{ std.mem.trimEnd(u8, dir.path, "/"), base }) catch |err| Refuse.with(init.io, word, err); }; var made_serial: ?u32 = null; if (found_path != null) { var command_buf: [8192]u8 = undefined; const command = std.fmt.bufPrint(&command_buf, "{s}{s}\n", .{ path, word[target.path.len..] }) catch |err| Refuse.with(init.io, word, err); // The pane it went to, read on the open that asked (another // client's look meanwhile is not this one's): what --wait waits on. const went = ninep_io.Client.ask(arena, parent.dial, look, command, "") catch |err| Refuse.with(init.io, word, err); var rows = std.mem.tokenizeAny(u8, went, " \n"); if (rows.next()) |row| made_serial = std.fmt.parseInt(u32, row, 10) catch null; } else { const made = ninep_io.Client.read(arena, parent.dial, "/pane/new", "/pane/new") catch |err| Refuse.with(init.io, word, err); const serial = std.fmt.parseInt(u32, std.mem.trim(u8, made, " \n"), 10) catch |err| Refuse.with(init.io, word, err); made_serial = serial; var name_buf: [64]u8 = undefined; const name = try std.fmt.bufPrint(&name_buf, "/pane/{d}/name", .{serial}); var line_buf: [4200]u8 = undefined; const line = std.fmt.bufPrint(&line_buf, "{s}\n", .{path}) catch |err| Refuse.with(init.io, word, err); ninep_io.Client.write(arena, parent.dial, name, line) catch |err| { // The name refused: the pane made for it goes too, no // stray +New left behind. var ctl_buf: [64]u8 = undefined; const ctl = std.fmt.bufPrint(&ctl_buf, "/pane/{d}/ctl", .{serial}) catch unreachable; var why_buf: [256]u8 = undefined; const said = ninep_io.Client.lastSaid(); const why = why_buf[0..@min(said.len, why_buf.len)]; @memcpy(why, said[0..why.len]); ninep_io.Client.write(arena, parent.dial, ctl, "delete\n") catch {}; if (err == error.Remote) { var buf: [8192]u8 = undefined; const text = std.fmt.bufPrint(&buf, "pardes: {s}: {s}\n", .{ word[0..@min(word.len, 4096)], why }) catch "pardes: refused\n"; std.Io.File.stderr().writeStreamingAll(init.io, text) catch {}; std.process.exit(1); } Refuse.with(init.io, word, err); }; } if (wait) waitForDel(init.io, arena, parent.dial, path, made_serial); return; } // `pardes -` outside a session: an editor whose first pane holds stdin, // as `vim -` does; the terminal is /dev/tty, never stdin. if (positional) |a| if (std.mem.eql(u8, a, "-")) { opts.stdin_text = readStdinText(init.io, arena) catch |err| badArgs(init.io, "stdin: {s}", .{@errorName(err)}); // Nothing paged: nothing to show. if (opts.stdin_text.?.len == 0) return; positional = null; }; if (positional) |a| { const target = @import("look.zig").parsePathLine(a); if (std.mem.eql(u8, target.path, "/n") or std.mem.startsWith(u8, target.path, "/n/") or std.mem.eql(u8, target.path, "/virtual") or std.mem.startsWith(u8, target.path, "/virtual/")) { opts.file = try arena.dupe(u8, target.path); opts.file_line = target.at.line; } else if (std.c.chdir(a.ptr) != 0) { var cwdbuf: [4096]u8 = undefined; const cwd = std.c.getcwd(&cwdbuf, cwdbuf.len) orelse badArgs(init.io, "this shell's working directory is gone; cd somewhere that exists", .{}); var realbuf: [4096]u8 = undefined; switch (@import("look.zig").resolve(null, a, std.mem.span(@as([*:0]u8, @ptrCast(cwd))), &realbuf)) { .file => |t| { opts.file = try arena.dupe(u8, t.path); opts.file_line = t.at.line; }, .image => |t| opts.file = try arena.dupe(u8, t.path), .none => opts.missing = .{ .word = try arena.dupe(u8, a), .dir = try arena.dupe(u8, std.mem.span(@as([*:0]u8, @ptrCast(cwd)))), }, .url => badArgs(init.io, "a URL is not something a launch can open; start pardes and click it", .{}), .pane => badArgs(init.io, "@pN addresses a pane of a running pardes, so there is none yet", .{}), else => badArgs(init.io, "cannot enter that directory: {s}", .{a}), } } } // The real bare-tty startup wants the editor half present from the first // frame, so it names that layout; a core booted for a test names none and // gets the raw shell by itself. This has to come AFTER the positional is // resolved: naming a layout short-circuits `Boot.of`, so choosing it any // earlier threw away a file argument, and the error pane for one that does // not exist, without a word. if (opts.tty_only and opts.file == null and opts.missing == null) opts.boot = .tty; const found = pardes.config.User.load(init.io, arena, init.environ_map); opts.startup_config = found.bytes; opts.startup_config_path = found.path; opts.config_dir = found.dir; opts.store_path = storePath(init.io, arena, init.environ_map); if (found.dir) |d| @import("crash.zig").setDir(d); if (attach) |name| attachTo(init.io, name); if (detach) |name| { // Said plainly, never a Zig error trace: a name a live session's // socket holds already (a plain session is named by its pid too). if (name.len != 0 and ninep_io.taken(name)) { var said: [512]u8 = undefined; std.Io.File.stderr().writeStreamingAll(init.io, 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") catch {}; std.process.exit(1); } if (opts.ninep_name.len == 0) opts.ninep_name = name; // Nobody's size yet: one roomy enough for a script's panes; `size` // sets another, and an attached terminal or window its own. opts.cols = 160; opts.rows = 50; } const kind: daemon.Kind = if (pardes.platform == .gui) .gui else .tty; var term: @import("tty/tty.zig").Term = if (detach != null) .none else .open; if (daemon.wanted()) { if (detach != null or pardes.platform == .gui) { _ = daemon.register(null, kind, opts.ninep_name, detach != null); } else if (pardes.platform == .tty) fork: { // A terminal's session is forked off its stub, which stays the // job the shell waits on: Detach (or the terminal's end) ends // the job and leaves the session running (daemon.forkSession). // The daemon is reached or started first, from this small // process, and the terminal opened while it is this one's. const conn = daemon.connect(true) orelse break :fork; const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0)); if (fd < 0) { daemon.startPending(true); _ = std.c.close(conn); break :fork; } // Started in the background, the job stops here until it is // brought to the foreground, as one making its terminal raw does. // std.posix's termios, not std.c's: glibc's is the bigger struct. if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {} daemon.forkSession(conn) orelse { daemon.startPending(true); _ = std.c.close(fd); _ = std.c.close(conn); break :fork; }; _ = daemon.register(conn, .tty, opts.ninep_name, false); term = .{ .fd = fd }; } } defer daemon.quit(); errdefer daemon.tellStubExit(1); switch (pardes.platform) { .tty => @import("tty/tty.zig").run(init, opts, term) catch |err| switch (err) { // No controlling terminal (a detached pty, a daemon): said, not // an error trace. error.NoDevice => { std.Io.File.stderr().writeStreamingAll(init.io, "pardes: no terminal to draw on: /dev/tty will not open; run it in a terminal, or --detach\n") catch {}; std.process.exit(1); }, else => return err, }, .gui => try @import("gui/gui.zig").run(init, opts, detach != null), .web, .macos, .esp32p4 => unreachable, } daemon.tellStubExit(0); } /// `pardes --attach[=name]` in a terminal: this terminal handed (through /// the daemon) to the detached session of that name, or the only one, and /// this process its stub until the session leaves it. `pardes-gui /// --attach`: the session asked to open its window again, and done. fn attachTo(io: std.Io, name: []const u8) noreturn { var words: [600]u8 = undefined; const Say = struct { fn no(o: std.Io, why: []const u8) noreturn { var buf: [700]u8 = undefined; std.Io.File.stderr().writeStreamingAll(o, std.fmt.bufPrint(&buf, "pardes: --attach: {s}\n", .{why}) catch "pardes: --attach failed\n") catch {}; std.process.exit(1); } }; if (comptime !daemon.supported) Say.no(io, "this system has no pardes daemon to attach through"); if (pardes.platform == .gui) switch (daemon.attach(.gui, name, &.{}, &words)) { .ok => std.process.exit(0), .no => |why| Say.no(io, why), }; const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0)); if (fd < 0) Say.no(io, "no terminal to attach: /dev/tty will not open"); if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {} var pipe: [2]std.c.fd_t = undefined; if (std.c.pipe(&pipe) != 0) Say.no(io, "no pipe for the session to say when it leaves"); ninep_io.setCloexec(pipe[0]); ninep_io.setCloexec(pipe[1]); switch (daemon.attach(.tty, name, &.{ fd, pipe[1] }, &words)) { .ok => |pid| { _ = std.c.close(fd); _ = std.c.close(pipe[1]); daemon.stubWait(pid, false, pipe[0]); }, .no => |why| Say.no(io, why), } } fn parseCtrlKey(raw: []const u8) ?u21 { var value = std.mem.trim(u8, raw, " \t\r\n"); if (value.len >= 5 and std.ascii.eqlIgnoreCase(value[0..5], "ctrl-")) { value = value[5..]; } else if (value.len >= 5 and std.ascii.eqlIgnoreCase(value[0..5], "ctrl+")) { value = value[5..]; } else if (value.len == 2 and value[0] == '^') { value = value[1..]; } if (value.len != 1) return null; const c = std.ascii.toLower(value[0]); if (c < 'a' or c > 'z' or c == 'c') return null; return c; } test { _ = pardes.config.User; _ = @import("crash.zig"); _ = @import("memory.zig"); _ = @import("locations.zig"); _ = @import("fs.zig"); _ = @import("detached/wire.zig"); _ = @import("ShaderBuild.zig"); _ = @import("vaxis_input.zig"); _ = @import("daemon.zig"); _ = @import("9p_io.zig"); _ = @import("9p_io.zig").Client; _ = @import("host_io.zig"); _ = @import("host_io.zig").Shell; _ = @import("host_io.zig").Lsp; // Its tests too: imported by the hosts only, it was never collected. _ = @import("file_watch.zig"); _ = @import("lsp/lsp_client.zig"); _ = @import("lsp/lsp.zig"); if (comptime pardes.platform == .tty) { _ = @import("tty/tty.zig"); _ = @import("tty/panel_compositor.zig"); } if (comptime pardes.platform == .gui) _ = @import("gui/gui.zig"); if (comptime pardes.font_picker) _ = @import("fonts.zig"); } /// Where the store every window shares is kept (Store.zig): /// $XDG_STATE_HOME/pardes/store, else ~/.local/state/pardes/store, the /// directory made if need be; null with no home to keep it in (Recent and /// the closed panes then last the session). fn storePath(io: std.Io, arena: std.mem.Allocator, env: *const std.process.Environ.Map) ?[]const u8 { const dir = dir: { if (env.get("XDG_STATE_HOME")) |base| if (base.len != 0 and std.fs.path.isAbsolute(base)) break :dir std.fs.path.join(arena, &.{ base, "pardes" }) catch return null; const home = env.get("HOME") orelse return null; if (home.len == 0) return null; break :dir std.fs.path.join(arena, &.{ home, ".local", "state", "pardes" }) catch return null; }; std.Io.Dir.cwd().createDirPath(io, dir) catch return null; return std.fs.path.join(arena, &.{ dir, "store" }) catch null; }