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 upgrade = @import("upgrade.zig"); pub const std_options_debug_threaded_io: ?*std.Io.Threaded = std.Io.Threaded.global_single_threaded; pub const std_options_debug_io: std.Io = 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 = std.debug.FullPanic(struct { fn call(msg: []const u8, ret_addr: ?usize) noreturn { if (!recovering.swap(true, .seq_cst)) { pardes.replica.dying(); @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 = struct { pub fn handleSegfault(addr: ?usize, name: []const u8, opt_ctx: anytype) noreturn { if (!recovering.swap(true, .seq_cst)) { pardes.replica.dying(); @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!!. \\ --mount== mount a 9P session or Unix/TCP 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 (with \\ none, the one session): in this terminal for \\ `pardes`, a window for `pardes-gui`. One \\ attached already gets another view; one of the \\ other kind (a window's session in a terminal, \\ or the reverse) is joined as a client, as \\ --attach=:. Returns when the \\ session detaches or ends \\ --attach= ...the session called (its --9p or \\ --detach name, else its pid; see --ps) \\ --attach=: a client of session on another machine, \\ a terminal's or a window's (either kind's \\ session), over `ssh -L` to its pardes-replica.sock \\ ($PARDES_SSH: the ssh command, words, default \\ `ssh`; and \\ $PARDES_REMOTE_RUNTIME: its runtime directory, \\ if not this one's path). Its keys show at once \\ --attach=: ...through that socket (a path, with a '/'), \\ one forwarded already, or this machine's \\ --ps what the pardes daemon keeps: each session (its \\ pid, kind, whether attached) and its shells, then \\ the shells no session holds \\ --kill= end session and its shells (TERM, then \\ KILL 2 s later); unsaved changes are lost \\ --kill-all end every session and every shell the daemon keeps \\ --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(gpa: std.mem.Allocator, dial: []const u8, path: []const u8, known: ?u32) noreturn { // 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 { die(io, fmt ++ "\nTry 'pardes --help'.", args); } /// `pardes: ` on stderr, and exit 1. fn die(io: std.Io, comptime fmt: []const u8, args: anytype) noreturn { var buf: [8192]u8 = undefined; const line = std.fmt.bufPrint(&buf, "pardes: " ++ fmt ++ "\n", args) catch "pardes: refused\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 /// (wire.zig `semantics`). const version_text = upgrade.version_line ++ "\n" ++ std.fmt.comptimePrint("semantics {x:0>16}\n", .{@import("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. \\ ; pub const main = nativeMain; // glibc's struct termios is 60 bytes, Zig 0.17's std.c.termios the kernel's // 44: libc's tcgetattr wrote 16 bytes past every Zig caller's (vaxis's // makeRaw, the stub's, the GUI's), and a ReleaseSafe build trapped at its // first terminal. These take libc's place in the process: the kernel's own // ioctls, which read and write only the 36 bytes both layouts begin with // (the flags, the line, the kernel's 19 cc), so a caller of either size // stays within its struct. comptime { if (builtin.os.tag == .linux and builtin.abi.isGnu()) { @export(&kernelTcgetattr, .{ .name = "tcgetattr" }); @export(&kernelTcsetattr, .{ .name = "tcsetattr" }); } } fn kernelTcgetattr(fd: c_int, t: *std.os.linux.termios) callconv(.c) c_int { return libcResult(std.os.linux.tcgetattr(fd, t)); } fn kernelTcsetattr(fd: c_int, how: c_int, t: *const std.os.linux.termios) callconv(.c) c_int { return libcResult(std.os.linux.tcsetattr(fd, @fromBackingInt(@bitCast(how)), t)); } fn libcResult(rc: usize) c_int { const e = std.os.linux.errno(rc); if (e == .SUCCESS) return 0; std.c._errno().* = @intCast(@backingInt(e)); return -1; } test "tcgetattr writes nothing past a Zig termios" { if (comptime !(builtin.os.tag == .linux and builtin.abi.isGnu())) return error.SkipZigTest; const master = std.c.open("/dev/ptmx", .{ .ACCMODE = .RDWR, .NOCTTY = true, .CLOEXEC = true }, @as(std.c.mode_t, 0)); if (master < 0) return error.SkipZigTest; defer _ = std.c.close(master); var s: extern struct { t: std.c.termios, canary: [32]u8 } = .{ .t = undefined, .canary = @splat(0xAA) }; try std.testing.expectEqual(0, std.c.tcgetattr(master, &s.t)); try std.testing.expectEqualSlices(u8, &@as([32]u8, @splat(0xAA)), &s.canary); try std.testing.expectEqual(0, std.c.tcsetattr(master, .NOW, &s.t)); try std.testing.expectEqual(-1, std.c.tcgetattr(-1, &s.t)); } // init.gpa, what the tui, 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), or an upgrade of // one with its registry: nothing else. if (comptime daemon.supported) if (args.len >= 2 and args.len <= 3 and std.mem.eql(u8, args[1], "--daemon")) daemon.serve(if (args.len == 3 and std.mem.startsWith(u8, args[2], upgrade.flag)) args[2][upgrade.flag.len..] else null); // An upgraded session's new process (upgrade.zig): its record, then the // arguments it was started with, which configure it as before; its // file, stdin, directory and daemon come from the record instead. const upgraded = comptime upgrade.supported and (pardes.platform == .tui or pardes.platform == .gui); if (upgraded) if (args.len > 1 and std.mem.startsWith(u8, args[1], upgrade.flag)) { upgrade.resumed = upgrade.Record.decode(args[1][upgrade.flag.len..]) catch badArgs(init.io, "--upgraded: a record this build cannot read", .{}); }; const resuming = upgrade.resumed != null; 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 = if (resuming) 2 else 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.eql(u8, a, "--tty-toggle") or std.mem.startsWith(u8, a, "--tty-toggle=")) { session_only = false; new_session = true; const key = if (a.len > "--tty-toggle".len) a["--tty-toggle=".len..] else next: { i += 1; if (i >= args.len) badArgs(init.io, "--tty-toggle needs a letter after it", .{}); break :next args[i]; }; opts.tty_toggle = parseCtrlKey(key) orelse badArgs(init.io, "--tty-toggle wants one letter, not '{s}'", .{key}); } 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, "--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, "--ps")) { manage(init.io, "list", ""); } else if (std.mem.startsWith(u8, a, "--kill=")) { const name = a["--kill=".len..]; if (name.len == 0) badArgs(init.io, "--kill needs a session's name; --kill-all ends every one", .{}); manage(init.io, "kill", name); } else if (std.mem.eql(u8, a, "--kill-all")) { manage(init.io, "killall", ""); } 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.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 and !resuming) 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) die(init.io, "--wait: the session at {s} does not answer; it is gone", .{parent.dial[0..@min(parent.dial.len, 4096)]}); break :forwarding; }; const Refuse = struct { fn with(io: std.Io, what: []const u8, err: anyerror) noreturn { var words_buf: [128]u8 = undefined; die(io, "{s}: {s}", .{ what[0..@min(what.len, 4096)], if (err == error.Remote) ninep_io.Client.lastSaid() else forwardWords(err, &words_buf) }); } }; // 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) die(init.io, "{s}: {s}", .{ word[0..@min(word.len, 4096)], why }); Refuse.with(init.io, word, err); }; } if (wait) waitForDel(arena, parent.dial, path, made_serial); return; } if (resuming) positional = null; // `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.state = .disk; opts.recent_import = oldRecentDir(arena, init.environ_map); if (found.dir) |d| @import("crash.zig").setDir(d); if (attach) |name| if (std.mem.lastIndexOfScalar(u8, name, ':')) |colon| { remoteAttach(init, opts, name[0..colon], name[colon + 1 ..]); }; if (attach) |name| if (!resuming) attachTo(init, opts, 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 !resuming and ninep_io.taken(name)) die(init.io, "a session named {s} is already running", .{name}); 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("tui/tui.zig").Term = if (detach != null) .none else .open; var headless = detach != null; upgrade.remember(args); if (upgrade.resumed) |*rec| { // Close-on-exec again: a shell forked from here inherits none. rec.closeOnExec(true); opts.load_path = rec.dump; term = .none; for (rec.ttys[0..rec.nttys]) |t| if (t.primary) { term = .{ .fd = .{ .fd = t.fd, .termios = t.termios } }; }; headless = if (pardes.platform == .gui) !rec.window else rec.nttys == 0; daemon.resumeLink(rec.link, rec.stub, kind, opts.ninep_name, headless); } else if (daemon.wanted()) { if (detach != null or pardes.platform == .gui) { _ = daemon.register(null, kind, opts.ninep_name, detach != null); } else if (pardes.platform == .tui) 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 = fd } }; } } defer daemon.quit(); errdefer daemon.tellStubExit(1); switch (pardes.platform) { .tui => @import("tui/tui.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, headless), .macos => unreachable, } daemon.tellStubExit(0); } extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int; extern "c" fn atexit(f: *const fn () callconv(.c) void) c_int; /// `pardes --ps`: what the per-user daemon keeps, as a tree; `--kill=` /// and `--kill-all`: those sessions ended with their shells, a TERM and, /// for one still there 2 s later, a KILL. fn manage(io: std.Io, verb: []const u8, name: []const u8) noreturn { if (comptime !daemon.supported) die(io, "this system has no pardes daemon", .{}); var words_buf: [300]u8 = undefined; const words = if (std.mem.eql(u8, verb, "kill")) std.fmt.bufPrint(&words_buf, "kill {s}", .{name}) catch die(io, "that name is too long", .{}) else verb; var buf: [4096]u8 = undefined; const said = daemon.ask(words, &buf) orelse die(io, "no pardes daemon is running", .{}); if (std.mem.startsWith(u8, said, "no ")) die(io, "{s}", .{said[3..]}); if (std.mem.eql(u8, verb, "list")) { var out: [8192]u8 = undefined; var w: std.Io.Writer = .fixed(&out); var lines = std.mem.tokenizeScalar(u8, said, '\n'); var orphans = false; while (lines.next()) |line| { var it = std.mem.tokenizeScalar(u8, line, ' '); const what = it.next() orelse continue; const pid = it.next() orelse continue; var comm_buf: [64]u8 = undefined; const comm = commOf(pid, &comm_buf); if (std.mem.eql(u8, what, "daemon")) { w.print("pardes daemon {s}\n", .{pid}) catch break; } else if (std.mem.eql(u8, what, "session")) { const kind = it.next() orelse ""; const state = it.next() orelse ""; w.print(" session {s} {s} ({s}, {s})\n", .{ std.mem.trim(u8, it.rest(), " "), pid, kind, state }) catch break; } else if (std.mem.eql(u8, what, "shell")) { w.print(" shell {s} {s}\n", .{ pid, comm }) catch break; } else if (std.mem.eql(u8, what, "orphan")) { if (!orphans) w.writeAll(" shells no session holds (Adopt takes them, --kill-all ends them)\n") catch break; orphans = true; w.print(" shell {s} {s}\n", .{ pid, comm }) catch break; } } std.Io.File.stdout().writeStreamingAll(io, w.buffered()) catch {}; std.process.exit(0); } var pids: [64]std.c.pid_t = undefined; var n: usize = 0; var it = std.mem.tokenizeScalar(u8, said, ' '); _ = it.next(); // ok while (it.next()) |p| if (n < pids.len) { pids[n] = std.fmt.parseInt(std.c.pid_t, p, 10) catch continue; n += 1; }; // Gone once the daemon no longer lists them: a session's link ends with // its process, a zombie's too, which kill(pid, 0) would call alive. const Gone = struct { fn all(list: []const std.c.pid_t, ms: u32) bool { var waited: u32 = 0; while (true) : (waited += 20) { var reply: [4096]u8 = undefined; const now = daemon.ask("list", &reply) orelse return true; var lines = std.mem.tokenizeScalar(u8, now, '\n'); const left = while (lines.next()) |line| { var fields = std.mem.tokenizeScalar(u8, line, ' '); if (!std.mem.eql(u8, fields.next() orelse "", "session")) continue; const pid = std.fmt.parseInt(std.c.pid_t, fields.next() orelse "", 10) catch continue; if (std.mem.indexOfScalar(std.c.pid_t, list, pid) != null) break true; } else false; if (!left) return true; if (waited >= ms) return false; const ts: std.c.timespec = .{ .sec = 0, .nsec = 20 * std.time.ns_per_ms }; _ = std.c.nanosleep(&ts, null); } } }; if (!Gone.all(pids[0..n], 2000)) { for (pids[0..n]) |p| _ = std.c.kill(p, .KILL); if (!Gone.all(pids[0..n], 1000)) die(io, "a session would not end, even killed", .{}); } std.process.exit(0); } /// The command `pid` runs, as /proc says it (Linux); empty where it does not. fn commOf(pid: []const u8, buf: *[64]u8) []const u8 { var path_buf: [64]u8 = undefined; const path = std.fmt.bufPrintSentinel(&path_buf, "/proc/{s}/comm", .{pid}, 0) catch return ""; const fd = std.c.open(path, .{ .ACCMODE = .RDONLY, .CLOEXEC = true }, @as(std.c.mode_t, 0)); if (fd < 0) return ""; defer _ = std.c.close(fd); const got = std.c.read(fd, buf, buf.len); if (got <= 0) return ""; return std.mem.trimEnd(u8, buf[0..@intCast(got)], "\n"); } /// The replica client of this build's frontend: a terminal's (tui.zig) or a /// window's (gui.zig). fn clientOf(init: std.process.Init, opts: pardes.Options, path: []const u8, name: []const u8, far: bool) !void { switch (pardes.platform) { .tui => try @import("tui/tui.zig").remote(init, opts, path, name, far), .gui => try @import("gui/gui.zig").remote(init, opts, path, name, far), else => unreachable, } } /// `pardes --attach=:` (`pardes-gui` too): a replica client /// (tui.zig and gui.zig `remote`), through the socket `where` names, or /// through `ssh -L` of host `where`'s replica socket to one of this /// process's. fn remoteAttach(init: std.process.Init, opts: pardes.Options, where: []const u8, name: []const u8) noreturn { const io = init.io; if (comptime pardes.platform != .tui and pardes.platform != .gui) unreachable; if (std.mem.indexOfScalar(u8, where, '/') != null) { clientOf(init, opts, where, name, false) catch |err| die(io, "--attach: {t}", .{err}); std.process.exit(0); } // ssh -L : , until the socket here answers. var here_buf: [ninep_io.sun_path_len:0]u8 = undefined; const tmp = std.mem.span(std.c.getenv("TMPDIR") orelse "/tmp"); const here = std.fmt.bufPrintSentinel(&here_buf, "{s}/pardes-ssh-{d}.sock", .{ tmp, std.c.getpid() }, 0) catch die(io, "--attach: TMPDIR is too long for a socket's path", .{}); var there_buf: [ninep_io.sun_path_len + 64:0]u8 = undefined; var dir_buf: [ninep_io.sun_path_len:0]u8 = undefined; const dir = if (std.c.getenv("PARDES_REMOTE_RUNTIME")) |d| std.mem.span(d) else ninep_io.socketDir(&dir_buf) orelse die(io, "--attach: no runtime directory to name the remote socket by: set PARDES_REMOTE_RUNTIME", .{}); var forward_buf: [2 * ninep_io.sun_path_len + 64]u8 = undefined; const there = std.fmt.bufPrintSentinel(&there_buf, "{s}/pardes-replica.sock", .{dir}, 0) catch unreachable; const forward = std.fmt.bufPrintSentinel(&forward_buf, "{s}:{s}", .{ here, there }, 0) catch unreachable; var host_buf: [256]u8 = undefined; const host = std.fmt.bufPrintSentinel(&host_buf, "{s}", .{where}, 0) catch die(io, "--attach: that host's name is too long", .{}); var argv: [48:null]?[*:0]const u8 = @splat(null); var n: usize = 0; var words_buf: [1024]u8 = undefined; // Not `ssh -C`: what the session sends a far client is zstd already // (replica.zig), and zlib over it costs both ends' time for nothing. // ponytail: what the client sends goes as it is, keys and a paste // alike; a big paste through a slow link is the ceiling, and would be // an envelope of its own. $PARDES_SSH, when set, is the whole command. var words = std.mem.tokenizeScalar(u8, std.mem.span(std.c.getenv("PARDES_SSH") orelse "ssh"), ' '); var at: usize = 0; while (words.next()) |w| { if (n >= 40 or at + w.len + 1 > words_buf.len) die(io, "--attach: PARDES_SSH has too many words", .{}); @memcpy(words_buf[at..][0..w.len], w); words_buf[at + w.len] = 0; argv[n] = @ptrCast(&words_buf[at]); n += 1; at += w.len + 1; } // A terminal asked for and a command that waits, not -N: only an // interactive connection gets TCP_NODELAY from ssh and sshd, and with // Nagle each key in a burst waited for the last one's ACK, a round trip. for ([_][*:0]const u8{ "-tt", "-q", "-o", "ExitOnForwardFailure=yes", "-L", forward.ptr, host.ptr, "exec sleep 2147483647" }) |a| { argv[n] = a; n += 1; } _ = std.c.unlink(here); const pid = std.c.fork(); if (pid < 0) die(io, "--attach: no fork for ssh", .{}); if (pid == 0) { // A client killed outright takes its ssh with it. daemon.hupOnStubDeath(true); const null_fd = std.c.open("/dev/null", .{ .ACCMODE = .RDONLY }, @as(std.c.mode_t, 0)); if (null_fd >= 0) _ = std.c.dup2(null_fd, 0); _ = execvp(argv[0].?, &argv); std.c._exit(127); } // Ended at the client's exit, whatever path it takes there (its own // words on a refused redial exit from inside it). ponytail: a client // that crashes leaves its socket's file behind; its ssh goes. const Ssh = struct { var child: std.c.pid_t = 0; var path: [:0]const u8 = ""; fn end() callconv(.c) void { if (child > 0) { _ = std.c.kill(child, .TERM); _ = std.c.waitpid(child, null, 0); } _ = std.c.unlink(path); } }; Ssh.child = pid; Ssh.path = here; _ = atexit(Ssh.end); var waited: u32 = 0; while (std.c.access(here, std.c.F_OK) != 0) : (waited += 1) { var status: c_int = 0; if (std.c.waitpid(pid, &status, std.c.W.NOHANG) == pid) { Ssh.child = 0; die(io, "--attach: ssh to {s} ended before its forward was up", .{where}); } if (waited > 3000) die(io, "--attach: ssh to {s} set up no forward in 30 s", .{where}); const ts: std.c.timespec = .{ .sec = 0, .nsec = 10 * std.time.ns_per_ms }; _ = std.c.nanosleep(&ts, null); } clientOf(init, opts, here, name, true) catch |err| die(io, "--attach: {t}", .{err}); std.process.exit(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. A /// session of the other kind is joined as a replica client, through this /// machine's replica socket. fn attachTo(init: std.process.Init, opts: pardes.Options, name: []const u8) noreturn { const io = init.io; var words: [600]u8 = undefined; if (comptime !daemon.supported) die(io, "--attach: 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| die(io, "--attach: {s}", .{why}), .other => |named| crossAttach(init, opts, named), }; const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0)); if (fd < 0) die(io, "--attach: 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) die(io, "--attach: 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| die(io, "--attach: {s}", .{why}), .other => |named| { _ = std.c.close(fd); _ = std.c.close(pipe[0]); _ = std.c.close(pipe[1]); crossAttach(init, opts, named); }, } } /// A session of the other kind (`--attach`'s): a replica client of it here. fn crossAttach(init: std.process.Init, opts: pardes.Options, name: []const u8) noreturn { var sock_buf: [ninep_io.sun_path_len:0]u8 = undefined; const sock = daemon.replicaSocket(&sock_buf) orelse die(init.io, "--attach: no runtime directory for the replica socket", .{}); remoteAttach(init, opts, sock, name); } 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("wire.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 == .tui) { _ = @import("tui/tui.zig"); } if (comptime pardes.platform == .gui) _ = @import("gui/gui.zig"); if (comptime pardes.font_picker) _ = @import("fonts.zig"); } /// Where Recent's file (0.24) and the store before it were kept: /// $XDG_STATE_HOME/pardes, else ~/.local/state/pardes. A state file that /// holds no Recent yet reads them once (Db.zig). fn oldRecentDir(arena: std.mem.Allocator, env: *const std.process.Environ.Map) ?[]const u8 { if (env.get("XDG_STATE_HOME")) |base| if (base.len != 0 and std.fs.path.isAbsolute(base)) return std.fs.path.join(arena, &.{ base, "pardes" }) catch null; const home = env.get("HOME") orelse return null; if (home.len == 0) return null; return std.fs.path.join(arena, &.{ home, ".local", "state", "pardes" }) catch null; }