HAXY

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

╭──────────╮ │← previous│ ╰──────────╯ ╭ changed ────╮ │src/serve.zig│ ╰─────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │70 │ │71 // the admin repo path is where the user/repo metadata events live │ │72 │ │73 - const admin_repo_path = try std.fs.path.resolve(allocator, &.{ data_dir_path, "admin" }); │ │73 + const admin_repo_path = try std.Io.Dir.path.resolveAlloc(allocator, &.{ data_dir_path, "admin" });│ │74 defer allocator.free(admin_repo_path); │ │75 │ │76 // create the admin repo on first run │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭ changed ─────────╮ │src/serve_http.zig│ ╰──────────────────╯ ╭───────────────────────────────────────────────────────────────────────────────────────╮ │51 stream: std.Io.net.Stream, │ │52 err: *std.Io.Writer, │ │53 ) !void { │ │54 - var send_buffer = [_]u8{0} ** any_repo_opts.net_buffer_size; │ │55 - var recv_buffer = [_]u8{0} ** any_repo_opts.net_buffer_size; │ │54 + var send_buffer: [any_repo_opts.net_buffer_size]u8 = @splat(0); │ │55 + var recv_buffer: [any_repo_opts.net_buffer_size]u8 = @splat(0); │ │56 var conn_br = stream.reader(io, &recv_buffer); │ │57 var conn_bw = stream.writer(io, &send_buffer); │ │58 var http_server = std.http.Server.init(&conn_br.interface, &conn_bw.interface);│ ╰───────────────────────────────────────────────────────────────────────────────────────╯ ╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │254 errdefer allocator.free(mutable); │ │255 const decoded = std.Uri.percentDecodeInPlace(mutable); │ │256 │ │257 - var iter = std.fs.path.componentIterator(decoded); │ │257 + var iter = std.Io.Dir.path.componentIterator(decoded); │ │258 while (iter.next()) |component| { │ │259 if (component.name.len == 0 or std.mem.eql(u8, component.name, ".") or std.mem.eql(u8, component.name, "..")) {│ │260 return error.InvalidRepoPath; │ ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭ changed ─────────────────╮ │src/serve_ssh_protocol.zig│ ╰──────────────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │123 keypair: Ed25519.KeyPair, │ │124 │ │125 pub fn loadOrGenerate(io: std.Io, allocator: std.mem.Allocator, data_dir_path: []const u8) !HostKey {│ │126 - const path = try std.fs.path.join(allocator, &.{ data_dir_path, host_key_file_name }); │ │126 + const path = try std.Io.Dir.path.join(allocator, &.{ data_dir_path, host_key_file_name }); │ │127 defer allocator.free(path); │ │128 │ │129 const cwd = std.Io.Dir.cwd(); │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │141 defer allocator.free(text); │ │142 defer std.crypto.secureZero(u8, text); │ │143 // owner-only from the start — never a window where the key is readable │ │144 - const permissions: std.Io.File.Permissions = if (builtin.os.tag == .windows) .default_file else @enumFromInt(0o600); │ │144 + const permissions: std.Io.File.Permissions = if (builtin.target.os.tag == .windows) .default_file else @fromBackingInt(@intCast(0o600));│ │145 // linked into place only once complete, and never over an existing key │ │146 var atomic_file = try cwd.createFileAtomic(io, path, .{ .permissions = permissions }); │ │147 defer atomic_file.deinit(io); │ ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭───────────────────────────────────────────────────────────────────────────────────╮ │776 defer std.crypto.secureZero(u8, std.mem.asBytes(&conn.cs_cipher)); │ │777 defer std.crypto.secureZero(u8, std.mem.asBytes(&conn.sc_cipher)); │ │778 │ │779 - errdefer |err| disconnectOnError(&conn, err); │ │779 + authAndRunChannels(&conn, handler) catch |err| { │ │780 + disconnectOnError(&conn, err); │ │781 + return err; │ │782 + }; │ │783 +} │ │784 │ │781 - const fingerprint = try runAuth(&conn); │ │782 - try runChannelLayer(&conn, &fingerprint, handler); │ │785 +fn authAndRunChannels(conn: *Conn, handler: anytype) !void { │ │786 + const fingerprint = try runAuth(conn); │ │787 + try runChannelLayer(conn, &fingerprint, handler); │ │788 } │ │789 │ │790 /// tell the peer why we're hanging up (RFC 4253 §11.1), best effort. protocol│ ╰───────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │1877 const pk = rsa.PublicKey.fromBytes(e, n) catch return false; │ │1878 switch (n.len) { │ │1879 inline 256, 384, 512 => |len| { │ │1875 - rsa.PKCS1v1_5Signature.verify(len, sig[0..len].*, signed, pk, Hash) catch return false;│ │1880 + rsa.PKCS1v1_5Signature.verify(len, sig[0..len], signed, pk, Hash) catch return false; │ │1881 return true; │ │1882 }, │ │1883 else => return false, │ ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────╮ │2244 test "channel close before shell or exec is acknowledged" {│ │2245 const io = std.testing.io; │ │2246 const allocator = std.testing.allocator; │ │2242 - const key = [_]u8{0x5a} ** 64; │ │2247 + const key: [64]u8 = @splat(0x5a); │ │2248 var encoded: [256]u8 = undefined; │ │2249 var encoded_writer = std.Io.Writer.fixed(&encoded); │ │2250 var sender = Cipher.init(&key, 0); │ ╰─────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────────────────────────────────────────────────────────────╮ │2277 } │ │2278 }; │ │2279 var handler = Handler{}; │ │2275 - try runChannelLayer(&conn, &([_]u8{0} ** fingerprint_len), &handler); │ │2280 + try runChannelLayer(&conn, &@as([fingerprint_len]u8, @splat(0)), &handler);│ │2281 var output_reader = std.Io.Reader.fixed(writer.buffered()); │ │2282 var receiver = Cipher.init(&key, 0); │ │2283 const confirmation = try receiver.readPacket(allocator, &output_reader); │ ╰─────────────────────────────────────────────────────────────────────────────────────╯ ╭ changed ─────────╮ │src/test/event.zig│ ╰──────────────────╯ ╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ │552 const issue_id_set = try Repo.DB.SortedSet(.read_only).init(issue_id_set_cursor);│ │553 try std.testing.expectEqual(6, try issue_id_set.count()); │ │554 │ │555 - var found = [_]bool{false} ** 6; │ │555 + var found: [6]bool = @splat(false); │ │556 var iter = try issue_id_set.iteratorFromIndex(0); │ │557 while (try iter.next()) |id_cursor_val| { │ │558 var id_cursor = id_cursor_val; │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭──────╮ │next →│ ╰──────╯