tiny.quic.connection

1pub const Range = struct {2    smallest: u62,3    largest: u62,4};

1pub const Ranges = struct {2    values: []Range,3    count: u16 = 0,45    pub fn init(values: []Range) Ranges {6        std.debug.assert(values.len <= std.math.maxInt(u16));7        for (values) |*value| value.* = .{ .smallest = 0, .largest = 0 };8        return .{ .values = values };9    }1011    pub fn contains(self: *const Ranges, packet_number: u62) bool {12        for (0..self.values.len) |index| {13            if (index >= self.count) break;14            const value = self.values[index];15            if (packet_number < value.smallest) return false;16            if (packet_number <= value.largest) return true;17        }18        return false;19    }2021    pub fn insert(self: *Ranges, packet_number: u62) bool {22        if (self.contains(packet_number)) return false;23        var at = self.insertionIndex(packet_number);24        const joins_left = self.joinsLeft(at, packet_number);25        const joins_right = self.joinsRight(at, packet_number);26        if (joins_left and joins_right) {27            self.values[at - 1].largest = self.values[at].largest;28            self.remove(at);29            return true;30        }31        if (joins_left) {32            self.values[at - 1].largest = packet_number;33            return true;34        }35        if (joins_right) {36            self.values[at].smallest = packet_number;37            return true;38        }39        if (self.count == self.values.len) {40            if (at == 0) return true;41            self.remove(0);42            at = self.insertionIndex(packet_number);43        }44        self.insertAt(at, .{ .smallest = packet_number, .largest = packet_number });45        return true;46    }4748    pub fn encode(self: *const Ranges, delay: u62, output: *quic.cursor.Write) !void {49        if (self.count == 0) return error.EmptyRanges;50        std.debug.assert(self.count <= self.values.len);51        std.debug.assert(self.count - 1 <= quic.frame.ack_ranges_max);52        const newest = self.values[self.count - 1];53        try output.byte(0x02);54        _ = try quic.varint.write(newest.largest, output);55        _ = try quic.varint.write(delay, output);56        _ = try quic.varint.write(self.count - 1, output);57        _ = try quic.varint.write(newest.largest - newest.smallest, output);58        var previous = newest;59        for (0..self.values.len) |reverse| {60            if (reverse + 1 >= self.count) break;61            const index = self.count - 2 - reverse;62            const current = self.values[index];63            _ = try quic.varint.write(previous.smallest - current.largest - 2, output);64            _ = try quic.varint.write(current.largest - current.smallest, output);65            previous = current;66        }67    }6869    fn insertionIndex(self: *const Ranges, packet_number: u62) usize {70        for (0..self.values.len) |index| {71            if (index >= self.count) return index;72            if (packet_number < self.values[index].smallest) return index;73        }74        return self.count;75    }7677    fn joinsLeft(self: *const Ranges, at: usize, packet_number: u62) bool {78        if (at == 0) return false;79        const largest = self.values[at - 1].largest;80        if (largest == std.math.maxInt(u62)) return false;81        return largest + 1 == packet_number;82    }8384    fn joinsRight(self: *const Ranges, at: usize, packet_number: u62) bool {85        if (at >= self.count) return false;86        if (packet_number == std.math.maxInt(u62)) return false;87        return packet_number + 1 == self.values[at].smallest;88    }8990    fn insertAt(self: *Ranges, at: usize, value: Range) void {91        std.debug.assert(self.count < self.values.len);92        var index: usize = self.count;93        for (0..self.values.len) |_| {94            if (index <= at) break;95            self.values[index] = self.values[index - 1];96            index -= 1;97        }98        self.values[at] = value;99        self.count += 1;100    }101102    fn remove(self: *Ranges, at: usize) void {103        std.debug.assert(at < self.count);104        for (0..self.values.len) |offset| {105            const index = at + offset;106            if (index + 1 >= self.count) break;107            self.values[index] = self.values[index + 1];108        }109        self.count -= 1;110    }111};

1pub const Reassembler = struct {2    bytes: []u8,3    present: []u8,4    next_offset: u62 = 0,56    pub const ReceiveError = error{ BufferExceeded, ConflictingData };78    pub fn init(bytes: []u8, present: []u8) Reassembler {9        std.debug.assert(bytes.len == present.len);10        @memset(bytes, 0);11        @memset(present, 0);12        return .{ .bytes = bytes, .present = present };13    }1415    pub fn receive(16        self: *Reassembler,17        offset: u62,18        data: []const u8,19    ) ReceiveError!void {20        const start = std.math.cast(usize, offset) orelse return error.BufferExceeded;21        if (start > self.bytes.len) return error.BufferExceeded;22        if (data.len > self.bytes.len - start) return error.BufferExceeded;23        for (data, 0..) |byte, index| {24            const target = start + index;25            if (self.present[target] != 0 and self.bytes[target] != byte) {26                return error.ConflictingData;27            }28            self.bytes[target] = byte;29            self.present[target] = 1;30        }31    }3233    pub fn contiguous(self: *const Reassembler) []const u8 {34        const start = std.math.cast(usize, self.next_offset) orelse return &.{};35        if (start >= self.bytes.len) return &.{};36        var end = start;37        for (start..self.bytes.len) |index| {38            if (self.present[index] == 0) break;39            end += 1;40        }41        return self.bytes[start..end];42    }4344    pub fn consume(self: *Reassembler, length: usize) void {45        const available = self.contiguous();46        std.debug.assert(length <= available.len);47        self.next_offset += @intCast(length);48    }49};

1pub const State = struct {2    storage: *quic.connection.Storage,3    initial_write: ?quic.crypto.Keys = null,4    initial_read: ?quic.crypto.Keys = null,5    handshake_write: ?quic.crypto.Keys = null,6    handshake_read: ?quic.crypto.Keys = null,7    application_write: ?quic.crypto.Keys = null,8    application_read_previous: ?quic.crypto.Keys = null,9    application_read_current: ?quic.crypto.Keys = null,10    application_read_next: ?quic.crypto.Keys = null,11    application_write_secret: quic.crypto.Secret = @splat(0),12    application_read_secret: quic.crypto.Secret = @splat(0),13    application_read_next_secret: quic.crypto.Secret = @splat(0),14    send_phase: bool = false,15    receive_phase: bool = false,16    previous_read_valid: bool = false,17    first_current_read_packet: u62 = 0,18    receive_update_acknowledged: bool = true,19    previous_read_largest: ?u62 = null,20    update_requested: bool = false,21    update_awaiting_ack: bool = false,22    update_first_packet: ?u62 = null,2324    pub const InstallError = quic.crypto.Keys.InitError || error{UnsupportedCipherSuite};2526    pub fn init(storage: *quic.connection.Storage) State {27        return .{ .storage = storage };28    }2930    pub fn installInitial(31        self: *State,32        role: quic.tls.Role,33        destination: []const u8,34    ) InstallError!void {35        std.debug.assert(self.initial_write == null);36        std.debug.assert(self.initial_read == null);37        const secrets = quic.crypto.initial.secrets(destination);38        const write_secret = if (role == .client) secrets.client else secrets.server;39        const read_secret = if (role == .client) secrets.server else secrets.client;40        self.initial_write = try quic.crypto.Keys.derive(41            self.storage.keys(.initial_write),42            .aes_128_gcm_sha256,43            write_secret,44        );45        self.initial_read = try quic.crypto.Keys.derive(46            self.storage.keys(.initial_read),47            .aes_128_gcm_sha256,48            read_secret,49        );50    }5152    pub fn installTls(self: *State, engine: *const quic.tls.Engine) InstallError!void {53        const suite = try selectedSuite(engine);54        if (self.handshake_write == null) {55            if (engine.secret(.handshake, .write)) |secret| {56                self.handshake_write = try quic.crypto.Keys.derive(57                    self.storage.keys(.handshake_write),58                    suite,59                    secret,60                );61            }62        }63        if (self.handshake_read == null) {64            if (engine.secret(.handshake, .read)) |secret| {65                self.handshake_read = try quic.crypto.Keys.derive(66                    self.storage.keys(.handshake_read),67                    suite,68                    secret,69                );70            }71        }72        try self.installApplicationWrite(engine, suite);73        try self.installApplicationRead(engine, suite);74    }7576    fn installApplicationWrite(77        self: *State,78        engine: *const quic.tls.Engine,79        suite: quic.crypto.Suite,80    ) InstallError!void {81        if (self.application_write != null) return;82        const secret = engine.secret(.one_rtt, .write) orelse return;83        self.application_write_secret = secret;84        self.application_write = try quic.crypto.Keys.derive(85            self.storage.keys(.application_write),86            suite,87            secret,88        );89    }9091    fn installApplicationRead(92        self: *State,93        engine: *const quic.tls.Engine,94        suite: quic.crypto.Suite,95    ) InstallError!void {96        if (self.application_read_current != null) return;97        const secret = engine.secret(.one_rtt, .read) orelse return;98        self.application_read_secret = secret;99        self.application_read_next_secret = quic.crypto.Keys.next(suite, secret);100        self.application_read_previous = try quic.crypto.Keys.derive(101            self.storage.keys(.application_read_previous),102            suite,103            secret,104        );105        self.application_read_current = try quic.crypto.Keys.derive(106            self.storage.keys(.application_read_current),107            suite,108            secret,109        );110        self.application_read_next = try quic.crypto.Keys.derive(111            self.storage.keys(.application_read_next),112            suite,113            secret,114        );115        self.application_read_next.?.update(self.application_read_next_secret);116    }117118    pub fn write(self: *State, kind: quic.connection.SpaceKind) ?*quic.crypto.Keys {119        return switch (kind) {120            .initial => if (self.initial_write) |*keys| keys else null,121            .handshake => if (self.handshake_write) |*keys| keys else null,122            .application => if (self.application_write) |*keys| keys else null,123        };124    }125126    pub fn read(self: *State, kind: quic.connection.SpaceKind) ?*quic.crypto.Keys {127        return switch (kind) {128            .initial => if (self.initial_read) |*keys| keys else null,129            .handshake => if (self.handshake_read) |*keys| keys else null,130            .application => if (self.application_read_current) |*keys| keys else null,131        };132    }133134    pub fn selectApplicationRead(135        self: *State,136        header: quic.crypto.packet.Header,137    ) ?*quic.crypto.Keys {138        const phase = header.key_phase orelse return null;139        if (phase == self.receive_phase) {140            return if (self.application_read_current) |*keys| keys else null;141        }142        if (self.previous_read_valid and header.packet_number < self.first_current_read_packet) {143            return if (self.application_read_previous) |*keys| keys else null;144        }145        return if (self.application_read_next) |*keys| keys else null;146    }147148    pub fn promoteApplicationRead(149        self: *State,150        packet_number: u62,151        next_send: u62,152    ) error{ConsecutiveUpdate}!void {153        std.debug.assert(self.application_read_previous != null);154        std.debug.assert(self.application_read_current != null);155        std.debug.assert(self.application_read_next != null);156        const peer_initiated = self.send_phase == self.receive_phase;157        if (peer_initiated and !self.receive_update_acknowledged) return error.ConsecutiveUpdate;158        std.mem.swap(159            quic.crypto.Keys,160            &self.application_read_previous.?,161            &self.application_read_current.?,162        );163        std.mem.swap(164            quic.crypto.Keys,165            &self.application_read_current.?,166            &self.application_read_next.?,167        );168        self.application_read_secret = self.application_read_next_secret;169        const suite = self.application_read_current.?.selectedSuite();170        self.application_read_next_secret = quic.crypto.Keys.next(171            suite,172            self.application_read_secret,173        );174        self.application_read_next.?.update(self.application_read_next_secret);175        self.previous_read_valid = true;176        self.receive_phase = !self.receive_phase;177        self.first_current_read_packet = packet_number;178        self.previous_read_largest = null;179        self.receive_update_acknowledged = false;180        if (peer_initiated) self.updateWrite(next_send);181        std.debug.assert(self.send_phase == self.receive_phase);182    }183184    pub fn requestUpdate(self: *State) void {185        self.update_requested = true;186    }187188    pub fn prepareSend(self: *State, confirmed: bool, next_packet: u62) void {189        const keys = if (self.application_write) |*value| value else return;190        if (!confirmed) return;191        if (!self.update_requested and !keys.needsUpdate()) return;192        if (self.update_awaiting_ack) return;193        self.updateWrite(next_packet);194        self.update_requested = false;195    }196197    fn updateWrite(self: *State, next_packet: u62) void {198        const keys = &self.application_write.?;199        self.application_write_secret = quic.crypto.Keys.next(200            keys.selectedSuite(),201            self.application_write_secret,202        );203        keys.update(self.application_write_secret);204        self.send_phase = !self.send_phase;205        self.update_awaiting_ack = true;206        self.update_first_packet = next_packet;207    }208209    /// Frees the state that holds a further rotation back, `update_awaiting_ack`, once the peer has210    /// acknowledged something protected by the write keys now in use. The connection hands every211    /// ACK frame that arrives in the application space to this function, so a second key update can212    /// follow the first, because `prepareSend` tests that field before it rotates the write keys213    /// again. An ACK whose largest number falls under the first packet protected by those keys214    /// leaves the state as it was. The call returns at once when write key rotation is already215    /// complete.216    pub fn observeAck(self: *State, value: quic.frame.Ack) void {217        const first = self.update_first_packet orelse return;218        std.debug.assert(self.update_awaiting_ack);219        if (value.largest < first) return;220        self.update_awaiting_ack = false;221        self.update_first_packet = null;222    }223224    /// Marks the peer's most recent phase change as covered by an acknowledgment this endpoint has225    /// now sent. The connection calls this function after it puts an ACK into a 1-RTT packet, so a226    /// peer-driven key update can be followed by another, because `promoteApplicationRead` reads227    /// that mark and turns a second peer-driven rotation away when the mark is missing, answering228    /// `ConsecutiveUpdate`. The number handed in sits at or above the first packet of the phase229    /// being read.230    pub fn observeAckSent(self: *State, largest_received: u62) void {231        std.debug.assert(largest_received >= self.first_current_read_packet);232        self.receive_update_acknowledged = true;233    }234235    /// Pulls the phase boundary down to the number of a packet that arrived behind its neighbors.236    /// That boundary is `first_current_read_packet`, the lowest number the current keys have been237    /// seen to open. The connection reports every 1-RTT packet the current read keys opened to this238    /// function, so the boundary between the two key generations follows the peer's numbering,239    /// which the order of arrival can disturb. The call answers `PreviousKeysAboveCurrent` when the240    /// older keys have opened something higher since the last rotation, because a newer generation241    /// covering a lower number would break the order the peer promised. A number the older keys242    /// handled already leaves the boundary in place, which holds `previous_read_largest` strictly243    /// under the boundary.244    pub fn observeCurrentRead(245        self: *State,246        packet_number: u62,247    ) error{PreviousKeysAboveCurrent}!void {248        std.debug.assert(self.application_read_current != null);249        if (self.previous_read_largest) |largest| {250            std.debug.assert(largest < self.first_current_read_packet);251            if (packet_number < largest) return error.PreviousKeysAboveCurrent;252            if (packet_number == largest) return;253        }254        if (packet_number >= self.first_current_read_packet) return;255        self.first_current_read_packet = packet_number;256    }257258    /// Keeps the highest number the older keys have opened since the last rotation. The connection259    /// reports every 1-RTT packet the older read keys opened to this function, so260    /// `observeCurrentRead` compares a later packet against that number to separate a tolerable261    /// reordering from one it refuses. The number handed in falls under the phase boundary.262    pub fn observePreviousRead(self: *State, packet_number: u62) void {263        std.debug.assert(self.previous_read_valid);264        std.debug.assert(packet_number < self.first_current_read_packet);265        const largest = self.previous_read_largest orelse packet_number;266        self.previous_read_largest = @max(largest, packet_number);267    }268269    pub fn discardInitial(self: *State) void {270        discard(&self.initial_write);271        discard(&self.initial_read);272    }273274    pub fn discardHandshake(self: *State) void {275        discard(&self.handshake_write);276        discard(&self.handshake_read);277    }278279    pub fn deinit(self: *State) void {280        discard(&self.initial_write);281        discard(&self.initial_read);282        discard(&self.handshake_write);283        discard(&self.handshake_read);284        discard(&self.application_write);285        discard(&self.application_read_previous);286        discard(&self.application_read_current);287        discard(&self.application_read_next);288        std.crypto.secureZero(u8, &self.application_write_secret);289        std.crypto.secureZero(u8, &self.application_read_secret);290        std.crypto.secureZero(u8, &self.application_read_next_secret);291    }292};

1/// Primary type for one QUIC endpoint, held by a caller to drive with `receive`, `send`, and2/// `nextTimeout`, reading and writing byte slices its caller owns, and opening no socket of its3/// own. The connection holds a pointer into its storage, so it and that storage both stay at fixed4/// addresses for as long as it lives. The `init` constructor wants a configuration, the limits, and5/// storage already set up for those same limits, and answers `StorageMismatch` for storage set up6/// for others. Inside the connection are one record per packet number space, the key state, the TLS7/// engine, both halves of stream 0, and the send credit and receive window that cover the whole8/// connection. The `deinit` method gives back the TLS storage and the keys, and marks the storage9/// ready for the caller to take back.10pub const Connection = struct {11    config: quic.connection.Config,12    limits: quic.connection.Limits,13    storage: *quic.connection.Storage,14    local_cid: quic.packet.ConnectionId,15    peer_cid: ?quic.packet.ConnectionId,16    original_dcid: ?quic.packet.ConnectionId,17    peer_source_cid: ?quic.packet.ConnectionId,18    engine: ?quic.tls.Engine,19    keys: quic.connection.KeyState,20    spaces: [3]quic.connection.Space,21    crypto_streams: [3]quic.connection.Reassembler,22    crypto_send_offsets: [3]u62 = .{ 0, 0, 0 },23    /// Storage where each packet number space's lost handshake bytes wait for a packet, holding24    /// them until they go out again ahead of anything TLS has newly produced. The `emitCrypto`25    /// method clears them before it asks TLS for anything new. Dropping a space's keys empties its26    /// entry.27    crypto_lost: [3]quic.connection.recovery.LostRange = @splat(.{}),28    status_value: quic.connection.Status = .handshaking,29    close_reason_value: ?quic.connection.CloseReason = null,30    close_pending: bool = false,31    close_deadline_ns: ?u64 = null,32    close_packets_since_response: u16 = 0,33    close_response_packet_limit: u16 = 1,34    pending_ping: bool = false,35    pending_handshake_done: bool = false,36    handshake_done_received: bool = false,37    handshake_confirmed: bool = false,38    handshake_acknowledged: bool = false,39    rtt: quic.connection.recovery.Estimator = .{},40    pto_count: u32 = 0,41    pto_deadline_ns: ?u64 = null,42    pto_space: quic.connection.SpaceKind = .initial,43    /// Timestamp recording when a client first armed its anti-deadlock probe with nothing44    /// outstanding, holding that deadline still across the arming that `send` and `receive` do on45    /// every call. Both `send` and `receive` arm the timer afresh on every call, and this anchor46    /// keeps those calls from pushing the probe further off. The anchor empties once packets go47    /// out, once the peer has proof of this endpoint's address, and once a probe deadline passes.48    pto_anchor_ns: ?u64 = null,49    probe_packets: [3]u8 = @splat(0),50    peer_parameters_authenticated: bool = false,51    peer_parameters: ?quic.transport.Parameters = null,52    stream_send: quic.connection.stream.Send,53    stream_receive: quic.connection.stream.Receive,54    connection_credit: quic.connection.stream.Credit = .{ .limit = 0 },55    connection_window: quic.connection.stream.Window,56    stream_open: bool = false,57    stream_accepted: bool = false,58    peer_streams_bidi: u62 = 0,59    streams_blocked_pending: bool = false,60    streams_blocked_sent: bool = false,61    effective_idle_timeout_ms: u62,62    timer_started: bool = false,63    last_activity_ns: u64 = 0,64    client_address_validated: bool,65    received_before_validation: u64 = 0,66    sent_before_validation: u64 = 0,67    stats_value: quic.connection.Stats = .{},68    deinitialized: bool = false,6970    pub fn init(71        config: quic.connection.Config,72        limits: quic.connection.Limits,73        storage: *quic.connection.Storage,74    ) InitError!Connection {75        const expected = try quic.connection.Storage.Capacity.derive(limits);76        if (storage.phase != .initialization) return error.StorageMismatch;77        if (storage.capacity.storage_bytes != expected.storage_bytes) {78            return error.StorageMismatch;79        }80        if (storage.capacity.stream_receive_offset != expected.stream_receive_offset) {81            return error.StorageMismatch;82        }83        if (config.local_cid.len == 0) return error.InvalidConfig;84        if (config.local_cid.len > quic.packet.connection_id_bytes_max) {85            return error.InvalidConfig;86        }87        if (config.ack_delay_exponent > 20) return error.InvalidConfig;88        const local_cid = quic.packet.ConnectionId.init(config.local_cid) catch89            return error.InvalidConfig;90        var self = Connection{91            .config = config,92            .limits = limits,93            .storage = storage,94            .local_cid = local_cid,95            .peer_cid = null,96            .original_dcid = null,97            .peer_source_cid = null,98            .engine = null,99            .keys = quic.connection.KeyState.init(storage),100            .spaces = initSpaces(storage),101            .crypto_streams = initCryptoStreams(storage),102            .stream_send = quic.connection.stream.Send.init(103                storage.stream_send_bytes,104                storage.stream_sent_ranges,105                0,106            ),107            .stream_receive = quic.connection.stream.Receive.init(108                storage.stream_receive_bytes,109                storage.stream_receive_ranges,110                quic.connection.parameters.streamReceiveWindow(config, limits),111            ),112            .connection_window = quic.connection.stream.Window.init(config.initial_max_data),113            .effective_idle_timeout_ms = config.max_idle_timeout,114            .client_address_validated = config.role == .client,115        };116        errdefer self.keys.deinit();117        if (config.role == .client) try self.initializeClient();118        storage.activate();119        std.debug.assert(self.storage == storage);120        std.debug.assert(self.local_cid.length >= 1);121        return self;122    }123124    pub fn deinit(self: *Connection) void {125        std.debug.assert(!self.deinitialized);126        if (self.engine) |*engine| {127            engine.deinit();128        } else {129            self.storage.tls_storage.activate();130        }131        _ = self.storage.tls_storage.deinit();132        self.keys.deinit();133        self.storage.nested_released = true;134        self.deinitialized = true;135    }136137    pub fn state(self: *const Connection) quic.connection.Status {138        std.debug.assert(!self.deinitialized);139        return self.status_value;140    }141142    pub fn closeReason(self: *const Connection) ?quic.connection.CloseReason {143        std.debug.assert(!self.deinitialized);144        return self.close_reason_value;145    }146147    pub fn stats(self: *const Connection) quic.connection.Stats {148        std.debug.assert(!self.deinitialized);149        return self.stats_value;150    }151152    /// Hands back what the connection has measured of the path, so a caller sees what the153    /// connection's timers rest on.154    pub fn roundTrip(self: *const Connection) quic.connection.recovery.Estimator {155        std.debug.assert(!self.deinitialized);156        return self.rtt;157    }158159    /// Adds up what all three packet number spaces have outstanding, so a caller watching160    /// congestion reads the total bytes in flight.161    pub fn bytesInFlight(self: *const Connection) u64 {162        std.debug.assert(!self.deinitialized);163        var total: u64 = 0;164        for (&self.spaces) |*space_value| total += space_value.bytesInFlight();165        return total;166    }167168    pub fn peer(self: *const Connection) ?quic.tls.Peer {169        std.debug.assert(!self.deinitialized);170        const engine = if (self.engine) |*value| value else return null;171        return engine.peer();172    }173174    pub fn initialKeysDiscarded(self: *const Connection) bool {175        return self.keys.initial_write == null and self.keys.initial_read == null;176    }177178    pub fn handshakeKeysDiscarded(self: *const Connection) bool {179        return self.keys.handshake_write == null and self.keys.handshake_read == null;180    }181182    pub fn requestKeyUpdate(self: *Connection) error{NotEstablished}!void {183        if (self.status_value != .established) return error.NotEstablished;184        self.keys.requestUpdate();185        self.pending_ping = true;186    }187188    pub fn ping(self: *Connection) error{NotEstablished}!void {189        if (self.status_value != .established) return error.NotEstablished;190        self.pending_ping = true;191    }192193    /// Opens stream 0 for a client once the connection is established, and gives back the194    /// identifier 0, so the client obtains stream 0 before it writes. A server gets `NotClient`, a195    /// call made ahead of that point gets `NotEstablished`, and a repeat gets `StreamExists`. A196    /// peer that allows no streams gets `StreamLimit`, and one STREAMS_BLOCKED frame goes in the197    /// queue.198    pub fn openStream(self: *Connection) OpenError!StreamId {199        std.debug.assert(!self.deinitialized);200        if (self.config.role != .client) return error.NotClient;201        if (self.status_value != .established) return error.NotEstablished;202        if (self.stream_open) return error.StreamExists;203        if (self.peer_streams_bidi == 0) {204            if (!self.streams_blocked_sent) self.streams_blocked_pending = true;205            return error.StreamLimit;206        }207        self.stream_open = true;208        return 0;209    }210211    /// Gives a server the identifier 0 once, after the client's first frame for that stream has212    /// arrived, so the server learns that the client has opened stream 0. A client receives null,213    /// and a server asking ahead of that frame or asking a second time also receives null.214    pub fn acceptStream(self: *Connection) ?StreamId {215        std.debug.assert(!self.deinitialized);216        if (self.config.role != .server) return null;217        if (!self.stream_open) return null;218        if (self.stream_accepted) return null;219        self.stream_accepted = true;220        return 0;221    }222223    /// Takes application bytes into the send buffer, as many as the free room allows, and reports224    /// how many it took, providing the entry point for an application to hand stream bytes to the225    /// connection. Bytes go in for identifier 0 on an open stream, while the connection is226    /// handshaking or established.227    pub fn write(self: *Connection, id: StreamId, bytes: []const u8) usize {228        if (!self.streamOpenForApplication(id)) return 0;229        return self.stream_send.write(bytes);230    }231232    /// Settles the final size at whatever has been written so far, so an application ends its side233    /// of the stream. The call acts for identifier 0 on an open stream, while the connection is234    /// handshaking or established.235    pub fn finish(self: *Connection, id: StreamId) void {236        if (!self.streamOpenForApplication(id)) return;237        self.stream_send.finish();238    }239240    /// Copies waiting bytes in offset order and says whether they carry the reader to the FIN,241    /// enabling an application to take received stream bytes and release receive window room back242    /// to the peer. The method copies for identifier 0 on an open stream.243    pub fn read(self: *Connection, id: StreamId, out: []u8) ReadResult {244        if (!self.streamKnown(id)) return .{ .bytes = 0, .fin = false };245        return self.stream_receive.read(&self.connection_window, out);246    }247248    /// Gives up on sending and puts RESET_STREAM in the queue under the caller's code, so an249    /// application abandons its side of the stream. The call acts for identifier 0 on an open250    /// stream, while the connection is handshaking or established.251    pub fn resetStream(self: *Connection, id: StreamId, app_error_code: u62) void {252        if (!self.streamOpenForApplication(id)) return;253        _ = self.stream_send.reset(app_error_code);254    }255256    /// Puts STOP_SENDING in the queue under the caller's code while data may still arrive, so an257    /// application tells the peer to stop sending. The call acts for identifier 0 on an open258    /// stream, while the connection is handshaking or established.259    pub fn stopSending(self: *Connection, id: StreamId, app_error_code: u62) void {260        if (!self.streamOpenForApplication(id)) return;261        _ = self.stream_receive.stop(app_error_code);262    }263264    /// Hands back how far the sending half of an open stream has traveled, so an application sees265    /// whether its data was acknowledged or its reset took effect. The method answers for266    /// identifier 0 on an open stream, and offers null elsewhere.267    pub fn sendState(self: *const Connection, id: StreamId) ?SendState {268        if (!self.streamKnown(id)) return null;269        return self.stream_send.state;270    }271272    /// Hands back how far the receiving half of an open stream has traveled, so an application273    /// sees whether the peer has finished or reset the stream. The method answers for identifier 0274    /// on an open stream, and offers null elsewhere.275    pub fn receiveState(self: *const Connection, id: StreamId) ?ReceiveState {276        if (!self.streamKnown(id)) return null;277        return self.stream_receive.state;278    }279280    /// Hands back how far an open stream's data has traveled and which codes each side sent, so an281    /// application inspects stream progress and exchanged error codes. The method answers for282    /// identifier 0 on an open stream, and offers null elsewhere.283    pub fn streamStats(self: *const Connection, id: StreamId) ?quic.connection.StreamStats {284        if (!self.streamKnown(id)) return null;285        const send_part = &self.stream_send;286        const receive_part = &self.stream_receive;287        return .{288            .bytes_written = send_part.written,289            .bytes_sent = send_part.sent,290            .bytes_released = send_part.acknowledged,291            .bytes_received = receive_part.window.received,292            .bytes_read = receive_part.read_offset,293            .send_final_size = send_part.final_size,294            .receive_final_size = receive_part.final_size,295            .reset_sent_code = send_part.reset_code,296            .reset_received_code = receive_part.reset_code,297            .stop_sending_sent_code = receive_part.stop_code,298        };299    }300301    /// Moves the connection into closing and starts the closing period from the time the caller302    /// gave, so a close unable to reach the wire still ends and the caller receives the deadline to303    /// stop driving the connection. A reason past `close_reason_bytes_max` answers `ReasonTooLong`304    /// and changes nothing. The reason text is copied into the connection's own storage. When305    /// called on a connection that has already left handshaking or established, the call returns306    /// with the status untouched.307    pub fn close(308        self: *Connection,309        error_code: u62,310        application: bool,311        reason: []const u8,312        now_ns: u64,313    ) error{ReasonTooLong}!void {314        std.debug.assert(!self.deinitialized);315        std.debug.assert(close_reason_bytes_max <= self.storage.reason.len);316        if (reason.len > close_reason_bytes_max) return error.ReasonTooLong;317        self.advanceTime(now_ns);318        if (!isOpen(self.status_value)) return;319        std.debug.assert(self.close_deadline_ns == null);320        self.storeReason(error_code, application, null, reason, false);321        self.status_value = .closing;322        self.close_pending = true;323        self.close_deadline_ns = closeDeadline(now_ns);324    }325326    pub fn receive(self: *Connection, datagram: []const u8, now_ns: u64) void {327        std.debug.assert(self.storage.phase == .steady);328        std.debug.assert(!self.deinitialized);329        self.advanceTime(now_ns);330        if (self.status_value == .closed or self.status_value == .draining) return;331        increment(&self.stats_value.datagrams_received);332        if (self.config.role == .server and !self.client_address_validated) {333            self.received_before_validation +|= datagram.len;334        }335        defer self.armProbeTimeout(now_ns);336        if (datagram.len > self.limits.datagram_bytes) {337            increment(&self.stats_value.drops.oversized);338            return;339        }340        if (self.status_value == .closing) self.noteClosingDatagram();341        self.receivePackets(datagram, now_ns);342    }343344    pub fn send(self: *Connection, out: []u8, now_ns: u64) usize {345        std.debug.assert(self.storage.phase == .steady);346        std.debug.assert(!self.deinitialized);347        self.advanceTime(now_ns);348        if (self.status_value == .closed or self.status_value == .draining) return 0;349        if (out.len == 0) return 0;350        if (self.status_value == .closing) return self.sendClosing(out, now_ns);351        if (self.status_value == .established) {352            self.keys.prepareSend(true, self.space(.application).next_packet_number);353        }354        var datagram_length: usize = 0;355        var carries_initial = false;356        const can_coalesce_handshake = self.keys.write(.handshake) != null;357        for ([_]quic.connection.SpaceKind{ .initial, .handshake, .application }) |kind| {358            const limit = self.sendLimit(out.len);359            if (datagram_length >= limit) break;360            const available = limit - datagram_length;361            const minimum = packetMinimum(kind, available, carries_initial, can_coalesce_handshake);362            const force_ping = (kind == .handshake and carries_initial) or363                self.probe_packets[spaceIndex(kind)] != 0;364            const count = self.sendSpace(365                kind,366                out[datagram_length..limit],367                available,368                minimum,369                force_ping,370                now_ns,371            );372            if (kind == .initial and count != 0) carries_initial = true;373            datagram_length += count;374        }375        if (carries_initial) std.debug.assert(datagram_length >= 1200);376        if (datagram_length != 0) self.recordDatagramSent(datagram_length);377        self.armProbeTimeout(now_ns);378        return datagram_length;379    }380381    pub fn nextTimeout(self: *const Connection, now_ns: u64) ?u64 {382        std.debug.assert(self.storage.phase == .steady);383        std.debug.assert(!self.deinitialized);384        const deadline = switch (self.status_value) {385            .handshaking, .established => self.activeDeadline() orelse return null,386            .closing, .draining => self.close_deadline_ns orelse return null,387            .closed => return null,388        };389        return @max(deadline, now_ns);390    }391392    fn activeDeadline(self: *const Connection) ?u64 {393        std.debug.assert(isOpen(self.status_value));394        std.debug.assert(self.close_deadline_ns == null);395        var deadline: ?u64 = null;396        for (&self.spaces) |*space_value| {397            if (space_value.ack_due_at_ns) |due| deadline = earlier(deadline, due);398            if (space_value.loss_deadline_ns) |due| deadline = earlier(deadline, due);399        }400        if (self.pto_deadline_ns) |due| deadline = earlier(deadline, due);401        if (self.idleDeadline()) |idle| deadline = earlier(deadline, idle);402        return deadline;403    }404405    fn initializeClient(self: *Connection) InitError!void {406        std.debug.assert(self.config.role == .client);407        std.debug.assert(self.engine == null);408        var random = self.config.random.values() catch return error.RandomFailed;409        defer std.crypto.secureZero(u8, std.mem.asBytes(&random));410        const destination = quic.packet.ConnectionId.init(random.hello[0..8]) catch411            return error.InvalidConfig;412        self.peer_cid = destination;413        self.original_dcid = destination;414        try self.keys.installInitial(.client, destination.slice());415        const encoded = try quic.connection.parameters.encode(416            self.config,417            self.limits,418            self.local_cid,419            null,420            self.storage.transport,421        );422        self.engine = try quic.tls.Engine.init(.{423            .role = .client,424            .identity = self.config.identity,425            .expected_peer = self.config.expected_peer,426            .alpn = self.config.alpn,427            .transport_parameters = encoded,428            .server_name = self.config.server_name,429            .random = self.config.random,430            .cipher_suite = preferredCipherSuite(self.config.preferred_suite),431        }, .{ .max_message = self.limits.tls_message_max }, &self.storage.tls_storage);432    }433434    fn initializeServer(self: *Connection, view: PacketView, now_ns: u64) bool {435        std.debug.assert(self.config.role == .server);436        std.debug.assert(self.engine == null);437        std.debug.assert(view.kind == .initial);438        std.debug.assert(view.destination.length >= 8);439        const source = view.source orelse return false;440        self.original_dcid = view.destination;441        self.peer_source_cid = source;442        self.peer_cid = source;443        self.keys.installInitial(.server, view.destination.slice()) catch {444            self.fail(quic.connection.TransportError.internal_error, null, "initial keys", now_ns);445            return false;446        };447        const encoded = quic.connection.parameters.encode(448            self.config,449            self.limits,450            self.local_cid,451            view.destination,452            self.storage.transport,453        ) catch {454            self.fail(quic.connection.TransportError.internal_error, null, "parameters", now_ns);455            return false;456        };457        self.engine = quic.tls.Engine.init(.{458            .role = .server,459            .identity = self.config.identity,460            .expected_peer = self.config.expected_peer,461            .alpn = self.config.alpn,462            .transport_parameters = encoded,463            .server_name = self.config.server_name,464            .random = self.config.random,465            .cipher_suite = preferredCipherSuite(self.config.preferred_suite),466        }, .{ .max_message = self.limits.tls_message_max }, &self.storage.tls_storage) catch {467            self.fail(quic.connection.TransportError.internal_error, null, "TLS init", now_ns);468            return false;469        };470        return true;471    }472473    fn receivePackets(self: *Connection, datagram: []const u8, now_ns: u64) void {474        std.debug.assert(datagram.len <= self.limits.datagram_bytes);475        std.debug.assert(self.status_value != .closed);476        var offset: usize = 0;477        var first_destination: ?quic.packet.ConnectionId = null;478        for (0..self.limits.datagram_bytes) |_| {479            if (offset >= datagram.len) break;480            const view = inspectPacket(datagram[offset..], self.local_cid.length) catch |failure| {481                if (failure == error.Malformed) increment(&self.stats_value.drops.malformed);482                if (failure == error.Unsupported) increment(&self.stats_value.drops.unsupported);483                return;484            };485            if (first_destination == null) first_destination = view.destination;486            if (!sameCid(first_destination.?, view.destination)) {487                increment(&self.stats_value.drops.wrong_connection);488                offset += view.length;489                continue;490            }491            self.receivePacket(datagram[offset..][0..view.length], datagram.len, view, now_ns);492            if (self.status_value == .draining or self.status_value == .closed) return;493            offset += view.length;494            if (view.kind == .application) break;495        }496    }497498    /// Admits one packet by opening the packet, working through the payload, and writing the packet499    /// number into the space, serving as the single admission path that keeps the key state honest500    /// through the order of its steps. The key state is written last, after the payload has been501    /// worked through and the number written. That order holds because a packet can decrypt and502    /// still be dropped without ending the connection, and the key state is meant to describe the503    /// packets this endpoint took. A number the space holds already counts as a repeat, and the504    /// packet goes no further. A server taking in a Handshake packet has its proof of the client's505    /// address, and drops its Initial keys.506    fn receivePacket(507        self: *Connection,508        packet_bytes: []const u8,509        datagram_length: usize,510        view: PacketView,511        now_ns: u64,512    ) void {513        std.debug.assert(packet_bytes.len <= datagram_length);514        std.debug.assert(datagram_length <= self.limits.datagram_bytes);515        if (self.config.role == .server and self.engine == null and516            view.kind == .initial and view.destination.length < 8)517        {518            increment(&self.stats_value.drops.malformed);519            return;520        }521        if (self.config.role == .server and view.kind == .initial and datagram_length < 1200) {522            increment(&self.stats_value.drops.undersized_initial);523            return;524        }525        if (self.config.role == .server and self.engine == null) {526            if (view.kind != .initial) {527                increment(&self.stats_value.drops.unavailable_keys);528                return;529            }530            if (!self.initializeServer(view, now_ns)) return;531        }532        if (!self.validateConnectionIds(view)) {533            increment(&self.stats_value.drops.wrong_connection);534            return;535        }536        @memcpy(self.storage.packet[0..packet_bytes.len], packet_bytes);537        const mutable = self.storage.packet[0..packet_bytes.len];538        const result = self.openPacket(view, mutable, now_ns) orelse return;539        const opened = result.opened;540        const space_value = self.space(view.kind);541        if (space_value.received.contains(opened.packet_number)) {542            increment(&self.stats_value.drops.duplicate);543            return;544        }545        const ack_eliciting = self.processPayload(view.kind, opened.payload, now_ns) orelse return;546        const accepted = space_value.recordReceived(547            opened.packet_number,548            ack_eliciting,549            now_ns,550            maxAckDelayNs(self.config.max_ack_delay),551        );552        std.debug.assert(accepted);553        if (view.kind == .application and isOpen(self.status_value)) {554            const observed = self.observeApplicationRead(555                opened.packet_number,556                result.phase_changed,557                now_ns,558            );559            if (!observed) return;560        }561        if (self.keys.write(view.kind) == null) space_value.clearAck();562        increment(&self.stats_value.packets_received);563        self.touchActivity(now_ns);564        if (self.config.role == .server and view.kind == .handshake) {565            self.client_address_validated = true;566            self.discardInitialKeys();567        }568    }569570    fn openPacket(571        self: *Connection,572        view: PacketView,573        bytes: []u8,574        now_ns: u64,575    ) ?OpenedPacket {576        std.debug.assert(bytes.len <= self.limits.datagram_bytes);577        const space_value = self.space(view.kind);578        if (view.kind != .application) {579            const read_keys = self.keys.read(view.kind) orelse {580                increment(&self.stats_value.drops.unavailable_keys);581                return null;582            };583            const long = quic.crypto.packet.open(584                read_keys,585                bytes,586                self.storage.scratch,587                view.packet_number_offset,588                space_value.largest_received,589            ) catch |failure| return self.openFailure(read_keys, failure, now_ns);590            return .{ .opened = long, .phase_changed = false };591        }592        const header_keys = self.keys.read(.application) orelse {593            increment(&self.stats_value.drops.unavailable_keys);594            return null;595        };596        const header = quic.crypto.packet.unprotect(597            header_keys,598            bytes,599            view.packet_number_offset,600            space_value.largest_received,601        ) catch {602            increment(&self.stats_value.drops.malformed);603            return null;604        };605        const phase_changed = header.key_phase.? != self.keys.receive_phase;606        const read_keys = self.keys.selectApplicationRead(header) orelse {607            increment(&self.stats_value.drops.unavailable_keys);608            return null;609        };610        const opened = quic.crypto.packet.openPayload(611            read_keys,612            bytes,613            header,614            self.storage.scratch,615        ) catch |failure| return self.openFailure(read_keys, failure, now_ns);616        return .{ .opened = opened, .phase_changed = phase_changed };617    }618619    /// Writes one accepted 1-RTT packet into the key state, recognizing a key update and closing620    /// the connection on an illegal update. A packet of the phase now being read, arriving behind621    /// its neighbors, pulls the boundary down. A packet of the other phase sitting under that622    /// boundary is written against the older keys. A packet of the other phase in any other623    /// position moves the read keys on a generation. Either check failing ends the connection with624    /// KEY_UPDATE_ERROR and answers false. The caller has written the number down already, which625    /// holds the first packet of the phase now being read at or under the space's largest received626    /// number.627    fn observeApplicationRead(628        self: *Connection,629        packet_number: u62,630        phase_changed: bool,631        now_ns: u64,632    ) bool {633        std.debug.assert(self.keys.application_read_current != null);634        std.debug.assert(isOpen(self.status_value));635        std.debug.assert(self.space(.application).largest_received != null);636        std.debug.assert(self.space(.application).largest_received.? >= packet_number);637        const key_update_error = quic.connection.TransportError.key_update_error;638        if (!phase_changed) {639            self.keys.observeCurrentRead(packet_number) catch {640                self.fail(key_update_error, null, "previous keys above current packet", now_ns);641                return false;642            };643            return true;644        }645        const uses_previous = self.keys.previous_read_valid and646            packet_number < self.keys.first_current_read_packet;647        if (uses_previous) {648            self.keys.observePreviousRead(packet_number);649            return true;650        }651        const next_send = self.space(.application).next_packet_number;652        self.keys.promoteApplicationRead(packet_number, next_send) catch {653            self.fail(key_update_error, null, "consecutive key update", now_ns);654            return false;655        };656        return true;657    }658659    fn openFailure(660        self: *Connection,661        read_keys: *quic.crypto.Keys,662        failure: quic.crypto.packet.OpenError,663        now_ns: u64,664    ) ?OpenedPacket {665        if (failure == error.AuthenticationFailed) {666            increment(&self.stats_value.drops.unauthenticated);667            increment(&self.stats_value.failed_authentications);668            if (self.stats_value.failed_authentications >= read_keys.integrityLimit()) {669                self.fail(670                    quic.connection.TransportError.aead_limit_reached,671                    null,672                    "AEAD integrity limit",673                    now_ns,674                );675            }676            return null;677        }678        if (failure == error.IntegrityLimitReached) {679            self.fail(680                quic.connection.TransportError.aead_limit_reached,681                null,682                "AEAD integrity limit",683                now_ns,684            );685            return null;686        }687        if (failure == error.ReservedBits) {688            self.fail(689                quic.connection.TransportError.protocol_violation,690                null,691                "reserved packet bits",692                now_ns,693            );694            return null;695        }696        increment(&self.stats_value.drops.malformed);697        return null;698    }699700    fn processPayload(701        self: *Connection,702        kind: quic.connection.SpaceKind,703        payload: []u8,704        now_ns: u64,705    ) ?bool {706        std.debug.assert(payload.len <= self.limits.datagram_bytes);707        if (payload.len == 0) {708            self.fail(709                quic.connection.TransportError.protocol_violation,710                null,711                "empty packet",712                now_ns,713            );714            return null;715        }716        var input = quic.cursor.Read.init(payload);717        var ack_eliciting = false;718        for (0..self.limits.datagram_bytes) |_| {719            if (input.remaining() == 0) return ack_eliciting;720            const value = quic.frame.decode(&input) catch {721                self.fail(722                    quic.connection.TransportError.frame_encoding_error,723                    null,724                    "frame encoding",725                    now_ns,726                );727                return null;728            };729            const eliciting = self.processFrame(kind, value, now_ns) orelse return null;730            if (eliciting) ack_eliciting = true;731            if (self.status_value == .draining) return ack_eliciting;732        }733        unreachable;734    }735736    fn processFrame(737        self: *Connection,738        kind: quic.connection.SpaceKind,739        value: quic.frame.Frame,740        now_ns: u64,741    ) ?bool {742        std.debug.assert(self.status_value != .draining);743        std.debug.assert(self.status_value != .closed);744        if (self.status_value == .closing and value != .connection_close) return false;745        return switch (value) {746            .padding => false,747            .ping => true,748            .ack => |ack| self.processAck(kind, ack, now_ns),749            .crypto => |crypto_frame| self.processCrypto(kind, crypto_frame, now_ns),750            .handshake_done => self.processHandshakeDone(kind, now_ns),751            .connection_close => |close_frame| self.processClose(kind, close_frame, now_ns),752            .stream,753            .reset_stream,754            .stop_sending,755            .max_data,756            .max_stream_data,757            .max_streams,758            .data_blocked,759            .stream_data_blocked,760            .streams_blocked,761            => self.processStreamFrame(kind, value, now_ns),762            else => {763                self.fail(764                    quic.connection.TransportError.protocol_violation,765                    frameType(value),766                    "frame not implemented",767                    now_ns,768                );769                return null;770            },771        };772    }773774    fn processAck(775        self: *Connection,776        kind: quic.connection.SpaceKind,777        value: quic.frame.Ack,778        now_ns: u64,779    ) ?bool {780        const sink = AckSink{ .connection = self, .kind = kind };781        const acknowledged = self.space(kind).processAck(value, sink) catch {782            self.fail(783                quic.connection.TransportError.protocol_violation,784                0x02,785                "ACK for unsent packet",786                now_ns,787            );788            return null;789        };790        self.sampleRoundTrip(kind, value, acknowledged, now_ns);791        if (kind == .handshake) self.handshake_acknowledged = true;792        if (acknowledged.records != 0 and self.peerCompletedAddressValidation()) self.pto_count = 0;793        self.detectLoss(kind, now_ns);794        if (kind == .application) self.keys.observeAck(value);795        return false;796    }797798    /// Runs one detection pass over a space at the delay in force, serving as the single function799    /// starting loss detection so every pass uses the same delay. That delay is worked out from the800    /// latest and the smoothed measurement of the path. Whatever the pass removed is added to the801    /// connection's counters.802    fn detectLoss(self: *Connection, kind: quic.connection.SpaceKind, now_ns: u64) void {803        const delay_ns = quic.connection.recovery.lossDelayNs(804            self.rtt.latest_ns,805            self.rtt.smoothed_ns,806        );807        const sink = LossSink{ .connection = self, .kind = kind };808        const lost = self.space(kind).detectLost(now_ns, delay_ns, sink);809        self.stats_value.bytes_lost +|= lost.bytes;810    }811812    /// Arms the one recovery deadline the connection reports, deciding which single deadline813    /// `nextTimeout` will report for recovery. While any space is waiting on the time rule, that814    /// wait governs and no probe is armed at all. With packets outstanding the function arms the815    /// soonest probe, unless an unvalidated server could not afford to send it. With nothing816    /// outstanding the function arms a client's anti-deadlock probe. A connection that has left817    /// handshaking or established arms nothing.818    fn armProbeTimeout(self: *Connection, now_ns: u64) void {819        self.pto_deadline_ns = null;820        if (!isOpen(self.status_value)) {821            self.pto_anchor_ns = null;822            return;823        }824        for (&self.spaces) |*space_value| {825            if (space_value.loss_deadline_ns == null) continue;826            self.pto_anchor_ns = null;827            return;828        }829        if (self.bytesInFlight() != 0) {830            self.pto_anchor_ns = null;831            const probe = self.armedProbe() orelse return;832            if (self.amplificationBlocks(probe.kind)) return;833            self.pto_deadline_ns = probe.deadline_ns;834            self.pto_space = probe.kind;835            return;836        }837        self.armDeadlockProbe(now_ns);838    }839840    /// Arms the anti-deadlock probe from the anchor, keeping a client sending while it waits for a841    /// server flight that never came. A client keeps it armed with nothing outstanding until a842    /// Handshake acknowledgment, or a confirmed handshake, gives the peer its proof of the address.843    /// It points at the Handshake space if Handshake keys exist, and at the Initial space if844    /// Handshake keys are absent. With no write keys in the space it picked, the function leaves845    /// the timer disarmed and empties the anchor.846    fn armDeadlockProbe(self: *Connection, now_ns: u64) void {847        std.debug.assert(self.bytesInFlight() == 0);848        if (self.peerCompletedAddressValidation()) {849            self.pto_anchor_ns = null;850            return;851        }852        const kind: quic.connection.SpaceKind =853            if (self.keys.write(.handshake) != null) .handshake else .initial;854        if (self.keys.write(kind) == null) {855            self.pto_anchor_ns = null;856            return;857        }858        const anchor_ns = self.pto_anchor_ns orelse now_ns;859        self.pto_anchor_ns = anchor_ns;860        self.pto_space = kind;861        self.pto_deadline_ns = quic.connection.recovery.probeDeadlineNs(862            anchor_ns,863            self.probePeriodNs(kind),864        );865    }866867    /// Picks the soonest probe deadline among the spaces holding packets the peer has yet to868    /// settle, selecting the single winning probe timer among the three spaces. Each space measures869    /// its deadline from the last packet it sent that the peer owes an answer to. The application870    /// space is left out until the handshake is confirmed. With all spaces settled, the function871    /// returns null.872    fn armedProbe(self: *const Connection) ?Probe {873        var earliest: ?Probe = null;874        for ([_]quic.connection.SpaceKind{ .initial, .handshake, .application }) |kind| {875            const space_value = &self.spaces[spaceIndex(kind)];876            if (space_value.bytesInFlight() == 0) continue;877            if (kind == .application and !self.handshake_confirmed) break;878            const sent_ns = space_value.last_ack_eliciting_sent_ns orelse continue;879            const deadline_ns = quic.connection.recovery.probeDeadlineNs(880                sent_ns,881                self.probePeriodNs(kind),882            );883            if (earliest) |current| {884                if (deadline_ns >= current.deadline_ns) continue;885            }886            earliest = .{ .deadline_ns = deadline_ns, .kind = kind };887        }888        return earliest;889    }890891    /// Works out how long one space waits for an answer, at the doubling now in force, defining the892    /// period added to a send time for every probe deadline. The wait rests on the connection's893    /// smoothed measurement and its spread.894    fn probePeriodNs(self: *const Connection, kind: quic.connection.SpaceKind) u64 {895        const delay_ns = self.probeAckDelayNs(kind);896        return quic.connection.recovery.probePeriodNs(897            self.rtt.smoothed_ns,898            self.rtt.variation_ns,899            delay_ns,900            self.pto_count,901        );902    }903904    /// Reads the peer's `max_ack_delay` parameter into nanoseconds, for the application space and905    /// only past handshake confirmation, isolating the rule that adds the peer's delay only in one906    /// space and only after one point. It yields zero for the other two spaces, ahead of that907    /// confirmation, and before the peer's parameters have arrived.908    fn probeAckDelayNs(self: *const Connection, kind: quic.connection.SpaceKind) u64 {909        if (kind != .application) return 0;910        if (!self.handshake_confirmed) return 0;911        const parameters = self.peer_parameters orelse return 0;912        return maxAckDelayNs(parameters.max_ack_delay);913    }914915    /// Says whether the peer has proof of this endpoint's address, deciding both whether the916    /// anti-deadlock probe stays armed and whether an acknowledgment resets the backoff. A server917    /// always has it, because a client proves the server's address by finishing the handshake with918    /// it. A client has it once a Handshake acknowledgment arrives, or once the handshake is919    /// confirmed.920    fn peerCompletedAddressValidation(self: *const Connection) bool {921        if (self.config.role == .server) return true;922        return self.handshake_acknowledged or self.handshake_confirmed;923    }924925    /// Says whether an unvalidated server is short of the budget one probe in the space would cost,926    /// so the timer asks before arming a probe that would spin. That budget is three times what the927    /// client has sent this server, less what the server has sent back. The timer then waits on the928    /// client's next datagram to lift the budget. A client, and a server whose peer is validated,929    /// are never short.930    fn amplificationBlocks(self: *const Connection, kind: quic.connection.SpaceKind) bool {931        if (self.config.role != .server) return false;932        if (self.client_address_validated) return false;933        return self.remainingAmplificationBudget() < sendRoomMin(kind);934    }935936    /// Owes the armed space its probe packets once the deadline has passed, turning an expired937    /// deadline into packets the next `send` call emits. One packet is owed when nothing is938    /// outstanding, and two otherwise. It then lifts the doubling count, empties the anchor the939    /// anti-deadlock probe measured from, adds one to the timeout counter, and arms the timer940    /// afresh. `send` puts the owed packets out, forcing a PING into each.941    fn expireProbeTimeout(self: *Connection, now_ns: u64) void {942        std.debug.assert(isOpen(self.status_value));943        const deadline = self.pto_deadline_ns orelse return;944        if (now_ns < deadline) return;945        const kind = self.pto_space;946        const owed: u8 = if (self.bytesInFlight() == 0)947            1948        else949            quic.connection.recovery.probe_packets;950        self.probe_packets[spaceIndex(kind)] = owed;951        self.pto_count +|= 1;952        self.pto_anchor_ns = null;953        increment(&self.stats_value.probe_timeouts);954        self.armProbeTimeout(now_ns);955    }956957    /// Runs a detection pass over every space whose wait has run out, providing the path through958    /// which a caller calling back at the reported deadline reaches the loss pass. `receive`,959    /// `send`, and `close` all arrive here by way of `advanceTime`.960    fn detectExpiredLoss(self: *Connection, now_ns: u64) void {961        std.debug.assert(isOpen(self.status_value));962        for ([_]quic.connection.SpaceKind{ .initial, .handshake, .application }) |kind| {963            const deadline = self.space(kind).loss_deadline_ns orelse continue;964            if (now_ns < deadline) continue;965            self.detectLoss(kind, now_ns);966        }967    }968969    /// Measures the path from one ACK frame as the single source feeding the round-trip estimate,970    /// enforcing two conditions that determine whether an acknowledgment contributes a sample. A971    /// measurement wants the ACK frame's largest number to be one this ACK settled first. It also972    /// wants at least one packet the peer owed an answer to among what this ACK settled. What it973    /// measures is the time since that packet went out, less the delay the peer reported.974    fn sampleRoundTrip(975        self: *Connection,976        kind: quic.connection.SpaceKind,977        value: quic.frame.Ack,978        acknowledged: quic.connection.Acknowledged,979        now_ns: u64,980    ) void {981        if (!acknowledged.ack_eliciting) return;982        const sent_ns = acknowledged.largest_sent_ns orelse return;983        const latest_ns = quic.connection.recovery.sample(sent_ns, now_ns) orelse return;984        self.rtt.update(latest_ns, self.peerAckDelayNs(kind, value));985    }986987    /// Works out how much of the gap one ACK's sender says it spent before answering, centralizing988    /// the rule that counts delay only in one space and caps it only after one point. Initial and989    /// Handshake acknowledgments omit this delay figure. The peer's `max_ack_delay` holds that990    /// figure down once the handshake is confirmed. The figure is zero until the peer's parameters991    /// have arrived.992    fn peerAckDelayNs(993        self: *const Connection,994        kind: quic.connection.SpaceKind,995        value: quic.frame.Ack,996    ) u64 {997        const parameters = self.peer_parameters orelse return 0;998        const maximum_ns: ?u64 = if (self.handshake_confirmed)999            maxAckDelayNs(parameters.max_ack_delay)1000        else1001            null;1002        return quic.connection.recovery.reportedDelayNs(1003            kind == .application,1004            value.delay,1005            parameters.ack_delay_exponent,1006            maximum_ns,1007        );1008    }10091010    /// Applies one stream or flow control frame as the entry point where these frames enter the1011    /// connection, which only a 1-RTT packet may carry. The same frame inside an Initial or1012    /// Handshake packet ends the connection with PROTOCOL_VIOLATION. Answering with null leaves the1013    /// packet unacknowledged. An arriving STOP_SENDING resets the sending half, a MAX_STREAM_DATA1014    /// lifts the stream's allowance, and a MAX_DATA lifts the connection's. An arriving MAX_STREAMS1015    /// lifts how many bidirectional streams the peer allows.1016    fn processStreamFrame(1017        self: *Connection,1018        kind: quic.connection.SpaceKind,1019        value: quic.frame.Frame,1020        now_ns: u64,1021    ) ?bool {1022        std.debug.assert(isOpen(self.status_value));1023        if (kind != .application) {1024            self.fail(1025                quic.connection.TransportError.protocol_violation,1026                frameType(value),1027                "stream frame outside 1-RTT",1028                now_ns,1029            );1030            return null;1031        }1032        const received = &self.stats_value.stream_received;1033        switch (value) {1034            .stream => |data| return self.processStreamData(data, now_ns),1035            .reset_stream => |reset| return self.processResetStream(reset, now_ns),1036            .stop_sending => |stop| {1037                if (!self.admitStream(stop.stream_id, 0x05, now_ns)) return null;1038                increment(&received.stop_sending);1039                _ = self.stream_send.reset(stop.error_code);1040            },1041            .max_stream_data => |limit| {1042                if (!self.admitStream(limit.stream_id, 0x11, now_ns)) return null;1043                increment(&received.max_stream_data);1044                self.stream_send.credit.raise(limit.maximum);1045            },1046            .stream_data_blocked => |limit| {1047                if (!self.admitStream(limit.stream_id, 0x15, now_ns)) return null;1048                increment(&received.stream_data_blocked);1049            },1050            .max_data => |maximum| {1051                increment(&received.max_data);1052                self.connection_credit.raise(maximum);1053            },1054            .data_blocked => increment(&received.data_blocked),1055            .max_streams => |limit| {1056                increment(&received.max_streams);1057                if (!limit.unidirectional) {1058                    self.peer_streams_bidi = @max(self.peer_streams_bidi, limit.maximum);1059                }1060            },1061            .streams_blocked => increment(&received.streams_blocked),1062            else => unreachable,1063        }1064        return true;1065    }10661067    /// Puts one STREAM frame's data in order on the receiving half, delivering arriving STREAM data1068    /// to the receiving part of stream 0. With the reassembly table full, the packet goes1069    /// unacknowledged and the `stream_ranges` counter climbs. Data past a window ends the1070    /// connection with FLOW_CONTROL_ERROR, and a final size at odds with one already settled ends1071    /// it with FINAL_SIZE_ERROR.1072    fn processStreamData(self: *Connection, data: quic.frame.Stream, now_ns: u64) ?bool {1073        const frame_type = frameType(.{ .stream = data });1074        if (!self.admitStream(data.stream_id, frame_type, now_ns)) return null;1075        const window = &self.connection_window;1076        self.stream_receive.receive(window, data.offset, data.data, data.fin) catch |failure| {1077            if (failure == error.RangesFull) {1078                increment(&self.stats_value.drops.stream_ranges);1079                return null;1080            }1081            const code = if (failure == error.FlowControl)1082                quic.connection.TransportError.flow_control_error1083            else1084                quic.connection.TransportError.final_size_error;1085            self.fail(code, frame_type, "STREAM data", now_ns);1086            return null;1087        };1088        const received = &self.stats_value.stream_received;1089        increment(&received.stream_frames);1090        received.stream_bytes +|= data.data.len;1091        return true;1092    }10931094    fn processResetStream(self: *Connection, reset: quic.frame.ResetStream, now_ns: u64) ?bool {1095        if (!self.admitStream(reset.stream_id, 0x04, now_ns)) return null;1096        const window = &self.connection_window;1097        const code = reset.error_code;1098        const final = reset.final_size;1099        self.stream_receive.resetReceived(window, code, final) catch |failure| {1100            const transport_code = if (failure == error.FlowControl)1101                quic.connection.TransportError.flow_control_error1102            else1103                quic.connection.TransportError.final_size_error;1104            self.fail(transport_code, 0x04, "RESET_STREAM final size", now_ns);1105            return null;1106        };1107        increment(&self.stats_value.stream_received.reset_stream);1108        return true;1109    }11101111    /// Runs the identifier checks as every frame naming a stream passes through it, and opens1112    /// stream 0 on a server so the server first learns stream 0 exists. A frame naming a stream1113    /// this endpoint should have opened itself ends the connection with STREAM_STATE_ERROR, unless1114    /// it names stream 0 and stream 0 is open. A unidirectional identifier, or one whose sequence1115    /// reaches the advertised limit, ends the connection with STREAM_LIMIT_ERROR. The function1116    /// answers false after ending the connection.1117    fn admitStream(self: *Connection, stream_id: StreamId, frame_type: u62, now_ns: u64) bool {1118        const local: quic.connection.stream.Initiator = switch (self.config.role) {1119            .client => .client,1120            .server => .server,1121        };1122        if (quic.connection.stream.initiator(stream_id) == local) {1123            if (stream_id == 0 and self.stream_open) return true;1124            self.fail(1125                quic.connection.TransportError.stream_state_error,1126                frame_type,1127                "stream not opened",1128                now_ns,1129            );1130            return false;1131        }1132        const limit = quic.connection.parameters.localStreamsBidi(self.config.role);1133        const unidirectional = quic.connection.stream.direction(stream_id) == .unidirectional;1134        if (unidirectional or quic.connection.stream.sequence(stream_id) >= limit) {1135            self.fail(1136                quic.connection.TransportError.stream_limit_error,1137                frame_type,1138                "stream limit",1139                now_ns,1140            );1141            return false;1142        }1143        std.debug.assert(stream_id == 0);1144        self.stream_open = true;1145        return true;1146    }11471148    fn processCrypto(1149        self: *Connection,1150        kind: quic.connection.SpaceKind,1151        value: quic.frame.Crypto,1152        now_ns: u64,1153    ) ?bool {1154        const stream = &self.crypto_streams[spaceIndex(kind)];1155        stream.receive(value.offset, value.data) catch |failure| {1156            const code = if (failure == error.BufferExceeded)1157                quic.connection.TransportError.crypto_buffer_exceeded1158            else1159                quic.connection.TransportError.protocol_violation;1160            self.fail(code, 0x06, "CRYPTO reassembly", now_ns);1161            return null;1162        };1163        if (!self.driveTls(kind, now_ns)) return null;1164        return true;1165    }11661167    fn driveTls(self: *Connection, kind: quic.connection.SpaceKind, now_ns: u64) bool {1168        const engine = if (self.engine) |*value| value else return false;1169        const stream = &self.crypto_streams[spaceIndex(kind)];1170        for (0..self.limits.crypto_buffer_bytes) |_| {1171            const bytes = stream.contiguous();1172            if (bytes.len == 0) break;1173            engine.receive(kind.level(), bytes) catch {1174                const alert = engine.alert() orelse quic.tls.Alert.internal_error;1175                self.fail(@intCast(alert.quicError()), 0x06, "TLS alert", now_ns);1176                return false;1177            };1178            stream.consume(bytes.len);1179        }1180        self.keys.installTls(engine) catch {1181            self.fail(quic.connection.TransportError.internal_error, 0x06, "TLS keys", now_ns);1182            return false;1183        };1184        if (!self.authenticatePeer(now_ns)) return false;1185        self.observeTlsState();1186        return self.status_value != .closing;1187    }11881189    fn authenticatePeer(self: *Connection, now_ns: u64) bool {1190        if (self.peer_parameters_authenticated) return true;1191        const engine = if (self.engine) |*value| value else return true;1192        const peer_info = engine.peer() orelse return true;1193        const source = self.peer_source_cid orelse return true;1194        const parameters = quic.connection.parameters.validatePeer(1195            self.config.role,1196            peer_info.transport_parameters,1197            source,1198            self.original_dcid,1199        ) catch {1200            self.fail(1201                quic.connection.TransportError.transport_parameter_error,1202                null,1203                "transport parameters",1204                now_ns,1205            );1206            return false;1207        };1208        self.peer_parameters = parameters;1209        self.connection_credit.raise(parameters.initial_max_data);1210        const send_limit = quic.connection.parameters.streamSendLimit(1211            self.config.role,1212            parameters,1213        );1214        self.stream_send.credit.raise(send_limit);1215        self.peer_streams_bidi = parameters.initial_max_streams_bidi;1216        self.peer_parameters_authenticated = true;1217        self.effective_idle_timeout_ms = quic.connection.parameters.effectiveIdle(1218            self.config.max_idle_timeout,1219            parameters.max_idle_timeout,1220        );1221        return true;1222    }12231224    fn observeTlsState(self: *Connection) void {1225        std.debug.assert(isOpen(self.status_value));1226        const engine = if (self.engine) |*value| value else return;1227        if (self.config.role != .server) return;1228        if (engine.state() != .handshake_confirmed) return;1229        if (self.status_value == .handshaking) {1230            self.pending_handshake_done = true;1231            self.status_value = .established;1232        }1233        self.handshake_confirmed = true;1234        self.discardHandshakeKeys();1235    }12361237    fn processHandshakeDone(1238        self: *Connection,1239        kind: quic.connection.SpaceKind,1240        now_ns: u64,1241    ) ?bool {1242        std.debug.assert(isOpen(self.status_value));1243        if (kind != .application or self.config.role != .client) {1244            self.fail(1245                quic.connection.TransportError.protocol_violation,1246                0x1e,1247                "invalid HANDSHAKE_DONE",1248                now_ns,1249            );1250            return null;1251        }1252        const engine = if (self.engine) |*value| value else return null;1253        engine.confirm();1254        self.handshake_confirmed = true;1255        self.discardHandshakeKeys();1256        if (self.status_value == .handshaking) self.status_value = .established;1257        self.handshake_done_received = true;1258        increment(&self.stats_value.handshake_done_received);1259        return true;1260    }12611262    fn processClose(1263        self: *Connection,1264        kind: quic.connection.SpaceKind,1265        value: quic.frame.ConnectionClose,1266        now_ns: u64,1267    ) ?bool {1268        if (value.application and kind != .application) {1269            self.fail(1270                quic.connection.TransportError.protocol_violation,1271                0x1d,1272                "application close level",1273                now_ns,1274            );1275            return null;1276        }1277        if (self.status_value != .closing) {1278            self.storeReason(1279                value.error_code,1280                value.application,1281                value.frame_type,1282                value.reason,1283                true,1284            );1285        }1286        self.close_deadline_ns = self.close_deadline_ns orelse closeDeadline(now_ns);1287        self.status_value = .draining;1288        self.close_pending = false;1289        return false;1290    }12911292    fn sendClosing(self: *Connection, out: []u8, now_ns: u64) usize {1293        std.debug.assert(self.status_value == .closing);1294        std.debug.assert(self.close_reason_value != null);1295        if (!self.close_pending) return 0;1296        const kind = self.closeSpace() orelse {1297            self.status_value = .closed;1298            return 0;1299        };1300        const limit = self.sendLimit(out.len);1301        var length: usize = 0;1302        if (kind == .application and self.keys.write(.handshake) != null) {1303            length = self.sendClosePacket(.handshake, out[0..limit], now_ns);1304        }1305        length += self.sendClosePacket(kind, out[length..limit], now_ns);1306        if (length == 0) return 0;1307        std.debug.assert(length <= limit);1308        std.debug.assert(self.close_deadline_ns != null);1309        self.close_pending = false;1310        self.advanceCloseResponseLimit();1311        self.recordDatagramSent(length);1312        return length;1313    }13141315    fn sendClosePacket(1316        self: *Connection,1317        kind: quic.connection.SpaceKind,1318        out: []u8,1319        now_ns: u64,1320    ) usize {1321        std.debug.assert(out.len <= self.limits.datagram_bytes);1322        std.debug.assert(self.keys.write(kind) != null);1323        const packet_limit: usize = if (kind == .initial) 1200 else out.len;1324        if (out.len < packet_limit) return 0;1325        const plan = self.planPacket(kind, packet_limit, now_ns) orelse return 0;1326        var output = quic.cursor.Write.init(self.storage.packet[0..plan.payload_capacity]);1327        const reason = self.close_reason_value.?;1328        const application = reason.application and kind == .application;1329        const converted = reason.application and !application;1330        quic.frame.encode(.{ .connection_close = .{1331            .application = application,1332            .error_code = if (converted)1333                quic.connection.TransportError.application_error1334            else1335                reason.error_code,1336            .frame_type = if (application) null else reason.frame_type orelse 0,1337            .reason = if (converted) &.{} else reason.reason,1338        } }, &output) catch return 0;1339        const payload = Payload{1340            .bytes = output.written(),1341            .summary = .{ .connection_close = true },1342            .ack_eliciting = false,1343            .sent_ack = false,1344            .sent_ping = false,1345            .sent_handshake_done = false,1346            .sent_close = true,1347        };1348        const minimum: u16 = if (kind == .initial) 1200 else 0;1349        const count = self.assemblePayload(kind, plan.number, payload, minimum, out, now_ns);1350        std.debug.assert(count <= out.len);1351        return count;1352    }13531354    fn sendSpace(1355        self: *Connection,1356        kind: quic.connection.SpaceKind,1357        out: []u8,1358        available: usize,1359        minimum_bytes: u16,1360        force_ping: bool,1361        now_ns: u64,1362    ) usize {1363        std.debug.assert(available <= out.len);1364        std.debug.assert(available <= self.limits.datagram_bytes);1365        if (available < sendRoomMin(kind)) return 0;1366        if (self.keys.write(kind) == null) return 0;1367        const payload_limit = if (kind == .initial and minimum_bytes != 0)1368            @min(available, @as(usize, minimum_bytes))1369        else1370            available;1371        const plan = self.planPacket(kind, payload_limit, now_ns) orelse return 0;1372        const payload = self.buildPayload(1373            kind,1374            plan.payload_capacity,1375            force_ping,1376            now_ns,1377        ) catch {1378            self.fail(1379                quic.connection.TransportError.internal_error,1380                null,1381                "packet assembly",1382                now_ns,1383            );1384            return 0;1385        } orelse return 0;1386        return self.assemblePayload(kind, plan.number, payload, minimum_bytes, out, now_ns);1387    }13881389    fn buildPayload(1390        self: *Connection,1391        kind: quic.connection.SpaceKind,1392        available: usize,1393        force_ping: bool,1394        now_ns: u64,1395    ) PayloadError!?Payload {1396        std.debug.assert(available <= self.storage.packet.len);1397        var output = quic.cursor.Write.init(self.storage.packet[0..available]);1398        var payload = Payload{1399            .bytes = &.{},1400            .summary = .{},1401            .ack_eliciting = false,1402            .sent_ack = false,1403            .sent_ping = false,1404            .sent_handshake_done = false,1405            .sent_close = false,1406        };1407        const space_value = self.space(kind);1408        const record_room = space_value.sent.hasCapacity();1409        const application = kind == .application;1410        const eliciting = force_ping or (application and self.applicationFramesPending());1411        const send_ack = space_value.ack_pending and1412            ((record_room and eliciting) or space_value.ackDue(now_ns));1413        if (send_ack) payload.sent_ack = try self.emitAck(space_value, &output, now_ns);1414        payload.summary.ack = payload.sent_ack;1415        if (record_room) {1416            if (application) try self.emitApplicationControl(&output, &payload);1417            if (force_ping and !payload.ack_eliciting) try emitPing(&output, &payload);1418            if (try self.emitCrypto(kind, &output)) |crypto_summary| {1419                payload.summary.crypto = crypto_summary;1420                payload.ack_eliciting = true;1421            }1422            if (application) try self.emitStreamFrames(&output, &payload);1423        }1424        if (output.index == 0) return null;1425        payload.bytes = output.written();1426        return payload;1427    }14281429    fn emitAck(1430        self: *Connection,1431        space_value: *quic.connection.Space,1432        output: *quic.cursor.Write,1433        now_ns: u64,1434    ) PayloadError!bool {1435        const start = output.index;1436        const delay = space_value.ackDelay(now_ns, self.config.ack_delay_exponent);1437        space_value.received.encode(delay, output) catch |failure| switch (failure) {1438            error.NoSpace => {1439                output.index = start;1440                return false;1441            },1442            else => |other| return other,1443        };1444        return true;1445    }14461447    fn emitApplicationControl(1448        self: *Connection,1449        output: *quic.cursor.Write,1450        payload: *Payload,1451    ) PayloadError!void {1452        if (self.pending_handshake_done) {1453            if (try encodeDeferred(output, .{ .handshake_done = {} })) {1454                payload.summary.handshake_done = true;1455                payload.sent_handshake_done = true;1456                payload.ack_eliciting = true;1457            }1458        }1459        if (self.pending_ping) try emitPing(output, payload);1460    }14611462    /// Packs the flow control frames first, and a single STREAM frame for stream 0 after them, into1463    /// whatever room the packet has left, constructing the stream half of one 1-RTT payload. The1464    /// function packs the stream frames once stream 0 is open. A packet that took any of them1465    /// obliges the peer to answer.1466    fn emitStreamFrames(1467        self: *Connection,1468        output: *quic.cursor.Write,1469        payload: *Payload,1470    ) PayloadError!void {1471        const start = output.index;1472        try self.emitConnectionFlow(output, &payload.summary);1473        if (self.stream_open) {1474            try self.emitStreamControl(output, &payload.summary);1475            try self.emitStream(output, &payload.summary);1476        }1477        if (output.index > start) payload.ack_eliciting = true;1478    }14791480    fn emitConnectionFlow(1481        self: *Connection,1482        output: *quic.cursor.Write,1483        summary: *quic.connection.FrameSummary,1484    ) PayloadError!void {1485        if (self.connection_window.update()) |limit| {1486            if (try encodeDeferred(output, .{ .max_data = limit })) {1487                summary.max_data = limit;1488            }1489        }1490        if (self.connectionBlocked()) |limit| {1491            if (try encodeDeferred(output, .{ .data_blocked = limit })) {1492                summary.data_blocked = limit;1493            }1494        }1495        if (self.streams_blocked_pending) {1496            const limit = quic.frame.StreamLimit{1497                .unidirectional = false,1498                .maximum = self.peer_streams_bidi,1499            };1500            if (try encodeDeferred(output, .{ .streams_blocked = limit })) {1501                summary.streams_blocked = limit;1502            }1503        }1504    }15051506    fn emitStreamControl(1507        self: *Connection,1508        output: *quic.cursor.Write,1509        summary: *quic.connection.FrameSummary,1510    ) PayloadError!void {1511        std.debug.assert(self.stream_open);1512        if (self.stream_send.resetFrame(0)) |reset| {1513            if (try encodeDeferred(output, .{ .reset_stream = reset })) {1514                summary.reset_stream = reset;1515            }1516        }1517        if (self.stream_receive.stop_pending) {1518            const code = self.stream_receive.stop_code.?;1519            const stop = quic.frame.StopSending{ .stream_id = 0, .error_code = code };1520            if (try encodeDeferred(output, .{ .stop_sending = stop })) {1521                summary.stop_sending = stop;1522            }1523        }1524        if (self.stream_receive.windowUpdate()) |maximum| {1525            const limit = quic.frame.StreamData{ .stream_id = 0, .maximum = maximum };1526            if (try encodeDeferred(output, .{ .max_stream_data = limit })) {1527                summary.max_stream_data = limit;1528            }1529        }1530        if (self.stream_send.blocked()) |maximum| {1531            const limit = quic.frame.StreamData{ .stream_id = 0, .maximum = maximum };1532            if (try encodeDeferred(output, .{ .stream_data_blocked = limit })) {1533                summary.stream_data_blocked = limit;1534            }1535        }1536    }15371538    /// Packs a single STREAM frame for stream 0, last of all, sizing the frame to whatever room is1539    /// left. Bytes going a second time travel ahead of fresh ones, since the pick starts at the1540    /// sending half's next offset. The length field goes in when padding follows, which occurs when1541    /// the frame would otherwise end short of a full header protection sample. The FIN travels on1542    /// the last byte. A frame too large for the room left keeps its bytes back, for some later1543    /// packet to carry.1544    fn emitStream(1545        self: *Connection,1546        output: *quic.cursor.Write,1547        summary: *quic.connection.FrameSummary,1548    ) PayloadError!void {1549        std.debug.assert(self.stream_open);1550        const send_part = &self.stream_send;1551        const credit = self.connection_credit.available();1552        const offset = send_part.nextOffset();1553        const remaining = output.remaining();1554        const plain_max = frameDataCapacity(0, offset, remaining, false) orelse return;1555        const plain = send_part.nextChunk(plain_max, credit) orelse return;1556        std.debug.assert(plain.offset == offset);1557        const plain_header = frameHeaderBytes(0, offset, plain.data.len, false);1558        const plain_end = output.index + plain_header + plain.data.len;1559        const length_present = plain_end < quic.connection.assemble.sampled_bytes_min;1560        var chunk = plain;1561        if (length_present) {1562            const framed_max = frameDataCapacity(0, offset, remaining, true) orelse return;1563            chunk = send_part.nextChunk(framed_max, credit) orelse return;1564        }1565        const value = quic.connection.stream.frame(0, chunk, length_present);1566        if (!try encodeDeferred(output, value)) return;1567        summary.stream = .{1568            .stream_id = 0,1569            .offset = chunk.offset,1570            .length = @intCast(chunk.data.len),1571            .fin = chunk.fin,1572        };1573    }15741575    /// Packs one CRYPTO frame for the space so handshake bytes reach a packet. Handshake bytes1576    /// waiting in that space go first, and TLS is asked for nothing new. Otherwise fresh TLS bytes1577    /// move the send offset on. TLS has no way to take bytes back, so fresh bytes that will not fit1578    /// the packet join the ones waiting.1579    fn emitCrypto(1580        self: *Connection,1581        kind: quic.connection.SpaceKind,1582        output: *quic.cursor.Write,1583    ) PayloadError!?quic.connection.CryptoSummary {1584        std.debug.assert(output.remaining() <= self.limits.datagram_bytes);1585        const engine = if (self.engine) |*value| value else return null;1586        const index = spaceIndex(kind);1587        std.debug.assert(engine.emitted(kind.level()).len == self.crypto_send_offsets[index]);1588        if (!self.crypto_lost[index].isEmpty()) return self.emitLostCrypto(kind, output);1589        const offset = self.crypto_send_offsets[index];1590        const maximum = cryptoDataCapacity(offset, output.remaining(), self.storage.scratch.len);1591        if (maximum == 0) return null;1592        const count = engine.emit(kind.level(), self.storage.scratch[0..maximum]);1593        std.debug.assert(count <= maximum);1594        if (count == 0) return null;1595        self.crypto_send_offsets[index] += @intCast(count);1596        const data = self.storage.scratch[0..count];1597        if (!try encodeDeferred(output, .{ .crypto = .{ .offset = offset, .data = data } })) {1598            self.crypto_lost[index].add(offset, @intCast(count));1599            return null;1600        }1601        return .{ .offset = offset, .length = @intCast(count) };1602    }16031604    /// Packs one CRYPTO frame from the first waiting offset, carrying as many waiting bytes as fit,1605    /// to rebuild a lost handshake frame from bytes TLS already emitted. The bytes come back out of1606    /// the TLS engine's own record of what it produced. The function takes the packed bytes out of1607    /// the waiting stretch there and then. Doing so there and then is safe, because the packet is1608    /// written down as sent immediately after packing, or the connection fails.1609    fn emitLostCrypto(1610        self: *Connection,1611        kind: quic.connection.SpaceKind,1612        output: *quic.cursor.Write,1613    ) PayloadError!?quic.connection.CryptoSummary {1614        const engine = if (self.engine) |*value| value else return null;1615        const lost = &self.crypto_lost[spaceIndex(kind)];1616        std.debug.assert(!lost.isEmpty());1617        const flight = engine.emitted(kind.level());1618        std.debug.assert(lost.end <= flight.len);1619        const offset = lost.start;1620        const room = output.remaining();1621        const waiting: usize = @intCast(lost.length());1622        const count = cryptoDataCapacity(offset, room, @min(waiting, room));1623        if (count == 0) return null;1624        const data = flight[@intCast(offset)..][0..count];1625        const value = quic.frame.Frame{ .crypto = .{ .offset = offset, .data = data } };1626        if (!try encodeDeferred(output, value)) return null;1627        lost.advance(@intCast(count));1628        return .{ .offset = offset, .length = @intCast(count) };1629    }16301631    fn assemblePayload(1632        self: *Connection,1633        kind: quic.connection.SpaceKind,1634        number: quic.connection.NumberEncoding,1635        payload: Payload,1636        minimum_bytes: u16,1637        out: []u8,1638        now_ns: u64,1639    ) usize {1640        std.debug.assert(out.len <= self.limits.datagram_bytes);1641        std.debug.assert(payload.bytes.len <= self.limits.datagram_bytes);1642        const space_value = self.space(kind);1643        if (payload.ack_eliciting) std.debug.assert(space_value.sent.hasCapacity());1644        const write_keys = self.keys.write(kind) orelse {1645            self.fail(quic.connection.TransportError.internal_error, null, "write keys", now_ns);1646            return 0;1647        };1648        const destination_cid = self.peer_cid orelse {1649            self.fail(quic.connection.TransportError.internal_error, null, "peer CID", now_ns);1650            return 0;1651        };1652        const packet_type: quic.connection.assemble.PacketType = switch (kind) {1653            .initial => .initial,1654            .handshake => .handshake,1655            .application => .one_rtt,1656        };1657        const built = quic.connection.assemble.packet(write_keys, .{1658            .packet_type = packet_type,1659            .destination = destination_cid,1660            .source = self.local_cid,1661            .number = number,1662            .key_phase = self.keys.send_phase,1663            .minimum_bytes = minimum_bytes,1664        }, payload.bytes, out) catch |failure| {1665            if (failure == error.ConfidentialityLimitReached) {1666                self.fail(1667                    quic.connection.TransportError.aead_limit_reached,1668                    null,1669                    "AEAD confidentiality limit",1670                    now_ns,1671                );1672            } else {1673                self.fail(1674                    quic.connection.TransportError.internal_error,1675                    null,1676                    "packet protection",1677                    now_ns,1678                );1679            }1680            return 0;1681        };1682        if (!self.recordPacketSent(space_value, kind, number, payload, built, now_ns)) return 0;1683        self.commitPayload(kind, payload, now_ns);1684        increment(&self.stats_value.packets_sent);1685        self.touchActivityOnSend(now_ns, payload.ack_eliciting);1686        return built.length;1687    }16881689    fn recordPacketSent(1690        self: *Connection,1691        space_value: *quic.connection.Space,1692        kind: quic.connection.SpaceKind,1693        number: quic.connection.NumberEncoding,1694        payload: Payload,1695        built: quic.connection.assemble.Built,1696        now_ns: u64,1697    ) bool {1698        std.debug.assert(built.length <= self.limits.datagram_bytes);1699        std.debug.assert(payload.bytes.len <= built.payload_length);1700        std.debug.assert(number.packet_number == space_value.next_packet_number);1701        if (!payload.ack_eliciting) {1702            space_value.next_packet_number += 1;1703            return true;1704        }1705        space_value.recordSent(.{1706            .packet_number = number.packet_number,1707            .time_sent_ns = now_ns,1708            .ack_eliciting = true,1709            .acknowledged = false,1710            .lost = false,1711            .in_flight_bytes = built.length,1712            .key_phase = self.keys.send_phase,1713            .key_phase_present = kind == .application,1714            .frames = payload.summary,1715        }) catch {1716            self.fail(1717                quic.connection.TransportError.internal_error,1718                null,1719                "sent records",1720                now_ns,1721            );1722            return false;1723        };1724        return true;1725    }17261727    fn planPacket(1728        self: *Connection,1729        kind: quic.connection.SpaceKind,1730        packet_bytes: usize,1731        now_ns: u64,1732    ) ?PacketPlan {1733        std.debug.assert(packet_bytes <= self.limits.datagram_bytes);1734        const destination = self.peer_cid orelse {1735            self.fail(quic.connection.TransportError.internal_error, null, "peer CID", now_ns);1736            return null;1737        };1738        const number = self.space(kind).numberEncoding() catch {1739            self.fail(quic.connection.TransportError.internal_error, null, "packet number", now_ns);1740            return null;1741        };1742        const number_bytes: usize = number.bits / 8;1743        const reserve = packetReserve(1744            kind,1745            packet_bytes,1746            @intCast(number_bytes),1747            destination.length,1748            self.local_cid.length,1749        );1750        const sampled = quic.connection.assemble.sampled_bytes_min - number_bytes;1751        if (reserve + @max(sampled, 1) > packet_bytes) return null;1752        std.debug.assert(reserve < packet_bytes);1753        return .{ .number = number, .payload_capacity = packet_bytes - reserve };1754    }17551756    fn commitPayload(1757        self: *Connection,1758        kind: quic.connection.SpaceKind,1759        payload: Payload,1760        now_ns: u64,1761    ) void {1762        if (payload.sent_ack) {1763            const space_value = self.space(kind);1764            space_value.markAckSent();1765            increment(&self.stats_value.ack_frames_sent);1766            if (kind == .application) self.keys.observeAckSent(space_value.largest_received.?);1767        }1768        if (payload.ack_eliciting) {1769            const owed = &self.probe_packets[spaceIndex(kind)];1770            if (owed.* != 0) owed.* -= 1;1771        }1772        if (payload.sent_ping) self.pending_ping = false;1773        if (payload.sent_handshake_done) {1774            self.pending_handshake_done = false;1775            increment(&self.stats_value.handshake_done_sent);1776        }1777        if (payload.sent_close) self.close_pending = false;1778        if (kind == .application) self.commitStreamFrames(payload.summary);1779        if (kind == .handshake and self.config.role == .client) self.discardInitialKeys();1780        if (kind == .application and self.keys.application_write.?.confidentialityExhausted()) {1781            self.fail(1782                quic.connection.TransportError.aead_limit_reached,1783                null,1784                "AEAD confidentiality limit",1785                now_ns,1786            );1787        }1788    }17891790    fn commitStreamFrames(self: *Connection, summary: quic.connection.FrameSummary) void {1791        const sent_stats = &self.stats_value.stream_sent;1792        if (summary.max_data) |limit| {1793            self.connection_window.advertise(limit);1794            increment(&sent_stats.max_data);1795        }1796        if (summary.data_blocked) |limit| {1797            self.connection_credit.markBlocked(limit);1798            increment(&sent_stats.data_blocked);1799        }1800        if (summary.streams_blocked != null) {1801            self.streams_blocked_pending = false;1802            self.streams_blocked_sent = true;1803            increment(&sent_stats.streams_blocked);1804        }1805        if (summary.reset_stream != null) {1806            self.stream_send.commitReset();1807            increment(&sent_stats.reset_stream);1808        }1809        if (summary.stop_sending != null) {1810            self.stream_receive.stop_pending = false;1811            increment(&sent_stats.stop_sending);1812        }1813        if (summary.max_stream_data) |limit| {1814            self.stream_receive.window.advertise(limit.maximum);1815            increment(&sent_stats.max_stream_data);1816        }1817        if (summary.stream_data_blocked) |limit| {1818            self.stream_send.commitBlocked(limit.maximum);1819            increment(&sent_stats.stream_data_blocked);1820        }1821        const range = summary.stream orelse return;1822        const new_bytes = self.stream_send.commitChunk(range.offset, range.length, range.fin);1823        self.connection_credit.consume(new_bytes);1824        increment(&sent_stats.stream_frames);1825        sent_stats.stream_bytes +|= range.length;1826    }18271828    /// Decides what one lost 1-RTT packet puts back in the queue, centralizing the whole1829    /// retransmission policy for that packet in one place. Stream 0 decides for the STREAM bytes,1830    /// the FIN, the RESET_STREAM, and the STOP_SENDING. The two MAX frames go again, each carrying1831    /// the figure now in force. The three BLOCKED frames go again while the sender still stands at1832    /// the figure the lost one reported. HANDSHAKE_DONE goes again.1833    fn loseApplicationFrames(self: *Connection, frames: quic.connection.FrameSummary) void {1834        std.debug.assert(isOpen(self.status_value));1835        if (frames.handshake_done) self.pending_handshake_done = true;1836        if (frames.max_data) |limit| self.connection_window.loseLimit(limit);1837        if (frames.data_blocked) |limit| self.connection_credit.loseBlocked(limit);1838        if (frames.streams_blocked) |limit| self.loseStreamsBlocked(limit);1839        const send_part = &self.stream_send;1840        const receive_part = &self.stream_receive;1841        if (frames.stream) |range| send_part.lose(range.offset, range.length, range.fin);1842        if (frames.reset_stream != null) send_part.loseReset();1843        if (frames.stop_sending != null) receive_part.loseStop();1844        if (frames.max_stream_data) |limit| receive_part.window.loseLimit(limit.maximum);1845        if (frames.stream_data_blocked) |limit| send_part.credit.loseBlocked(limit.maximum);1846    }18471848    /// Puts STREAMS_BLOCKED back in the queue while stream 0 is still unopened and the peer still1849    /// allows the same number of streams the lost frame reported, resending the blocked report1850    /// while that condition holds.1851    fn loseStreamsBlocked(self: *Connection, limit: quic.frame.StreamLimit) void {1852        std.debug.assert(!limit.unidirectional);1853        if (self.stream_open) return;1854        if (self.peer_streams_bidi != limit.maximum) return;1855        self.streams_blocked_pending = true;1856    }18571858    fn validateConnectionIds(self: *Connection, view: PacketView) bool {1859        if (self.peer_source_cid == null) {1860            const source = view.source orelse return false;1861            if (view.kind != .initial) return false;1862            self.peer_source_cid = source;1863            self.peer_cid = source;1864        } else if (view.source) |source| {1865            if (!sameCid(self.peer_source_cid.?, source)) return false;1866        }1867        if (self.config.role == .server and view.kind == .initial) {1868            if (sameCid(view.destination, self.original_dcid.?)) return true;1869        }1870        return sameCid(view.destination, self.local_cid);1871    }18721873    /// Drops the Initial keys, everything the Initial space held for recovery, and its waiting1874    /// handshake bytes, so an abandoned space leaves no timer or record behind. A client arrives1875    /// here as it sends each Handshake packet, and a server as it takes one in. Only the first call1876    /// does anything, which keeps a repeat from putting the doubling count back to the start.1877    fn discardInitialKeys(self: *Connection) void {1878        if (self.initialKeysDiscarded()) return;1879        self.keys.discardInitial();1880        self.space(.initial).discard();1881        self.crypto_lost[spaceIndex(.initial)] = .{};1882        self.resetProbeTimeout(.initial);1883        std.debug.assert(self.keys.write(.initial) == null);1884        std.debug.assert(self.keys.read(.initial) == null);1885    }18861887    /// Drops the Handshake keys, everything the Handshake space held for recovery, and its waiting1888    /// handshake bytes, so an abandoned space leaves no timer or record behind. A client arrives1889    /// here on each HANDSHAKE_DONE frame it takes in, and a server wherever TLS says the handshake1890    /// stands confirmed. Only the first call does anything, which keeps a repeat from putting the1891    /// doubling count back to the start.1892    fn discardHandshakeKeys(self: *Connection) void {1893        if (self.handshakeKeysDiscarded()) return;1894        self.keys.discardHandshake();1895        self.space(.handshake).discard();1896        self.crypto_lost[spaceIndex(.handshake)] = .{};1897        self.resetProbeTimeout(.handshake);1898        std.debug.assert(self.keys.write(.handshake) == null);1899        std.debug.assert(self.keys.read(.handshake) == null);1900    }19011902    /// Puts the probe timeout of a space whose keys are gone back to the start, so a space that no1903    /// longer exists stops contributing to consecutive backoff timeouts. The doubling count starts1904    /// over, and no probe is owed to that space. The function empties the deadline and the1905    /// anti-deadlock anchor, and every caller leaves through `send` or `receive`, which arm the1906    /// timer afresh.1907    fn resetProbeTimeout(self: *Connection, kind: quic.connection.SpaceKind) void {1908        std.debug.assert(kind != .application);1909        self.pto_count = 0;1910        self.probe_packets[spaceIndex(kind)] = 0;1911        self.pto_deadline_ns = null;1912        self.pto_anchor_ns = null;1913    }19141915    fn noteClosingDatagram(self: *Connection) void {1916        std.debug.assert(self.status_value == .closing);1917        std.debug.assert(self.close_response_packet_limit >= 1);1918        self.close_packets_since_response +|= 1;1919        if (self.close_packets_since_response >= self.close_response_packet_limit) {1920            self.close_pending = true;1921        }1922    }19231924    fn advanceCloseResponseLimit(self: *Connection) void {1925        std.debug.assert(self.status_value == .closing);1926        std.debug.assert(self.close_response_packet_limit >= 1);1927        self.close_packets_since_response = 0;1928        self.close_response_packet_limit *|= 2;1929    }19301931    fn fail(1932        self: *Connection,1933        error_code: u62,1934        frame_type: ?u62,1935        reason: []const u8,1936        now_ns: u64,1937    ) void {1938        switch (self.status_value) {1939            .handshaking, .established => {},1940            .closing => {1941                std.debug.assert(self.close_deadline_ns != null);1942                return;1943            },1944            .draining, .closed => return,1945        }1946        std.debug.assert(self.close_deadline_ns == null);1947        self.storeReason(error_code, false, frame_type, reason, false);1948        self.status_value = .closing;1949        self.close_pending = true;1950        self.close_deadline_ns = closeDeadline(now_ns);1951    }19521953    fn storeReason(1954        self: *Connection,1955        error_code: u62,1956        application: bool,1957        frame_type: ?u62,1958        reason: []const u8,1959        remote: bool,1960    ) void {1961        std.debug.assert(reason.len <= self.storage.reason.len);1962        @memcpy(self.storage.reason[0..reason.len], reason);1963        self.close_reason_value = .{1964            .error_code = error_code,1965            .application = application,1966            .frame_type = frame_type,1967            .reason = self.storage.reason[0..reason.len],1968            .remote = remote,1969        };1970    }19711972    fn closeSpace(self: *Connection) ?quic.connection.SpaceKind {1973        if (self.keys.write(.application) != null) return .application;1974        if (self.keys.write(.handshake) != null) return .handshake;1975        if (self.keys.write(.initial) != null) return .initial;1976        return null;1977    }19781979    /// Says whether an identifier names the one stream this connection has open, providing the1980    /// single initial check for every public method that names an already-open stream. `write`,1981    /// `finish`, `read`, `resetStream`, `stopSending`, `sendState`, `receiveState`, and1982    /// `streamStats` all pass through it. The check asserts that the connection still holds its1983    /// storage, so a call made after the caller took that storage back trips in a debug build.1984    /// Identifier 0 is the one it answers true for.1985    fn streamKnown(self: *const Connection, id: StreamId) bool {1986        std.debug.assert(!self.deinitialized);1987        if (id != 0) return false;1988        return self.stream_open;1989    }19901991    fn streamOpenForApplication(self: *const Connection, id: StreamId) bool {1992        if (!self.streamKnown(id)) return false;1993        return isOpen(self.status_value);1994    }19951996    fn connectionBlocked(self: *const Connection) ?u62 {1997        if (!self.stream_open) return null;1998        const send_part = &self.stream_send;1999        const waiting = send_part.reset_code == null and send_part.sent < send_part.written;2000        return self.connection_credit.blocked(waiting);2001    }20022003    /// Says whether any 1-RTT control, flow control, or stream frame is waiting, which lets an ACK2004    /// travel alongside one because an ACK alone does not oblige the peer to answer. The function2005    /// covers a waiting HANDSHAKE_DONE, PING, and STREAMS_BLOCKED, a connection window figure, and2006    /// a connection blocked report. Once stream 0 is open, the function covers a waiting reset, a2007    /// waiting stop, a stream window figure, a stream blocked report, and a pick ready to go.2008    fn applicationFramesPending(self: *const Connection) bool {2009        if (self.pending_handshake_done) return true;2010        if (self.pending_ping) return true;2011        if (self.streams_blocked_pending) return true;2012        if (self.connection_window.update() != null) return true;2013        if (!self.stream_open) return false;2014        if (self.stream_send.reset_pending) return true;2015        if (self.stream_receive.stop_pending) return true;2016        if (self.stream_receive.windowUpdate() != null) return true;2017        if (self.stream_send.blocked() != null) return true;2018        if (self.connectionBlocked() != null) return true;2019        const credit = self.connection_credit.available();2020        return self.stream_send.nextChunk(std.math.maxInt(u16), credit) != null;2021    }20222023    fn space(self: *Connection, kind: quic.connection.SpaceKind) *quic.connection.Space {2024        std.debug.assert(spaceIndex(kind) < self.spaces.len);2025        return &self.spaces[spaceIndex(kind)];2026    }20272028    fn sendLimit(self: *const Connection, out_length: usize) usize {2029        var limit = @min(out_length, self.limits.datagram_bytes);2030        if (self.config.role == .server and !self.client_address_validated) {2031            limit = @min(limit, self.remainingAmplificationBudget());2032        }2033        return limit;2034    }20352036    fn remainingAmplificationBudget(self: *const Connection) usize {2037        const received = std.math.mul(u64, self.received_before_validation, 3) catch2038            std.math.maxInt(u64);2039        if (received <= self.sent_before_validation) return 0;2040        return std.math.cast(usize, received - self.sent_before_validation) orelse2041            std.math.maxInt(usize);2042    }20432044    fn recordDatagramSent(self: *Connection, length: usize) void {2045        increment(&self.stats_value.datagrams_sent);2046        if (self.config.role == .server and !self.client_address_validated) {2047            self.sent_before_validation +|= length;2048        }2049    }20502051    fn touchActivity(self: *Connection, now_ns: u64) void {2052        self.timer_started = true;2053        self.last_activity_ns = now_ns;2054    }20552056    fn touchActivityOnSend(self: *Connection, now_ns: u64, ack_eliciting: bool) void {2057        if (!ack_eliciting) return;2058        self.touchActivity(now_ns);2059    }20602061    fn idleDeadline(self: *const Connection) ?u64 {2062        if (!self.timer_started) return null;2063        if (self.effective_idle_timeout_ms == 0) return null;2064        const duration = std.math.mul(2065            u64,2066            self.effective_idle_timeout_ms,2067            std.time.ns_per_ms,2068        ) catch std.math.maxInt(u64);2069        return std.math.add(u64, self.last_activity_ns, duration) catch std.math.maxInt(u64);2070    }20712072    fn advanceTime(self: *Connection, now_ns: u64) void {2073        if (self.close_deadline_ns) |deadline| {2074            if (now_ns >= deadline) {2075                self.status_value = .closed;2076                self.close_pending = false;2077                return;2078            }2079        }2080        if (!isOpen(self.status_value)) return;2081        self.detectExpiredLoss(now_ns);2082        if (!isOpen(self.status_value)) return;2083        self.expireProbeTimeout(now_ns);2084        if (!isOpen(self.status_value)) return;2085        const idle = self.idleDeadline() orelse return;2086        if (now_ns < idle) return;2087        self.storeReason(0, false, null, "idle timeout", false);2088        self.status_value = .closed;2089    }2090};