HAXY

▄▄ ▀▀▀▄ ▄▄ ▀▀▀▀▀▄ ▄▀▀▀▀ ▀▀▀▀▀▀ ▄▀▀▀▀▀▀ ▀▀▀▀▀▀ ▀ ▀ ▄▀▀▀▀▀▀ ▀▀▀▀▀▀ ▄▀ ▄▀ ▄▀▀▀▀▀▀▀▀ ▀▀▀▄▄ ▀▀▀▀▀▀ ▀▀ ▀▄▀▀ ▄▀ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▄ ▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀ ▄ ▄▀▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀ ▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄▄▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀▀▄ ▀▀▀ ▀▀▀▀▀▀▀▀ ▀▀▀ ▀▀▀ ▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀ ▀▀▀▄▀▄ ▄▄▄▀▀ ▀▀▀▀▀▀ ▀▀▄▀▀▀▀▀▀▀ ▀▀▀▀▀▄▀▀▀▀▀ ▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▄▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀

╭ changed ─────────────────╮ │src/serve_ssh_protocol.zig│ ╰──────────────────────────╯ ╭───────────╮ │← all files│ ╰───────────╯ ╭──────────╮ │← previous│ ╰──────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │1878 -fn replyChannelRequest( │ │1879 - io: std.Io, │ │1880 - allocator: std.mem.Allocator, │ │1881 - sc_cipher: *Cipher, │ │1882 - writer: *std.Io.Writer, │ │1883 - ch: *Channel, │ │1884 - want_reply: bool, │ │1885 - success: bool, │ │1886 -) !void { │ │1832 +fn replyChannelRequest(conn: *Conn, ch: *Channel, want_reply: bool, success: bool) !void { │ │1833 if (!want_reply) return; │ │1834 var reply: std.ArrayList(u8) = .empty; │ │1889 - defer reply.deinit(allocator); │ │1890 - try reply.append(allocator, if (success) SSH_MSG_CHANNEL_SUCCESS else SSH_MSG_CHANNEL_FAILURE); │ │1891 - try writeU32(&reply, allocator, ch.remote_id); │ │1892 - try sc_cipher.writePacket(io, writer, reply.items); │ │1835 + defer reply.deinit(conn.allocator); │ │1836 + try reply.append(conn.allocator, if (success) SSH_MSG_CHANNEL_SUCCESS else SSH_MSG_CHANNEL_FAILURE);│ │1837 + try writeU32(&reply, conn.allocator, ch.remote_id); │ │1838 + try conn.sc_cipher.writePacket(conn.io, conn.writer, reply.items); │ │1839 } │ │1840 │ │1841 fn handleWindowAdjust(ch: *Channel, packet: []const u8) !void { │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ │1849 ch.remote_window +|= add; │ │1850 } │ │1851 │ │1906 -fn discardChannelData( │ │1907 - io: std.Io, │ │1908 - allocator: std.mem.Allocator, │ │1909 - sc_cipher: *Cipher, │ │1910 - writer: *std.Io.Writer, │ │1911 - ch: *Channel, │ │1912 - packet: []const u8, │ │1913 - extended: bool, │ │1914 -) !void { │ │1852 +fn discardChannelData(conn: *Conn, ch: *Channel, packet: []const u8, extended: bool) !void {│ │1853 // byte SSH_MSG_CHANNEL_DATA/EXTENDED_DATA │ │1854 // uint32 recipient_channel │ │1855 // [if extended: uint32 type_code] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────╮ │1859 │ │1860 if (data_len > ch.local_window) return error.WindowExceeded; │ │1861 ch.local_window -= data_len; │ │1924 - try maybeRefillRecvWindow(io, allocator, sc_cipher, writer, ch); │ │1862 + try maybeRefillRecvWindow(conn, ch); │ │1863 } │ │1864 │ │1865 pub fn parseChannelData(packet: []const u8, extended: bool, expected_channel: u32) ![]const u8 {│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────╮ │1889 /// Send a CHANNEL_WINDOW_ADJUST if our receive window has dipped below half│ │1890 /// of the initial value. Used both for the pre-session discard path and by │ │1891 /// SessionCtx after it consumes a CHANNEL_DATA payload. │ │1954 -fn maybeRefillRecvWindow( │ │1955 - io: std.Io, │ │1956 - allocator: std.mem.Allocator, │ │1957 - sc_cipher: *Cipher, │ │1958 - writer: *std.Io.Writer, │ │1959 - ch: *Channel, │ │1960 -) !void { │ │1892 +fn maybeRefillRecvWindow(conn: *Conn, ch: *Channel) !void { │ │1893 if (ch.local_window >= initial_recv_window / 2) return; │ │1894 const add = initial_recv_window - ch.local_window; │ │1895 ch.local_window += add; │ ╰──────────────────────────────────────────────────────────────────────────────────╯ ╭────────────────────────────────────────────────────────────────────────────────────────────────╮ │1896 var adj: std.ArrayList(u8) = .empty; │ │1965 - defer adj.deinit(allocator); │ │1966 - try adj.append(allocator, SSH_MSG_CHANNEL_WINDOW_ADJUST); │ │1967 - try writeU32(&adj, allocator, ch.remote_id); │ │1968 - try writeU32(&adj, allocator, add); │ │1969 - try sc_cipher.writePacket(io, writer, adj.items); │ │1897 + defer adj.deinit(conn.allocator); │ │1898 + try adj.append(conn.allocator, SSH_MSG_CHANNEL_WINDOW_ADJUST); │ │1899 + try writeU32(&adj, conn.allocator, ch.remote_id); │ │1900 + try writeU32(&adj, conn.allocator, add); │ │1901 + try conn.sc_cipher.writePacket(conn.io, conn.writer, adj.items); │ │1902 } │ │1903 │ │1904 pub fn writeU32(buf: *std.ArrayList(u8), allocator: std.mem.Allocator, value: u32) !void {│ ╰────────────────────────────────────────────────────────────────────────────────────────────────╯