╭ changed ────────╮ │src/serve_ssh.zig│ ╰─────────────────╯ ╭───────────╮ │← all files│ ╰───────────╯ ╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │29 err: *std.Io.Writer, │ │30 │ │31 pub fn handleSession(self: *const SessionHandler, sess: *ssh.SessionCtx, request: ssh.Request) !void { │ │32 - serve_common.logError(self.err, "ssh session: kind={s} key={s}\n", .{ @tagName(request), sess.fingerprint }); │ │32 + serve_common.logError(sess.conn.io, self.err, "ssh session: kind={s} key={s}\n", .{ @tagName(request), sess.fingerprint });│ │33 switch (request) { │ │34 .shell => |pty_maybe| { │ │35 const pty = pty_maybe orelse { │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │74 const prev_count = active_connections.fetchAdd(1, .monotonic); │ │75 defer _ = active_connections.fetchSub(1, .monotonic); │ │76 if (prev_count >= max_connections) { │ │77 - serve_common.logError(ctx.err, "ssh: connection limit reached, dropping\n", .{}); │ │77 + serve_common.logError(ctx.io, ctx.err, "ssh: connection limit reached, dropping\n", .{});│ │78 return; │ │79 } │ │80 │ ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │81 var idle_state = ssh.IdleState{}; │ │82 var watchdog_future = std.Io.concurrent(ctx.io, watchdog, .{ ctx.io, &stream, &idle_state }) catch |spawn_err| {│ │83 - serve_common.logError(ctx.err, "ssh: watchdog spawn failed: {s}\n", .{@errorName(spawn_err)}); │ │83 + serve_common.logError(ctx.io, ctx.err, "ssh: watchdog spawn failed: {s}\n", .{@errorName(spawn_err)}); │ │84 return; │ │85 }; │ │86 defer watchdog_future.cancel(ctx.io); │ ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ 98 &idle_state, │ │ 99 ctx.session_handler, │ │100 ) catch |session_err| { │ │101 - serve_common.logError(ctx.err, "ssh session failed: {s}\n", .{@errorName(session_err)}); │ │101 + serve_common.logError(ctx.io, ctx.err, "ssh session failed: {s}\n", .{@errorName(session_err)});│ │102 }; │ │103 } │ │104 }.h; │ ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │162 // runs as the function unwinds — so any error it returns leaves the TUI torn │ │163 // down and we can surface the failure on the restored screen before exiting. │ │164 runTui(handler, sess, pty) catch |err| { │ │165 - serve_common.logError(handler.err, "ssh tui session failed: {s}\n", .{@errorName(err)}); │ │165 + serve_common.logError(sess.conn.io, handler.err, "ssh tui session failed: {s}\n", .{@errorName(err)}); │ │166 var buf: [256]u8 = undefined; │ │167 const msg = std.fmt.bufPrint(&buf, "haxy ssh: {s}\r\n", .{@errorName(err)}) catch "haxy ssh: internal error\r\n";│ │168 sess.writeBytes(msg) catch {}; │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯