1/// Cfg is zmx's configuration container.
  2///
  3/// The purpose of this container is to hold anything that can be modified by the user.
  4pub const Cfg = @This();
  5
  6const std = @import("std");
  7const lib_posix = @import("posix.zig");
  8const cross = @import("cross.zig");
  9
 10socket_dir: []const u8,
 11log_dir: []const u8,
 12max_scrollback_lines: usize = 10_000,
 13dir_mode: u32 = 0o750,
 14log_mode: u32 = 0o640,
 15tracked_envs: []const u8 = "DISPLAY,SSH_AUTH_SOCK,SSH_AGENT_PID,SSH_CONNECTION,WINDOWID,XAUTHORITY,KITTY_LISTEN_ON,KITTY_PID,KITTY_WINDOW_ID",
 16
 17pub fn init(alloc: std.mem.Allocator, io: std.Io) !Cfg {
 18    const socket_dir = try socketDir(alloc);
 19    errdefer alloc.free(socket_dir);
 20    const log_dir = try logDir(alloc);
 21    errdefer alloc.free(log_dir);
 22
 23    const dir_mode = if (lib_posix.getenv("ZMX_DIR_MODE")) |m|
 24        std.fmt.parseInt(u32, m, 8) catch 0o750
 25    else
 26        0o750;
 27
 28    const log_mode = if (lib_posix.getenv("ZMX_LOG_MODE")) |m|
 29        std.fmt.parseInt(u32, m, 8) catch 0o640
 30    else
 31        0o640;
 32
 33    var cfg = Cfg{
 34        .socket_dir = socket_dir,
 35        .log_dir = log_dir,
 36        .dir_mode = dir_mode,
 37        .log_mode = log_mode,
 38    };
 39
 40    try cfg.mkdir(io);
 41
 42    return cfg;
 43}
 44
 45fn socketDir(alloc: std.mem.Allocator) ![]const u8 {
 46    const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
 47    const uid = lib_posix.getuid();
 48
 49    const socket_dir: []const u8 = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
 50        try alloc.dupe(u8, zmxdir)
 51    else if (lib_posix.getenv("XDG_RUNTIME_DIR")) |xdg_runtime|
 52        try std.fmt.allocPrint(alloc, "{s}/zmx", .{xdg_runtime})
 53    else
 54        try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });
 55
 56    return socket_dir;
 57}
 58
 59fn logDir(alloc: std.mem.Allocator) ![]const u8 {
 60    const log_dir = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
 61        try std.fmt.allocPrint(alloc, "{s}/logs", .{zmxdir})
 62    else if (lib_posix.getenv("XDG_STATE_HOME")) |xdg_state_home|
 63        try std.fmt.allocPrint(alloc, "{s}/zmx/logs", .{xdg_state_home})
 64    else if (lib_posix.getenv("HOME")) |home_dir|
 65        try std.fmt.allocPrint(alloc, "{s}/.local/state/zmx/logs", .{home_dir})
 66    else fallback: {
 67        // This is the last resort: falling back to /tmp/$UID if HOME is unset.
 68        const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
 69        const uid = lib_posix.getuid();
 70        break :fallback try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });
 71    };
 72
 73    return log_dir;
 74}
 75
 76pub fn deinit(self: *Cfg, alloc: std.mem.Allocator) void {
 77    if (self.socket_dir.len > 0) alloc.free(self.socket_dir);
 78    if (self.log_dir.len > 0) alloc.free(self.log_dir);
 79}
 80
 81pub fn mkdir(self: *Cfg, io: std.Io) !void {
 82    const sock_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
 83    try mkdirAll(io, self.socket_dir, sock_perms);
 84    const log_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
 85    try mkdirAll(io, self.log_dir, log_perms);
 86}
 87
 88fn mkdirAll(io: std.Io, sub_dir_path: []const u8, permissions: std.Io.Dir.Permissions) !void {
 89    var it = std.fs.path.componentIterator(sub_dir_path);
 90    var component = it.last() orelse return error.BadPathName;
 91    while (true) {
 92        std.Io.Dir.createDirAbsolute(io, component.path, permissions) catch |err| switch (err) {
 93            error.PathAlreadyExists => {},
 94            error.FileNotFound => |e| {
 95                component = it.previous() orelse return e;
 96                continue;
 97            },
 98            else => |e| return e,
 99        };
100        component = it.next() orelse return;
101    }
102}
103
104test "Cfg.init uses default modes when env vars are not set" {
105    const alloc = std.testing.allocator;
106
107    // Ensure they are not set
108    _ = cross.c.unsetenv("ZMX_DIR_MODE");
109    _ = cross.c.unsetenv("ZMX_LOG_MODE");
110
111    var cfg = try Cfg.init(alloc, std.testing.io);
112    defer cfg.deinit(alloc);
113
114    try std.testing.expectEqual(@as(u32, 0o750), cfg.dir_mode);
115    try std.testing.expectEqual(@as(u32, 0o640), cfg.log_mode);
116}
117
118test "Cfg.init uses custom modes from env vars" {
119    const alloc = std.testing.allocator;
120
121    // Set custom octal values
122    _ = cross.c.setenv("ZMX_DIR_MODE", "770", 1);
123    _ = cross.c.setenv("ZMX_LOG_MODE", "660", 1);
124    defer {
125        _ = cross.c.unsetenv("ZMX_DIR_MODE");
126        _ = cross.c.unsetenv("ZMX_LOG_MODE");
127    }
128
129    var cfg = try Cfg.init(alloc, std.testing.io);
130    defer cfg.deinit(alloc);
131
132    try std.testing.expectEqual(@as(u32, 0o770), cfg.dir_mode);
133    try std.testing.expectEqual(@as(u32, 0o660), cfg.log_mode);
134}